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
35namespace llvm {
36
37/// The statepoint intrinsic accepts a set of flags as its third argument.
38/// Valid values come out of this set.
39enum 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.
56class 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.
61class GCStatepointInst : public CallBase {
62public:
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 /// live values for the statepoint.
180 const_op_iterator gc_live_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 live range
187 const_op_iterator gc_live_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 live arguments
194 iterator_range<const_op_iterator> gc_live() const {
195 return make_range(x: gc_live_begin(), y: gc_live_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
206std::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.
235struct 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.
245StatepointDirectives parseStatepointDirectivesFromAttrs(AttributeList AS);
246
247/// Return \c true if the \p Attr is an attribute that is a statepoint
248/// directive.
249bool isStatepointDirectiveAttr(Attribute Attr);
250
251} // end namespace llvm
252
253#endif // LLVM_IR_STATEPOINT_H
254