LLVM 19.0.0git
TargetCallingConv.h
Go to the documentation of this file.
1//===-- llvm/CodeGen/TargetCallingConv.h - Calling Convention ---*- 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 defines types for working with calling-convention information.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CODEGEN_TARGETCALLINGCONV_H
14#define LLVM_CODEGEN_TARGETCALLINGCONV_H
15
20#include <cassert>
21#include <climits>
22#include <cstdint>
23
24namespace llvm {
25namespace ISD {
26
27 struct ArgFlagsTy {
28 private:
29 unsigned IsZExt : 1; ///< Zero extended
30 unsigned IsSExt : 1; ///< Sign extended
31 unsigned IsInReg : 1; ///< Passed in register
32 unsigned IsSRet : 1; ///< Hidden struct-ret ptr
33 unsigned IsByVal : 1; ///< Struct passed by value
34 unsigned IsByRef : 1; ///< Passed in memory
35 unsigned IsNest : 1; ///< Nested fn static chain
36 unsigned IsReturned : 1; ///< Always returned
37 unsigned IsSplit : 1;
38 unsigned IsInAlloca : 1; ///< Passed with inalloca
39 unsigned IsPreallocated : 1; ///< ByVal without the copy
40 unsigned IsSplitEnd : 1; ///< Last part of a split
41 unsigned IsSwiftSelf : 1; ///< Swift self parameter
42 unsigned IsSwiftAsync : 1; ///< Swift async context parameter
43 unsigned IsSwiftError : 1; ///< Swift error parameter
44 unsigned IsCFGuardTarget : 1; ///< Control Flow Guard target
45 unsigned IsHva : 1; ///< HVA field for
46 unsigned IsHvaStart : 1; ///< HVA structure start
47 unsigned IsSecArgPass : 1; ///< Second argument
48 unsigned MemAlign : 4; ///< Log 2 of alignment when arg is passed in memory
49 ///< (including byval/byref). The max alignment is
50 ///< verified in IR verification.
51 unsigned OrigAlign : 5; ///< Log 2 of original alignment
52 unsigned IsInConsecutiveRegsLast : 1;
53 unsigned IsInConsecutiveRegs : 1;
54 unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate
55 unsigned IsPointer : 1;
56
57 unsigned ByValOrByRefSize = 0; ///< Byval or byref struct size
58
59 unsigned PointerAddrSpace = 0; ///< Address space of pointer argument
60
61 public:
63 : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsByRef(0),
64 IsNest(0), IsReturned(0), IsSplit(0), IsInAlloca(0),
65 IsPreallocated(0), IsSplitEnd(0), IsSwiftSelf(0), IsSwiftAsync(0),
66 IsSwiftError(0), IsCFGuardTarget(0), IsHva(0), IsHvaStart(0),
67 IsSecArgPass(0), MemAlign(0), OrigAlign(0),
68 IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
69 IsCopyElisionCandidate(0), IsPointer(0) {
70 static_assert(sizeof(*this) == 3 * sizeof(unsigned), "flags are too big");
71 }
72
73 bool isZExt() const { return IsZExt; }
74 void setZExt() { IsZExt = 1; }
75
76 bool isSExt() const { return IsSExt; }
77 void setSExt() { IsSExt = 1; }
78
79 bool isInReg() const { return IsInReg; }
80 void setInReg() { IsInReg = 1; }
81
82 bool isSRet() const { return IsSRet; }
83 void setSRet() { IsSRet = 1; }
84
85 bool isByVal() const { return IsByVal; }
86 void setByVal() { IsByVal = 1; }
87
88 bool isByRef() const { return IsByRef; }
89 void setByRef() { IsByRef = 1; }
90
91 bool isInAlloca() const { return IsInAlloca; }
92 void setInAlloca() { IsInAlloca = 1; }
93
94 bool isPreallocated() const { return IsPreallocated; }
95 void setPreallocated() { IsPreallocated = 1; }
96
97 bool isSwiftSelf() const { return IsSwiftSelf; }
98 void setSwiftSelf() { IsSwiftSelf = 1; }
99
100 bool isSwiftAsync() const { return IsSwiftAsync; }
101 void setSwiftAsync() { IsSwiftAsync = 1; }
102
103 bool isSwiftError() const { return IsSwiftError; }
104 void setSwiftError() { IsSwiftError = 1; }
105
106 bool isCFGuardTarget() const { return IsCFGuardTarget; }
107 void setCFGuardTarget() { IsCFGuardTarget = 1; }
108
109 bool isHva() const { return IsHva; }
110 void setHva() { IsHva = 1; }
111
112 bool isHvaStart() const { return IsHvaStart; }
113 void setHvaStart() { IsHvaStart = 1; }
114
115 bool isSecArgPass() const { return IsSecArgPass; }
116 void setSecArgPass() { IsSecArgPass = 1; }
117
118 bool isNest() const { return IsNest; }
119 void setNest() { IsNest = 1; }
120
121 bool isReturned() const { return IsReturned; }
122 void setReturned(bool V = true) { IsReturned = V; }
123
124 bool isInConsecutiveRegs() const { return IsInConsecutiveRegs; }
125 void setInConsecutiveRegs(bool Flag = true) { IsInConsecutiveRegs = Flag; }
126
127 bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; }
128 void setInConsecutiveRegsLast(bool Flag = true) {
129 IsInConsecutiveRegsLast = Flag;
130 }
131
132 bool isSplit() const { return IsSplit; }
133 void setSplit() { IsSplit = 1; }
134
135 bool isSplitEnd() const { return IsSplitEnd; }
136 void setSplitEnd() { IsSplitEnd = 1; }
137
138 bool isCopyElisionCandidate() const { return IsCopyElisionCandidate; }
139 void setCopyElisionCandidate() { IsCopyElisionCandidate = 1; }
140
141 bool isPointer() const { return IsPointer; }
142 void setPointer() { IsPointer = 1; }
143
145 return decodeMaybeAlign(MemAlign).valueOrOne();
146 }
147
149 MemAlign = encode(A);
150 assert(getNonZeroMemAlign() == A && "bitfield overflow");
151 }
152
154 assert(isByVal());
155 MaybeAlign A = decodeMaybeAlign(MemAlign);
156 assert(A && "ByValAlign must be defined");
157 return *A;
158 }
159
161 return decodeMaybeAlign(OrigAlign).valueOrOne();
162 }
163
165 OrigAlign = encode(A);
166 assert(getNonZeroOrigAlign() == A && "bitfield overflow");
167 }
168
169 unsigned getByValSize() const {
170 assert(isByVal() && !isByRef());
171 return ByValOrByRefSize;
172 }
173 void setByValSize(unsigned S) {
174 assert(isByVal() && !isByRef());
175 ByValOrByRefSize = S;
176 }
177
178 unsigned getByRefSize() const {
179 assert(!isByVal() && isByRef());
180 return ByValOrByRefSize;
181 }
182 void setByRefSize(unsigned S) {
183 assert(!isByVal() && isByRef());
184 ByValOrByRefSize = S;
185 }
186
187 unsigned getPointerAddrSpace() const { return PointerAddrSpace; }
188 void setPointerAddrSpace(unsigned AS) { PointerAddrSpace = AS; }
189};
190
191 /// InputArg - This struct carries flags and type information about a
192 /// single incoming (formal) argument or incoming (from the perspective
193 /// of the caller) return value virtual register.
194 ///
195 struct InputArg {
197 MVT VT = MVT::Other;
199 bool Used = false;
200
201 /// Index original Function's argument.
202 unsigned OrigArgIndex;
203 /// Sentinel value for implicit machine-level input arguments.
204 static const unsigned NoArgIndex = UINT_MAX;
205
206 /// Offset in bytes of current input value relative to the beginning of
207 /// original argument. E.g. if argument was splitted into four 32 bit
208 /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12.
209 unsigned PartOffset;
210
211 InputArg() = default;
212 InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
213 unsigned origIdx, unsigned partOffs)
214 : Flags(flags), Used(used), OrigArgIndex(origIdx), PartOffset(partOffs) {
215 VT = vt.getSimpleVT();
216 ArgVT = argvt;
217 }
218
219 bool isOrigArg() const {
220 return OrigArgIndex != NoArgIndex;
221 }
222
223 unsigned getOrigArgIndex() const {
224 assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");
225 return OrigArgIndex;
226 }
227 };
228
229 /// OutputArg - This struct carries flags and a value for a
230 /// single outgoing (actual) argument or outgoing (from the perspective
231 /// of the caller) return value virtual register.
232 ///
233 struct OutputArg {
237
238 /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
239 bool IsFixed = false;
240
241 /// Index original Function's argument.
242 unsigned OrigArgIndex;
243
244 /// Offset in bytes of current output value relative to the beginning of
245 /// original argument. E.g. if argument was splitted into four 32 bit
246 /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12.
247 unsigned PartOffset;
248
249 OutputArg() = default;
250 OutputArg(ArgFlagsTy flags, MVT vt, EVT argvt, bool isfixed,
251 unsigned origIdx, unsigned partOffs)
252 : Flags(flags), IsFixed(isfixed), OrigArgIndex(origIdx),
253 PartOffset(partOffs) {
254 VT = vt;
255 ArgVT = argvt;
256 }
257 };
258
259} // end namespace ISD
260} // end namespace llvm
261
262#endif // LLVM_CODEGEN_TARGETCALLINGCONV_H
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Machine Value Type.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
unsigned encode(MaybeAlign A)
Returns a representation of the alignment that encodes undefined as 0.
Definition: Alignment.h:217
MaybeAlign decodeMaybeAlign(unsigned Value)
Dual operation of the encode function above.
Definition: Alignment.h:220
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Extended Value Type.
Definition: ValueTypes.h:34
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:299
bool isInConsecutiveRegs() const
void setInConsecutiveRegs(bool Flag=true)
bool isCopyElisionCandidate() const
Align getNonZeroOrigAlign() const
void setPointerAddrSpace(unsigned AS)
unsigned getPointerAddrSpace() const
unsigned getByRefSize() const
void setReturned(bool V=true)
void setByRefSize(unsigned S)
unsigned getByValSize() const
bool isInConsecutiveRegsLast() const
Align getNonZeroMemAlign() const
void setByValSize(unsigned S)
void setInConsecutiveRegsLast(bool Flag=true)
Align getNonZeroByValAlign() const
InputArg - This struct carries flags and type information about a single incoming (formal) argument o...
static const unsigned NoArgIndex
Sentinel value for implicit machine-level input arguments.
unsigned PartOffset
Offset in bytes of current input value relative to the beginning of original argument.
unsigned getOrigArgIndex() const
unsigned OrigArgIndex
Index original Function's argument.
InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used, unsigned origIdx, unsigned partOffs)
OutputArg - This struct carries flags and a value for a single outgoing (actual) argument or outgoing...
OutputArg(ArgFlagsTy flags, MVT vt, EVT argvt, bool isfixed, unsigned origIdx, unsigned partOffs)
unsigned PartOffset
Offset in bytes of current output value relative to the beginning of original argument.
bool IsFixed
IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
unsigned OrigArgIndex
Index original Function's argument.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
Definition: Alignment.h:141