1 | //===- llvm/IR/Statepoint.h - gc.statepoint utilities -----------*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file contains utility functions and a wrapper class analogous to |
10 | // CallBase for accessing the fields of gc.statepoint, gc.relocate, |
11 | // gc.result intrinsics; and some general utilities helpful when dealing with |
12 | // gc.statepoint. |
13 | // |
14 | //===----------------------------------------------------------------------===// |
15 | |
16 | #ifndef LLVM_IR_STATEPOINT_H |
17 | #define LLVM_IR_STATEPOINT_H |
18 | |
19 | #include "llvm/ADT/iterator_range.h" |
20 | #include "llvm/IR/Attributes.h" |
21 | #include "llvm/IR/Constants.h" |
22 | #include "llvm/IR/Function.h" |
23 | #include "llvm/IR/InstrTypes.h" |
24 | #include "llvm/IR/Instructions.h" |
25 | #include "llvm/IR/IntrinsicInst.h" |
26 | #include "llvm/IR/Intrinsics.h" |
27 | #include "llvm/Support/Casting.h" |
28 | #include "llvm/Support/MathExtras.h" |
29 | #include <cassert> |
30 | #include <cstddef> |
31 | #include <cstdint> |
32 | #include <optional> |
33 | #include <vector> |
34 | |
35 | namespace llvm { |
36 | |
37 | /// The statepoint intrinsic accepts a set of flags as its third argument. |
38 | /// Valid values come out of this set. |
39 | enum class StatepointFlags { |
40 | None = 0, |
41 | GCTransition = 1, ///< Indicates that this statepoint is a transition from |
42 | ///< GC-aware code to code that is not GC-aware. |
43 | /// Mark the deopt arguments associated with the statepoint as only being |
44 | /// "live-in". By default, deopt arguments are "live-through". "live-through" |
45 | /// requires that they the value be live on entry, on exit, and at any point |
46 | /// during the call. "live-in" only requires the value be available at the |
47 | /// start of the call. In particular, "live-in" values can be placed in |
48 | /// unused argument registers or other non-callee saved registers. |
49 | DeoptLiveIn = 2, |
50 | |
51 | MaskAll = 3 ///< A bitmask that includes all valid flags. |
52 | }; |
53 | |
54 | // These two are defined in IntrinsicInst since they're part of the |
55 | // IntrinsicInst class hierarchy. |
56 | class GCRelocateInst; |
57 | |
58 | /// Represents a gc.statepoint intrinsic call. This extends directly from |
59 | /// CallBase as the IntrinsicInst only supports calls and gc.statepoint is |
60 | /// invokable. |
61 | class GCStatepointInst : public CallBase { |
62 | public: |
63 | GCStatepointInst() = delete; |
64 | GCStatepointInst(const GCStatepointInst &) = delete; |
65 | GCStatepointInst &operator=(const GCStatepointInst &) = delete; |
66 | |
67 | static bool classof(const CallBase *I) { |
68 | if (const Function *CF = I->getCalledFunction()) |
69 | return CF->getIntrinsicID() == Intrinsic::experimental_gc_statepoint; |
70 | return false; |
71 | } |
72 | |
73 | static bool classof(const Value *V) { |
74 | return isa<CallBase>(Val: V) && classof(I: cast<CallBase>(Val: V)); |
75 | } |
76 | |
77 | enum { |
78 | IDPos = 0, |
79 | NumPatchBytesPos = 1, |
80 | CalledFunctionPos = 2, |
81 | NumCallArgsPos = 3, |
82 | FlagsPos = 4, |
83 | CallArgsBeginPos = 5, |
84 | }; |
85 | |
86 | /// Return the ID associated with this statepoint. |
87 | uint64_t getID() const { |
88 | return cast<ConstantInt>(Val: getArgOperand(i: IDPos))->getZExtValue(); |
89 | } |
90 | |
91 | /// Return the number of patchable bytes associated with this statepoint. |
92 | uint32_t getNumPatchBytes() const { |
93 | const Value *NumPatchBytesVal = getArgOperand(i: NumPatchBytesPos); |
94 | uint64_t NumPatchBytes = |
95 | cast<ConstantInt>(Val: NumPatchBytesVal)->getZExtValue(); |
96 | assert(isInt<32>(NumPatchBytes) && "should fit in 32 bits!" ); |
97 | return NumPatchBytes; |
98 | } |
99 | |
100 | /// Number of arguments to be passed to the actual callee. |
101 | int getNumCallArgs() const { |
102 | return cast<ConstantInt>(Val: getArgOperand(i: NumCallArgsPos))->getZExtValue(); |
103 | } |
104 | |
105 | uint64_t getFlags() const { |
106 | return cast<ConstantInt>(Val: getArgOperand(i: FlagsPos))->getZExtValue(); |
107 | } |
108 | |
109 | /// Return the value actually being called or invoked. |
110 | Value *getActualCalledOperand() const { |
111 | return getArgOperand(i: CalledFunctionPos); |
112 | } |
113 | |
114 | /// Returns the function called if this is a wrapping a direct call, and null |
115 | /// otherwise. |
116 | Function *getActualCalledFunction() const { |
117 | return dyn_cast_or_null<Function>(Val: getActualCalledOperand()); |
118 | } |
119 | |
120 | /// Return the type of the value returned by the call underlying the |
121 | /// statepoint. |
122 | Type *getActualReturnType() const { |
123 | auto *FT = cast<FunctionType>(Val: getParamElementType(ArgNo: CalledFunctionPos)); |
124 | return FT->getReturnType(); |
125 | } |
126 | |
127 | |
128 | /// Return the number of arguments to the underlying call. |
129 | size_t actual_arg_size() const { return getNumCallArgs(); } |
130 | /// Return an iterator to the begining of the arguments to the underlying call |
131 | const_op_iterator actual_arg_begin() const { |
132 | assert(CallArgsBeginPos <= (int)arg_size()); |
133 | return arg_begin() + CallArgsBeginPos; |
134 | } |
135 | /// Return an end iterator of the arguments to the underlying call |
136 | const_op_iterator actual_arg_end() const { |
137 | auto I = actual_arg_begin() + actual_arg_size(); |
138 | assert((arg_end() - I) == 2); |
139 | return I; |
140 | } |
141 | /// range adapter for actual call arguments |
142 | iterator_range<const_op_iterator> actual_args() const { |
143 | return make_range(x: actual_arg_begin(), y: actual_arg_end()); |
144 | } |
145 | |
146 | const_op_iterator gc_transition_args_begin() const { |
147 | if (auto Opt = getOperandBundle(ID: LLVMContext::OB_gc_transition)) |
148 | return Opt->Inputs.begin(); |
149 | return arg_end(); |
150 | } |
151 | const_op_iterator gc_transition_args_end() const { |
152 | if (auto Opt = getOperandBundle(ID: LLVMContext::OB_gc_transition)) |
153 | return Opt->Inputs.end(); |
154 | return arg_end(); |
155 | } |
156 | |
157 | /// range adapter for GC transition arguments |
158 | iterator_range<const_op_iterator> gc_transition_args() const { |
159 | return make_range(x: gc_transition_args_begin(), y: gc_transition_args_end()); |
160 | } |
161 | |
162 | const_op_iterator deopt_begin() const { |
163 | if (auto Opt = getOperandBundle(ID: LLVMContext::OB_deopt)) |
164 | return Opt->Inputs.begin(); |
165 | return arg_end(); |
166 | } |
167 | const_op_iterator deopt_end() const { |
168 | if (auto Opt = getOperandBundle(ID: LLVMContext::OB_deopt)) |
169 | return Opt->Inputs.end(); |
170 | return arg_end(); |
171 | } |
172 | |
173 | /// range adapter for vm state arguments |
174 | iterator_range<const_op_iterator> deopt_operands() const { |
175 | return make_range(x: deopt_begin(), y: deopt_end()); |
176 | } |
177 | |
178 | /// Returns an iterator to the begining of the argument range describing gc |
179 | /// values for the statepoint. |
180 | const_op_iterator gc_args_begin() const { |
181 | if (auto Opt = getOperandBundle(ID: LLVMContext::OB_gc_live)) |
182 | return Opt->Inputs.begin(); |
183 | return arg_end(); |
184 | } |
185 | |
186 | /// Return an end iterator for the gc argument range |
187 | const_op_iterator gc_args_end() const { |
188 | if (auto Opt = getOperandBundle(ID: LLVMContext::OB_gc_live)) |
189 | return Opt->Inputs.end(); |
190 | return arg_end(); |
191 | } |
192 | |
193 | /// range adapter for gc arguments |
194 | iterator_range<const_op_iterator> gc_args() const { |
195 | return make_range(x: gc_args_begin(), y: gc_args_end()); |
196 | } |
197 | |
198 | |
199 | /// Get list of all gc reloactes linked to this statepoint |
200 | /// May contain several relocations for the same base/derived pair. |
201 | /// For example this could happen due to relocations on unwinding |
202 | /// path of invoke. |
203 | inline std::vector<const GCRelocateInst *> getGCRelocates() const; |
204 | }; |
205 | |
206 | std::vector<const GCRelocateInst *> GCStatepointInst::getGCRelocates() const { |
207 | std::vector<const GCRelocateInst *> Result; |
208 | |
209 | // Search for relocated pointers. Note that working backwards from the |
210 | // gc_relocates ensures that we only get pairs which are actually relocated |
211 | // and used after the statepoint. |
212 | for (const User *U : users()) |
213 | if (auto *Relocate = dyn_cast<GCRelocateInst>(Val: U)) |
214 | Result.push_back(x: Relocate); |
215 | |
216 | auto *StatepointInvoke = dyn_cast<InvokeInst>(Val: this); |
217 | if (!StatepointInvoke) |
218 | return Result; |
219 | |
220 | // We need to scan thorough exceptional relocations if it is invoke statepoint |
221 | LandingPadInst *LandingPad = StatepointInvoke->getLandingPadInst(); |
222 | |
223 | // Search for gc relocates that are attached to this landingpad. |
224 | for (const User *LandingPadUser : LandingPad->users()) { |
225 | if (auto *Relocate = dyn_cast<GCRelocateInst>(Val: LandingPadUser)) |
226 | Result.push_back(x: Relocate); |
227 | } |
228 | return Result; |
229 | } |
230 | |
231 | /// Call sites that get wrapped by a gc.statepoint (currently only in |
232 | /// RewriteStatepointsForGC and potentially in other passes in the future) can |
233 | /// have attributes that describe properties of gc.statepoint call they will be |
234 | /// eventually be wrapped in. This struct is used represent such directives. |
235 | struct StatepointDirectives { |
236 | std::optional<uint32_t> NumPatchBytes; |
237 | std::optional<uint64_t> StatepointID; |
238 | |
239 | static const uint64_t DefaultStatepointID = 0xABCDEF00; |
240 | static const uint64_t DeoptBundleStatepointID = 0xABCDEF0F; |
241 | }; |
242 | |
243 | /// Parse out statepoint directives from the function attributes present in \p |
244 | /// AS. |
245 | StatepointDirectives parseStatepointDirectivesFromAttrs(AttributeList AS); |
246 | |
247 | /// Return \c true if the \p Attr is an attribute that is a statepoint |
248 | /// directive. |
249 | bool isStatepointDirectiveAttr(Attribute Attr); |
250 | |
251 | } // end namespace llvm |
252 | |
253 | #endif // LLVM_IR_STATEPOINT_H |
254 | |