/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm/Target/TargetCallingConv.h
Line | Count | Source |
1 | | //===-- llvm/Target/TargetCallingConv.h - Calling Convention ----*- C++ -*-===// |
2 | | // |
3 | | // The LLVM Compiler Infrastructure |
4 | | // |
5 | | // This file is distributed under the University of Illinois Open Source |
6 | | // License. See LICENSE.TXT for details. |
7 | | // |
8 | | //===----------------------------------------------------------------------===// |
9 | | // |
10 | | // This file defines types for working with calling-convention information. |
11 | | // |
12 | | //===----------------------------------------------------------------------===// |
13 | | |
14 | | #ifndef LLVM_TARGET_TARGETCALLINGCONV_H |
15 | | #define LLVM_TARGET_TARGETCALLINGCONV_H |
16 | | |
17 | | #include "llvm/CodeGen/MachineValueType.h" |
18 | | #include "llvm/CodeGen/ValueTypes.h" |
19 | | #include "llvm/Support/MathExtras.h" |
20 | | #include <cassert> |
21 | | #include <climits> |
22 | | #include <cstdint> |
23 | | |
24 | | namespace llvm { |
25 | | namespace 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 IsNest : 1; ///< Nested fn static chain |
35 | | unsigned IsReturned : 1; ///< Always returned |
36 | | unsigned IsSplit : 1; |
37 | | unsigned IsInAlloca : 1; ///< Passed with inalloca |
38 | | unsigned IsSplitEnd : 1; ///< Last part of a split |
39 | | unsigned IsSwiftSelf : 1; ///< Swift self parameter |
40 | | unsigned IsSwiftError : 1; ///< Swift error parameter |
41 | | unsigned IsHva : 1; ///< HVA field for |
42 | | unsigned IsHvaStart : 1; ///< HVA structure start |
43 | | unsigned IsSecArgPass : 1; ///< Second argument |
44 | | unsigned ByValAlign : 4; ///< Log 2 of byval alignment |
45 | | unsigned OrigAlign : 5; ///< Log 2 of original alignment |
46 | | unsigned IsInConsecutiveRegsLast : 1; |
47 | | unsigned IsInConsecutiveRegs : 1; |
48 | | unsigned IsCopyElisionCandidate : 1; ///< Argument copy elision candidate |
49 | | |
50 | | unsigned ByValSize; ///< Byval struct size |
51 | | |
52 | | public: |
53 | | ArgFlagsTy() |
54 | | : IsZExt(0), IsSExt(0), IsInReg(0), IsSRet(0), IsByVal(0), IsNest(0), |
55 | | IsReturned(0), IsSplit(0), IsInAlloca(0), IsSplitEnd(0), |
56 | | IsSwiftSelf(0), IsSwiftError(0), IsHva(0), IsHvaStart(0), |
57 | | IsSecArgPass(0), ByValAlign(0), OrigAlign(0), |
58 | | IsInConsecutiveRegsLast(0), IsInConsecutiveRegs(0), |
59 | 12.7M | IsCopyElisionCandidate(0), ByValSize(0) { |
60 | 12.7M | static_assert(sizeof(*this) == 2 * sizeof(unsigned), "flags are too big"); |
61 | 12.7M | } |
62 | | |
63 | 158k | bool isZExt() const { return IsZExt; } |
64 | 173k | void setZExt() { IsZExt = 1; } |
65 | | |
66 | 198k | bool isSExt() const { return IsSExt; } |
67 | 23.4k | void setSExt() { IsSExt = 1; } |
68 | | |
69 | 180k | bool isInReg() const { return IsInReg; } |
70 | 2.33k | void setInReg() { IsInReg = 1; } |
71 | | |
72 | 8.66M | bool isSRet() const { return IsSRet; } |
73 | 9.46k | void setSRet() { IsSRet = 1; } |
74 | | |
75 | 15.1M | bool isByVal() const { return IsByVal; } |
76 | 1.28k | void setByVal() { IsByVal = 1; } |
77 | | |
78 | 5.23M | bool isInAlloca() const { return IsInAlloca; } |
79 | 46 | void setInAlloca() { IsInAlloca = 1; } |
80 | | |
81 | 8.74M | bool isSwiftSelf() const { return IsSwiftSelf; } |
82 | 195 | void setSwiftSelf() { IsSwiftSelf = 1; } |
83 | | |
84 | 12.5M | bool isSwiftError() const { return IsSwiftError; } |
85 | 475 | void setSwiftError() { IsSwiftError = 1; } |
86 | | |
87 | 393 | bool isHva() const { return IsHva; } |
88 | 58 | void setHva() { IsHva = 1; } |
89 | | |
90 | 29 | bool isHvaStart() const { return IsHvaStart; } |
91 | 16 | void setHvaStart() { IsHvaStart = 1; } |
92 | | |
93 | 392 | bool isSecArgPass() const { return IsSecArgPass; } |
94 | 181 | void setSecArgPass() { IsSecArgPass = 1; } |
95 | | |
96 | 441k | bool isNest() const { return IsNest; } |
97 | 40 | void setNest() { IsNest = 1; } |
98 | | |
99 | 1.61M | bool isReturned() const { return IsReturned; } |
100 | 5.26k | void setReturned() { IsReturned = 1; } |
101 | | |
102 | 8.63M | bool isInConsecutiveRegs() const { return IsInConsecutiveRegs; } |
103 | 6.71k | void setInConsecutiveRegs() { IsInConsecutiveRegs = 1; } |
104 | | |
105 | 26.3k | bool isInConsecutiveRegsLast() const { return IsInConsecutiveRegsLast; } |
106 | 3.81k | void setInConsecutiveRegsLast() { IsInConsecutiveRegsLast = 1; } |
107 | | |
108 | 14.5M | bool isSplit() const { return IsSplit; } |
109 | 25.9k | void setSplit() { IsSplit = 1; } |
110 | | |
111 | 126 | bool isSplitEnd() const { return IsSplitEnd; } |
112 | 25.3k | void setSplitEnd() { IsSplitEnd = 1; } |
113 | | |
114 | 981k | bool isCopyElisionCandidate() const { return IsCopyElisionCandidate; } |
115 | 4.26k | void setCopyElisionCandidate() { IsCopyElisionCandidate = 1; } |
116 | | |
117 | 1.70k | unsigned getByValAlign() const { return (1U << ByValAlign) / 2; } |
118 | 1.28k | void setByValAlign(unsigned A) { |
119 | 1.28k | ByValAlign = Log2_32(A) + 1; |
120 | 1.28k | assert(getByValAlign() == A && "bitfield overflow"); |
121 | 1.28k | } |
122 | | |
123 | 143k | unsigned getOrigAlign() const { return (1U << OrigAlign) / 2; } |
124 | 9.25M | void setOrigAlign(unsigned A) { |
125 | 9.25M | OrigAlign = Log2_32(A) + 1; |
126 | 9.25M | assert(getOrigAlign() == A && "bitfield overflow"); |
127 | 9.25M | } |
128 | | |
129 | 2.36k | unsigned getByValSize() const { return ByValSize; } |
130 | 1.28k | void setByValSize(unsigned S) { ByValSize = S; } |
131 | | }; |
132 | | |
133 | | /// InputArg - This struct carries flags and type information about a |
134 | | /// single incoming (formal) argument or incoming (from the perspective |
135 | | /// of the caller) return value virtual register. |
136 | | /// |
137 | | struct InputArg { |
138 | | ArgFlagsTy Flags; |
139 | | MVT VT = MVT::Other; |
140 | | EVT ArgVT; |
141 | | bool Used = false; |
142 | | |
143 | | /// Index original Function's argument. |
144 | | unsigned OrigArgIndex; |
145 | | /// Sentinel value for implicit machine-level input arguments. |
146 | | static const unsigned NoArgIndex = UINT_MAX; |
147 | | |
148 | | /// Offset in bytes of current input value relative to the beginning of |
149 | | /// original argument. E.g. if argument was splitted into four 32 bit |
150 | | /// registers, we got 4 InputArgs with PartOffsets 0, 4, 8 and 12. |
151 | | unsigned PartOffset; |
152 | | |
153 | 1.26M | InputArg() = default; |
154 | | InputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool used, |
155 | | unsigned origIdx, unsigned partOffs) |
156 | 988k | : Flags(flags), Used(used), OrigArgIndex(origIdx), PartOffset(partOffs) { |
157 | 988k | VT = vt.getSimpleVT(); |
158 | 988k | ArgVT = argvt; |
159 | 988k | } |
160 | | |
161 | 782k | bool isOrigArg() const { |
162 | 782k | return OrigArgIndex != NoArgIndex; |
163 | 782k | } |
164 | | |
165 | 1.62M | unsigned getOrigArgIndex() const { |
166 | 1.62M | assert(OrigArgIndex != NoArgIndex && "Implicit machine-level argument"); |
167 | 1.62M | return OrigArgIndex; |
168 | 1.62M | } |
169 | | }; |
170 | | |
171 | | /// OutputArg - This struct carries flags and a value for a |
172 | | /// single outgoing (actual) argument or outgoing (from the perspective |
173 | | /// of the caller) return value virtual register. |
174 | | /// |
175 | | struct OutputArg { |
176 | | ArgFlagsTy Flags; |
177 | | MVT VT; |
178 | | EVT ArgVT; |
179 | | |
180 | | /// IsFixed - Is this a "fixed" value, ie not passed through a vararg "...". |
181 | | bool IsFixed = false; |
182 | | |
183 | | /// Index original Function's argument. |
184 | | unsigned OrigArgIndex; |
185 | | |
186 | | /// Offset in bytes of current output value relative to the beginning of |
187 | | /// original argument. E.g. if argument was splitted into four 32 bit |
188 | | /// registers, we got 4 OutputArgs with PartOffsets 0, 4, 8 and 12. |
189 | | unsigned PartOffset; |
190 | | |
191 | | OutputArg() = default; |
192 | | OutputArg(ArgFlagsTy flags, EVT vt, EVT argvt, bool isfixed, |
193 | | unsigned origIdx, unsigned partOffs) |
194 | | : Flags(flags), IsFixed(isfixed), OrigArgIndex(origIdx), |
195 | 5.94M | PartOffset(partOffs) { |
196 | 5.94M | VT = vt.getSimpleVT(); |
197 | 5.94M | ArgVT = argvt; |
198 | 5.94M | } |
199 | | }; |
200 | | |
201 | | } // end namespace ISD |
202 | | } // end namespace llvm |
203 | | |
204 | | #endif // LLVM_TARGET_TARGETCALLINGCONV_H |