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