Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Calling Convention Implementation Fragment *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 : static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
10 : MVT LocVT, CCValAssign::LocInfo LocInfo,
11 : ISD::ArgFlagsTy ArgFlags, CCState &State);
12 : static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
13 : MVT LocVT, CCValAssign::LocInfo LocInfo,
14 : ISD::ArgFlagsTy ArgFlags, CCState &State);
15 : static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
16 : MVT LocVT, CCValAssign::LocInfo LocInfo,
17 : ISD::ArgFlagsTy ArgFlags, CCState &State);
18 : static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
19 : MVT LocVT, CCValAssign::LocInfo LocInfo,
20 : ISD::ArgFlagsTy ArgFlags, CCState &State);
21 : static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
22 : MVT LocVT, CCValAssign::LocInfo LocInfo,
23 : ISD::ArgFlagsTy ArgFlags, CCState &State);
24 :
25 :
26 7220 : static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
27 : MVT LocVT, CCValAssign::LocInfo LocInfo,
28 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
29 :
30 7207 : if (LocVT == MVT::i1 ||
31 14427 : LocVT == MVT::i8 ||
32 : LocVT == MVT::i16) {
33 : LocVT = MVT::i32;
34 13 : if (ArgFlags.isSExt())
35 : LocInfo = CCValAssign::SExt;
36 13 : else if (ArgFlags.isZExt())
37 : LocInfo = CCValAssign::ZExt;
38 : else
39 : LocInfo = CCValAssign::AExt;
40 : }
41 :
42 7220 : if (LocVT == MVT::f32) {
43 : LocVT = MVT::i32;
44 : LocInfo = CCValAssign::BCvt;
45 : }
46 :
47 7220 : if (LocVT == MVT::f64) {
48 : LocVT = MVT::i64;
49 : LocInfo = CCValAssign::BCvt;
50 : }
51 :
52 7220 : if (ArgFlags.isByVal()) {
53 19 : State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 8, 8, ArgFlags);
54 19 : return false;
55 : }
56 :
57 7201 : if (State.isVarArg() && ValNo >= static_cast<HexagonCCState&>(State).getNumNamedVarArgParams()) {
58 76 : if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
59 : return false;
60 : }
61 :
62 7125 : if (LocVT == MVT::i32) {
63 5192 : if (ArgFlags.isSplit()) {
64 0 : if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
65 : return false;
66 : }
67 : }
68 :
69 1933 : if (LocVT == MVT::i32 ||
70 9030 : LocVT == MVT::v2i16 ||
71 : LocVT == MVT::v4i8) {
72 : static const MCPhysReg RegList1[] = {
73 : Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
74 : };
75 5278 : if (unsigned Reg = State.AllocateReg(RegList1)) {
76 5232 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
77 5232 : return false;
78 : }
79 : }
80 :
81 107 : if (LocVT == MVT::i64 ||
82 91 : LocVT == MVT::v2i32 ||
83 1958 : LocVT == MVT::v4i16 ||
84 : LocVT == MVT::v8i8) {
85 1847 : if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
86 : return false;
87 : }
88 :
89 107 : if (LocVT == MVT::i64 ||
90 91 : LocVT == MVT::v2i32 ||
91 1958 : LocVT == MVT::v4i16 ||
92 : LocVT == MVT::v8i8) {
93 : static const MCPhysReg RegList2[] = {
94 : Hexagon::D0, Hexagon::D1, Hexagon::D2
95 : };
96 1847 : if (unsigned Reg = State.AllocateReg(RegList2)) {
97 1842 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
98 1842 : return false;
99 : }
100 : }
101 :
102 51 : if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
103 51 : return false;
104 :
105 : return true; // CC didn't match.
106 : }
107 :
108 :
109 0 : static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
110 : MVT LocVT, CCValAssign::LocInfo LocInfo,
111 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
112 :
113 0 : if (LocVT == MVT::i32 ||
114 0 : LocVT == MVT::v2i16 ||
115 : LocVT == MVT::v4i8) {
116 0 : unsigned Offset1 = State.AllocateStack(4, 4);
117 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset1, LocVT, LocInfo));
118 0 : return false;
119 : }
120 :
121 0 : if (LocVT == MVT::i64 ||
122 0 : LocVT == MVT::v2i32 ||
123 0 : LocVT == MVT::v4i16 ||
124 : LocVT == MVT::v8i8) {
125 0 : unsigned Offset2 = State.AllocateStack(8, 8);
126 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
127 0 : return false;
128 : }
129 :
130 : return true; // CC didn't match.
131 : }
132 :
133 :
134 3706 : static bool CC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
135 : MVT LocVT, CCValAssign::LocInfo LocInfo,
136 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
137 :
138 3706 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
139 1460 : if (LocVT == MVT::v16i32 ||
140 3482 : LocVT == MVT::v32i16 ||
141 : LocVT == MVT::v64i8) {
142 : static const MCPhysReg RegList1[] = {
143 : Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
144 : };
145 1017 : if (unsigned Reg = State.AllocateReg(RegList1)) {
146 1017 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
147 1017 : return false;
148 : }
149 : }
150 : }
151 :
152 2689 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
153 1011 : if (LocVT == MVT::v32i32 ||
154 2099 : LocVT == MVT::v64i16 ||
155 : LocVT == MVT::v128i8) {
156 : static const MCPhysReg RegList2[] = {
157 : Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
158 : };
159 472 : if (unsigned Reg = State.AllocateReg(RegList2)) {
160 472 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
161 472 : return false;
162 : }
163 : }
164 : }
165 :
166 2217 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
167 617 : if (LocVT == MVT::v16i32 ||
168 1234 : LocVT == MVT::v32i16 ||
169 : LocVT == MVT::v64i8) {
170 0 : unsigned Offset3 = State.AllocateStack(64, 64);
171 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
172 0 : return false;
173 : }
174 : }
175 :
176 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
177 617 : if (LocVT == MVT::v32i32 ||
178 1234 : LocVT == MVT::v64i16 ||
179 : LocVT == MVT::v128i8) {
180 0 : unsigned Offset4 = State.AllocateStack(128, 64);
181 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
182 0 : return false;
183 : }
184 : }
185 :
186 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
187 1418 : if (LocVT == MVT::v32i32 ||
188 2935 : LocVT == MVT::v64i16 ||
189 : LocVT == MVT::v128i8) {
190 : static const MCPhysReg RegList5[] = {
191 : Hexagon::V0, Hexagon::V1, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15
192 : };
193 743 : if (unsigned Reg = State.AllocateReg(RegList5)) {
194 739 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
195 739 : return false;
196 : }
197 : }
198 : }
199 :
200 1478 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
201 845 : if (LocVT == MVT::v64i32 ||
202 1705 : LocVT == MVT::v128i16 ||
203 : LocVT == MVT::v256i8) {
204 : static const MCPhysReg RegList6[] = {
205 : Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
206 : };
207 684 : if (unsigned Reg = State.AllocateReg(RegList6)) {
208 684 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
209 684 : return false;
210 : }
211 : }
212 : }
213 :
214 794 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
215 173 : if (LocVT == MVT::v32i32 ||
216 350 : LocVT == MVT::v64i16 ||
217 : LocVT == MVT::v128i8) {
218 4 : unsigned Offset7 = State.AllocateStack(128, 128);
219 4 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
220 4 : return false;
221 : }
222 : }
223 :
224 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
225 173 : if (LocVT == MVT::v64i32 ||
226 346 : LocVT == MVT::v128i16 ||
227 : LocVT == MVT::v256i8) {
228 0 : unsigned Offset8 = State.AllocateStack(256, 128);
229 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset8, LocVT, LocInfo));
230 0 : return false;
231 : }
232 : }
233 :
234 790 : if (!CC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
235 790 : return false;
236 :
237 : return true; // CC didn't match.
238 : }
239 :
240 :
241 5824 : static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
242 : MVT LocVT, CCValAssign::LocInfo LocInfo,
243 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
244 :
245 5798 : if (LocVT == MVT::i1 ||
246 11622 : LocVT == MVT::i8 ||
247 : LocVT == MVT::i16) {
248 : LocVT = MVT::i32;
249 26 : if (ArgFlags.isSExt())
250 : LocInfo = CCValAssign::SExt;
251 26 : else if (ArgFlags.isZExt())
252 : LocInfo = CCValAssign::ZExt;
253 : else
254 : LocInfo = CCValAssign::AExt;
255 : }
256 :
257 5824 : if (LocVT == MVT::f32) {
258 : LocVT = MVT::i32;
259 : LocInfo = CCValAssign::BCvt;
260 : }
261 :
262 5824 : if (LocVT == MVT::f64) {
263 : LocVT = MVT::i64;
264 : LocInfo = CCValAssign::BCvt;
265 : }
266 :
267 5824 : if (ArgFlags.isSplit()) {
268 : static const MCPhysReg RegList1[] = {
269 : Hexagon::R0, Hexagon::R1
270 : };
271 0 : if (unsigned Reg = State.AllocateReg(RegList1)) {
272 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
273 0 : return false;
274 : }
275 : }
276 :
277 2275 : if (LocVT == MVT::i32 ||
278 8071 : LocVT == MVT::v2i16 ||
279 : LocVT == MVT::v4i8) {
280 : static const MCPhysReg RegList2[] = {
281 : Hexagon::R0, Hexagon::R1
282 : };
283 3637 : if (unsigned Reg = State.AllocateReg(RegList2)) {
284 3637 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
285 3637 : return false;
286 : }
287 : }
288 :
289 68 : if (LocVT == MVT::i64 ||
290 54 : LocVT == MVT::v2i32 ||
291 2209 : LocVT == MVT::v4i16 ||
292 : LocVT == MVT::v8i8) {
293 : if (unsigned Reg = State.AllocateReg(Hexagon::D0)) {
294 2187 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
295 2187 : return false;
296 : }
297 : }
298 :
299 : return true; // CC didn't match.
300 : }
301 :
302 :
303 3000 : static bool RetCC_Hexagon_HVX(unsigned ValNo, MVT ValVT,
304 : MVT LocVT, CCValAssign::LocInfo LocInfo,
305 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
306 :
307 3000 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
308 1144 : if (LocVT == MVT::v16i32 ||
309 2530 : LocVT == MVT::v32i16 ||
310 : LocVT == MVT::v64i8) {
311 : if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
312 690 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
313 690 : return false;
314 : }
315 : }
316 : }
317 :
318 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
319 688 : if (LocVT == MVT::v32i32 ||
320 1450 : LocVT == MVT::v64i16 ||
321 : LocVT == MVT::v128i8) {
322 : if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
323 596 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
324 596 : return false;
325 : }
326 : }
327 : }
328 :
329 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
330 1446 : if (LocVT == MVT::v32i32 ||
331 2908 : LocVT == MVT::v64i16 ||
332 : LocVT == MVT::v128i8) {
333 : if (unsigned Reg = State.AllocateReg(Hexagon::V0)) {
334 654 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
335 654 : return false;
336 : }
337 : }
338 : }
339 :
340 : if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
341 874 : if (LocVT == MVT::v64i32 ||
342 1748 : LocVT == MVT::v128i16 ||
343 : LocVT == MVT::v256i8) {
344 : if (unsigned Reg = State.AllocateReg(Hexagon::W0)) {
345 844 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
346 844 : return false;
347 : }
348 : }
349 : }
350 :
351 216 : if (!RetCC_Hexagon(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
352 216 : return false;
353 :
354 : return true; // CC didn't match.
355 : }
|
