LLVM  9.0.0svn
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 
19 #include <cassert>
20 #include <climits>
21 #include <cstdint>
22 
23 namespace llvm {
24 namespace ISD {
25 
26  struct ArgFlagsTy {
27  private:
28  unsigned IsZExt : 1; ///< Zero extended
29  unsigned IsSExt : 1; ///< Sign extended
30  unsigned IsInReg : 1; ///< Passed in register
31  unsigned IsSRet : 1; ///< Hidden struct-ret ptr
32  unsigned IsByVal : 1; ///< Struct passed by value
33  unsigned IsNest : 1; ///< Nested fn static chain
34  unsigned IsReturned : 1; ///< Always returned
35  unsigned IsSplit : 1;
36  unsigned IsInAlloca : 1; ///< Passed with inalloca
37  unsigned IsSplitEnd : 1; ///< Last part of a split
38  unsigned IsSwiftSelf : 1; ///< Swift self parameter
39  unsigned IsSwiftError : 1; ///< Swift error parameter
40  unsigned IsHva : 1; ///< HVA field for
41  unsigned IsHvaStart : 1; ///< HVA structure start
42  unsigned IsSecArgPass : 1; ///< Second argument
43  unsigned ByValAlign : 4; ///< Log 2 of byval alignment
44  unsigned OrigAlign : 5; ///< Log 2 of original alignment
45  unsigned IsInConsecutiveRegsLast : 1;
46  unsigned IsInConsecutiveRegs : 1;
47  unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate
48  unsigned IsPointer : 1;
49 
50  unsigned ByValSize; ///< Byval struct size
51 
52  unsigned PointerAddrSpace; ///< Address space of pointer argument
53 
54  public:
56  : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsNest(0),
57  IsReturned(0), IsSplit(0), IsInAlloca(0), IsSplitEnd(0),
58  IsSwiftSelf(0), IsSwiftError(0), IsHva(0), IsHvaStart(0),
59  IsSecArgPass(0), ByValAlign(0), OrigAlign(0),
60  IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0),
61  IsCopyElisionCandidate(0), IsPointer(0), ByValSize(0),
62  PointerAddrSpace(0) {
63  static_assert(sizeof(*this) == 3 * sizeof(unsigned), "flags are too big");
64  }
65 
66  bool isZExt() const { return IsZExt; }
67  void setZExt() { IsZExt = 1; }
68 
69  bool isSExt() const { return IsSExt; }
70  void setSExt() { IsSExt = 1; }
71 
72  bool isInReg() const { return IsInReg; }
73  void setInReg() { IsInReg = 1; }
74 
75  bool isSRet() const { return IsSRet; }
76  void setSRet() { IsSRet = 1; }
77 
78  bool isByVal() const { return IsByVal; }
79  void setByVal() { IsByVal = 1; }
80 
81  bool isInAlloca() const { return IsInAlloca; }
82  void setInAlloca() { IsInAlloca = 1; }
83 
84  bool isSwiftSelf() const { return IsSwiftSelf; }
85  void setSwiftSelf() { IsSwiftSelf = 1; }
86 
87  bool isSwiftError() const { return IsSwiftError; }
88  void setSwiftError() { IsSwiftError = 1; }
89 
90  bool isHva() const { return IsHva; }
91  void setHva() { IsHva = 1; }
92 
93  bool isHvaStart() const { return IsHvaStart; }
94  void setHvaStart() { IsHvaStart = 1; }
95 
96  bool isSecArgPass() const { return IsSecArgPass; }
97  void setSecArgPass() { IsSecArgPass = 1; }
98 
99  bool isNest() const { return IsNest; }
100  void setNest() { IsNest = 1; }
101 
102  bool isReturned() const { return IsReturned; }
103  void setReturned() { IsReturned = 1; }
104 
105  bool isInConsecutiveRegs() const { return IsInConsecutiveRegs; }
106  void setInConsecutiveRegs() { IsInConsecutiveRegs = 1; }
107 
108  bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; }
109  void setInConsecutiveRegsLast() { IsInConsecutiveRegsLast = 1; }
110 
111  bool isSplit() const { return IsSplit; }
112  void setSplit() { IsSplit = 1; }
113 
114  bool isSplitEnd() const { return IsSplitEnd; }
115  void setSplitEnd() { IsSplitEnd = 1; }
116 
117  bool isCopyElisionCandidate() const { return IsCopyElisionCandidate; }
118  void setCopyElisionCandidate() { IsCopyElisionCandidate = 1; }
119 
120  bool isPointer() const { return IsPointer; }
121  void setPointer() { IsPointer = 1; }
122 
123  unsigned getByValAlign() const { return (1U << ByValAlign) / 2; }
124  void setByValAlign(unsigned A) {
125  ByValAlign = Log2_32(A) + 1;
126  assert(getByValAlign() == A && "bitfield overflow");
127  }
128 
129  unsigned getOrigAlign() const { return (1U << OrigAlign) / 2; }
130  void setOrigAlign(unsigned A) {
131  OrigAlign = Log2_32(A) + 1;
132  assert(getOrigAlign() == A && "bitfield overflow");
133  }
134 
135  unsigned getByValSize() const { return ByValSize; }
136  void setByValSize(unsigned S) { ByValSize = S; }
137 
138  unsigned getPointerAddrSpace() const { return PointerAddrSpace; }
139  void setPointerAddrSpace(unsigned AS) { PointerAddrSpace = AS; }
140 };
141 
142  /// InputArg - This struct carries flags and type information about a
143  /// single incoming (formal) argument or incoming (from the perspective
144  /// of the caller) return value virtual register.
145  ///
146  struct InputArg {
150  bool Used = false;
151 
152  /// Index original Function's argument.
153  unsigned OrigArgIndex;
154  /// Sentinel value for implicit machine-level input arguments.
155  static const unsigned NoArgIndex = UINT_MAX;
156 
157  /// Offset in bytes of current input value relative to the beginning of
158  /// original argument. E.g. if argument was splitted into four 32 bit
159  /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12.
160  unsigned PartOffset;
161 
162  InputArg() = default;
163  InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used,
164  unsigned origIdx, unsigned partOffs)
165  : Flags(flags), Used(used), OrigArgIndex(origIdx), PartOffset(partOffs) {
166  VT = vt.getSimpleVT();
167  ArgVT = argvt;
168  }
169 
170  bool isOrigArg() const {
171  return OrigArgIndex != NoArgIndex;
172  }
173 
174  unsigned getOrigArgIndex() const {
175  assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument");
176  return OrigArgIndex;
177  }
178  };
179 
180  /// OutputArg - This struct carries flags and a value for a
181  /// single outgoing (actual) argument or outgoing (from the perspective
182  /// of the caller) return value virtual register.
183  ///
184  struct OutputArg {
188 
189  /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...".
190  bool IsFixed = false;
191 
192  /// Index original Function's argument.
193  unsigned OrigArgIndex;
194 
195  /// Offset in bytes of current output value relative to the beginning of
196  /// original argument. E.g. if argument was splitted into four 32 bit
197  /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12.
198  unsigned PartOffset;
199 
200  OutputArg() = default;
201  OutputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool isfixed,
202  unsigned origIdx, unsigned partOffs)
203  : Flags(flags), IsFixed(isfixed), OrigArgIndex(origIdx),
204  PartOffset(partOffs) {
205  VT = vt.getSimpleVT();
206  ArgVT = argvt;
207  }
208  };
209 
210 } // end namespace ISD
211 } // end namespace llvm
212 
213 #endif // LLVM_CODEGEN_TARGETCALLINGCONV_H
void setByValAlign(unsigned A)
This class represents lattice values for constants.
Definition: AllocatorList.h:23
InputArg - This struct carries flags and type information about a single incoming (formal) argument o...
MVT getSimpleVT() const
Return the SimpleValueType held in the specified simple EVT.
Definition: ValueTypes.h:252
unsigned getPointerAddrSpace() const
bool isInConsecutiveRegs() const
void setByValSize(unsigned S)
OutputArg - This struct carries flags and a value for a single outgoing (actual) argument or outgoing...
void setOrigAlign(unsigned A)
unsigned getByValSize() const
Machine Value Type.
unsigned getOrigAlign() const
OutputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool isfixed, unsigned origIdx, unsigned partOffs)
unsigned PartOffset
Offset in bytes of current input value relative to the beginning of original argument.
Extended Value Type.
Definition: ValueTypes.h:33
bool isCopyElisionCandidate() const
unsigned Log2_32(uint32_t Value)
Return the floor log base 2 of the specified value, -1 if the value is zero.
Definition: MathExtras.h:538
unsigned OrigArgIndex
Index original Function&#39;s argument.
unsigned getByValAlign() const
void setPointerAddrSpace(unsigned AS)
unsigned getOrigArgIndex() const
unsigned PartOffset
Offset in bytes of current output value relative to the beginning of original argument.
bool isInConsecutiveRegsLast() const
InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used, unsigned origIdx, unsigned partOffs)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
unsigned OrigArgIndex
Index original Function&#39;s argument.