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
36namespace llvm {
37
38/// The statepoint intrinsic accepts a set of flags as its third argument.
39/// Valid values come out of this set.
40enum 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.
57class GCRelocateInst;
58class 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.
63class GCStatepointInst : public CallBase {
64public:
65 GCStatepointInst() = delete;
66 GCStatepointInst(const GCStatepointInst &) = delete;
67 GCStatepointInst &operator=(const GCStatepointInst &) = delete;
68
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
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.
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.
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.
103 int getNumCallArgs() const {
104 return cast<ConstantInt>(getArgOperand(NumCallArgsPos))->getZExtValue();
105 }
106
107 uint64_t getFlags() const {
108 return cast<ConstantInt>(getArgOperand(FlagsPos))->getZExtValue();
109 }
110
111 /// Return the value actually being called or invoked.
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.
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.
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.
132 size_t actual_arg_size() const { return getNumCallArgs(); }
133 /// Return an iterator to the begining of the arguments to the underlying call
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
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
145 iterator_range<const_op_iterator> actual_args() const {
146 return make_range(actual_arg_begin(), actual_arg_end());
147 }
148
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 }
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
161 iterator_range<const_op_iterator> gc_transition_args() const {
162 return make_range(gc_transition_args_begin(), gc_transition_args_end());
163 }
164
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 }
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
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.
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
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
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
214std::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
239std::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.
255struct 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.
265StatepointDirectives parseStatepointDirectivesFromAttrs(AttributeList AS);
266
267/// Return \c true if the \p Attr is an attribute that is a statepoint
268/// directive.
269bool isStatepointDirectiveAttr(Attribute Attr);
270
271} // end namespace llvm
272
273#endif // LLVM_IR_STATEPOINT_H
274