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_ARM_AAPCS(unsigned ValNo, MVT ValVT,
10 : MVT LocVT, CCValAssign::LocInfo LocInfo,
11 : ISD::ArgFlagsTy ArgFlags, CCState &State);
12 : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
13 : MVT LocVT, CCValAssign::LocInfo LocInfo,
14 : ISD::ArgFlagsTy ArgFlags, CCState &State);
15 : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
16 : MVT LocVT, CCValAssign::LocInfo LocInfo,
17 : ISD::ArgFlagsTy ArgFlags, CCState &State);
18 : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
19 : MVT LocVT, CCValAssign::LocInfo LocInfo,
20 : ISD::ArgFlagsTy ArgFlags, CCState &State);
21 : static bool CC_ARM_APCS_GHC(unsigned ValNo, MVT ValVT,
22 : MVT LocVT, CCValAssign::LocInfo LocInfo,
23 : ISD::ArgFlagsTy ArgFlags, CCState &State);
24 : static bool FastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
25 : MVT LocVT, CCValAssign::LocInfo LocInfo,
26 : ISD::ArgFlagsTy ArgFlags, CCState &State);
27 : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
28 : MVT LocVT, CCValAssign::LocInfo LocInfo,
29 : ISD::ArgFlagsTy ArgFlags, CCState &State);
30 : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
31 : MVT LocVT, CCValAssign::LocInfo LocInfo,
32 : ISD::ArgFlagsTy ArgFlags, CCState &State);
33 : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
34 : MVT LocVT, CCValAssign::LocInfo LocInfo,
35 : ISD::ArgFlagsTy ArgFlags, CCState &State);
36 : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
37 : MVT LocVT, CCValAssign::LocInfo LocInfo,
38 : ISD::ArgFlagsTy ArgFlags, CCState &State);
39 : static bool RetFastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
40 : MVT LocVT, CCValAssign::LocInfo LocInfo,
41 : ISD::ArgFlagsTy ArgFlags, CCState &State);
42 :
43 :
44 24078 : static bool CC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
45 : MVT LocVT, CCValAssign::LocInfo LocInfo,
46 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
47 :
48 24078 : if (ArgFlags.isByVal()) {
49 373 : State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
50 373 : return false;
51 : }
52 :
53 23705 : if (ArgFlags.isNest()) {
54 : if (unsigned Reg = State.AllocateReg(ARM::R12)) {
55 20 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
56 10 : return false;
57 : }
58 : }
59 :
60 23665 : if (LocVT == MVT::v1i64 ||
61 23578 : LocVT == MVT::v2i32 ||
62 23519 : LocVT == MVT::v4i16 ||
63 23517 : LocVT == MVT::v4f16 ||
64 47145 : LocVT == MVT::v8i8 ||
65 : LocVT == MVT::v2f32) {
66 276 : LocVT = MVT::f64;
67 276 : LocInfo = CCValAssign::BCvt;
68 : }
69 :
70 23660 : if (LocVT == MVT::v2i64 ||
71 23572 : LocVT == MVT::v4i32 ||
72 23517 : LocVT == MVT::v8i16 ||
73 23515 : LocVT == MVT::v8f16 ||
74 47163 : LocVT == MVT::v16i8 ||
75 : LocVT == MVT::v4f32) {
76 268 : LocVT = MVT::v2f64;
77 268 : LocInfo = CCValAssign::BCvt;
78 : }
79 :
80 23695 : if (ArgFlags.isSwiftSelf()) {
81 0 : if (LocVT == MVT::i32) {
82 : if (unsigned Reg = State.AllocateReg(ARM::R10)) {
83 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
84 0 : return false;
85 : }
86 : }
87 : }
88 :
89 23695 : if (ArgFlags.isSwiftError()) {
90 11 : if (LocVT == MVT::i32) {
91 : if (unsigned Reg = State.AllocateReg(ARM::R8)) {
92 22 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
93 11 : return false;
94 : }
95 : }
96 : }
97 :
98 23684 : if (LocVT == MVT::f64 ||
99 : LocVT == MVT::v2f64) {
100 1698 : if (CC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
101 : return false;
102 : }
103 :
104 22391 : if (LocVT == MVT::f32) {
105 1609 : LocVT = MVT::i32;
106 1609 : LocInfo = CCValAssign::BCvt;
107 : }
108 :
109 22391 : if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
110 22386 : return false;
111 :
112 : return true; // CC didn't match.
113 : }
114 :
115 :
116 25267 : static bool CC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
117 : MVT LocVT, CCValAssign::LocInfo LocInfo,
118 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
119 :
120 25240 : if (LocVT == MVT::i1 ||
121 50389 : LocVT == MVT::i8 ||
122 : LocVT == MVT::i16) {
123 : LocVT = MVT::i32;
124 244 : if (ArgFlags.isSExt())
125 : LocInfo = CCValAssign::SExt;
126 221 : else if (ArgFlags.isZExt())
127 : LocInfo = CCValAssign::ZExt;
128 : else
129 : LocInfo = CCValAssign::AExt;
130 : }
131 :
132 25267 : if (LocVT == MVT::i32) {
133 24793 : if (ArgFlags.getOrigAlign() == 8) {
134 : static const MCPhysReg RegList1[] = {
135 : ARM::R0, ARM::R2
136 : };
137 : static const MCPhysReg RegList2[] = {
138 : ARM::R0, ARM::R1
139 : };
140 2083 : if (unsigned Reg = State.AllocateReg(RegList1, RegList2)) {
141 1793 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
142 1793 : return false;
143 : }
144 : }
145 : }
146 :
147 23474 : if (LocVT == MVT::i32) {
148 23000 : if (ArgFlags.getOrigAlign() != 8) {
149 : static const MCPhysReg RegList3[] = {
150 : ARM::R0, ARM::R1, ARM::R2, ARM::R3
151 : };
152 22710 : if (unsigned Reg = State.AllocateReg(RegList3)) {
153 21511 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
154 21511 : return false;
155 : }
156 : }
157 : }
158 :
159 1963 : if (LocVT == MVT::i32) {
160 1489 : if (ArgFlags.getOrigAlign() == 8) {
161 : static const MCPhysReg ShadowRegList4[] = {
162 : ARM::R0, ARM::R1, ARM::R2, ARM::R3
163 : };
164 290 : unsigned Offset5 = State.AllocateStack(4, 8, ShadowRegList4);
165 290 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
166 290 : return false;
167 : }
168 : }
169 :
170 1673 : if (LocVT == MVT::i32) {
171 : static const MCPhysReg ShadowRegList6[] = {
172 : ARM::R0, ARM::R1, ARM::R2, ARM::R3
173 : };
174 1199 : unsigned Offset7 = State.AllocateStack(4, 4, ShadowRegList6);
175 1199 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
176 1199 : return false;
177 : }
178 :
179 474 : if (LocVT == MVT::f32) {
180 : static const MCPhysReg ShadowRegList8[] = {
181 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
182 : };
183 4 : unsigned Offset9 = State.AllocateStack(4, 4, ShadowRegList8);
184 4 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
185 4 : return false;
186 : }
187 :
188 470 : if (LocVT == MVT::f64) {
189 : static const MCPhysReg ShadowRegList10[] = {
190 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
191 : };
192 313 : unsigned Offset11 = State.AllocateStack(8, 8, ShadowRegList10);
193 313 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset11, LocVT, LocInfo));
194 313 : return false;
195 : }
196 :
197 157 : if (LocVT == MVT::v2f64) {
198 152 : if (ArgFlags.getOrigAlign() == 16) {
199 : static const MCPhysReg ShadowRegList12[] = {
200 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
201 : };
202 3 : unsigned Offset13 = State.AllocateStack(16, 16, ShadowRegList12);
203 3 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset13, LocVT, LocInfo));
204 3 : return false;
205 : }
206 : }
207 :
208 154 : if (LocVT == MVT::v2f64) {
209 : static const MCPhysReg ShadowRegList14[] = {
210 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
211 : };
212 149 : unsigned Offset15 = State.AllocateStack(16, 8, ShadowRegList14);
213 149 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset15, LocVT, LocInfo));
214 149 : return false;
215 : }
216 :
217 : return true; // CC didn't match.
218 : }
219 :
220 :
221 6670 : static bool CC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
222 : MVT LocVT, CCValAssign::LocInfo LocInfo,
223 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
224 :
225 6670 : if (ArgFlags.isByVal()) {
226 12 : State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
227 12 : return false;
228 : }
229 :
230 6646 : if (LocVT == MVT::v1i64 ||
231 6593 : LocVT == MVT::v2i32 ||
232 6545 : LocVT == MVT::v4i16 ||
233 6387 : LocVT == MVT::v4f16 ||
234 13023 : LocVT == MVT::v8i8 ||
235 : LocVT == MVT::v2f32) {
236 315 : LocVT = MVT::f64;
237 : LocInfo = CCValAssign::BCvt;
238 : }
239 :
240 6588 : if (LocVT == MVT::v2i64 ||
241 6554 : LocVT == MVT::v4i32 ||
242 6527 : LocVT == MVT::v8i16 ||
243 6380 : LocVT == MVT::v8f16 ||
244 13006 : LocVT == MVT::v16i8 ||
245 : LocVT == MVT::v4f32) {
246 350 : LocVT = MVT::v2f64;
247 : LocInfo = CCValAssign::BCvt;
248 : }
249 :
250 6658 : if (ArgFlags.isSwiftSelf()) {
251 53 : if (LocVT == MVT::i32) {
252 : if (unsigned Reg = State.AllocateReg(ARM::R10)) {
253 53 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
254 53 : return false;
255 : }
256 : }
257 : }
258 :
259 6605 : if (ArgFlags.isSwiftError()) {
260 36 : if (LocVT == MVT::i32) {
261 : if (unsigned Reg = State.AllocateReg(ARM::R8)) {
262 36 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
263 36 : return false;
264 : }
265 : }
266 : }
267 :
268 6569 : if (ArgFlags.isInConsecutiveRegs()) {
269 3436 : if (CC_ARM_AAPCS_Custom_Aggregate(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
270 : return false;
271 : }
272 :
273 3133 : if (LocVT == MVT::v2f64) {
274 : static const MCPhysReg RegList1[] = {
275 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
276 : };
277 62 : if (unsigned Reg = State.AllocateReg(RegList1)) {
278 14 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
279 14 : return false;
280 : }
281 : }
282 :
283 3119 : if (LocVT == MVT::f64) {
284 : static const MCPhysReg RegList2[] = {
285 : ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
286 : };
287 154 : if (unsigned Reg = State.AllocateReg(RegList2)) {
288 142 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
289 142 : return false;
290 : }
291 : }
292 :
293 2977 : if (LocVT == MVT::f32) {
294 : static const MCPhysReg RegList3[] = {
295 : ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
296 : };
297 105 : if (unsigned Reg = State.AllocateReg(RegList3)) {
298 101 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
299 101 : return false;
300 : }
301 : }
302 :
303 2876 : if (!CC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
304 2876 : return false;
305 :
306 : return true; // CC didn't match.
307 : }
308 :
309 :
310 9280 : static bool CC_ARM_APCS(unsigned ValNo, MVT ValVT,
311 : MVT LocVT, CCValAssign::LocInfo LocInfo,
312 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
313 :
314 9280 : if (ArgFlags.isByVal()) {
315 34 : State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, 4, 4, ArgFlags);
316 34 : return false;
317 : }
318 :
319 9238 : if (LocVT == MVT::i1 ||
320 18422 : LocVT == MVT::i8 ||
321 : LocVT == MVT::i16) {
322 91 : LocVT = MVT::i32;
323 91 : if (ArgFlags.isSExt())
324 13 : LocInfo = CCValAssign::SExt;
325 78 : else if (ArgFlags.isZExt())
326 72 : LocInfo = CCValAssign::ZExt;
327 : else
328 6 : LocInfo = CCValAssign::AExt;
329 : }
330 :
331 9246 : if (ArgFlags.isSwiftSelf()) {
332 20 : if (LocVT == MVT::i32) {
333 : if (unsigned Reg = State.AllocateReg(ARM::R10)) {
334 40 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
335 20 : return false;
336 : }
337 : }
338 : }
339 :
340 9226 : if (ArgFlags.isSwiftError()) {
341 22 : if (LocVT == MVT::i32) {
342 : if (unsigned Reg = State.AllocateReg(ARM::R8)) {
343 44 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
344 22 : return false;
345 : }
346 : }
347 : }
348 :
349 9202 : if (LocVT == MVT::v1i64 ||
350 9188 : LocVT == MVT::v2i32 ||
351 9180 : LocVT == MVT::v4i16 ||
352 18379 : LocVT == MVT::v8i8 ||
353 : LocVT == MVT::v2f32) {
354 81 : LocVT = MVT::f64;
355 81 : LocInfo = CCValAssign::BCvt;
356 : }
357 :
358 9195 : if (LocVT == MVT::v2i64 ||
359 9180 : LocVT == MVT::v4i32 ||
360 9173 : LocVT == MVT::v8i16 ||
361 18370 : LocVT == MVT::v16i8 ||
362 : LocVT == MVT::v4f32) {
363 84 : LocVT = MVT::v2f64;
364 84 : LocInfo = CCValAssign::BCvt;
365 : }
366 :
367 9204 : if (LocVT == MVT::f64 ||
368 : LocVT == MVT::v2f64) {
369 804 : if (CC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
370 : return false;
371 : }
372 :
373 8881 : if (LocVT == MVT::f32) {
374 923 : LocVT = MVT::i32;
375 923 : LocInfo = CCValAssign::BCvt;
376 : }
377 :
378 8881 : if (LocVT == MVT::i32) {
379 : static const MCPhysReg RegList1[] = {
380 : ARM::R0, ARM::R1, ARM::R2, ARM::R3
381 : };
382 8400 : if (unsigned Reg = State.AllocateReg(RegList1)) {
383 15126 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
384 7563 : return false;
385 : }
386 : }
387 :
388 1318 : if (LocVT == MVT::i32) {
389 837 : unsigned Offset2 = State.AllocateStack(4, 4);
390 1674 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset2, LocVT, LocInfo));
391 837 : return false;
392 : }
393 :
394 481 : if (LocVT == MVT::f64) {
395 455 : unsigned Offset3 = State.AllocateStack(8, 4);
396 910 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset3, LocVT, LocInfo));
397 455 : return false;
398 : }
399 :
400 26 : if (LocVT == MVT::v2f64) {
401 26 : unsigned Offset4 = State.AllocateStack(16, 4);
402 52 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset4, LocVT, LocInfo));
403 26 : return false;
404 : }
405 :
406 : return true; // CC didn't match.
407 : }
408 :
409 :
410 0 : static bool CC_ARM_APCS_GHC(unsigned ValNo, MVT ValVT,
411 : MVT LocVT, CCValAssign::LocInfo LocInfo,
412 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
413 :
414 0 : if (LocVT == MVT::v1i64 ||
415 0 : LocVT == MVT::v2i32 ||
416 0 : LocVT == MVT::v4i16 ||
417 0 : LocVT == MVT::v8i8 ||
418 : LocVT == MVT::v2f32) {
419 : LocVT = MVT::f64;
420 : LocInfo = CCValAssign::BCvt;
421 : }
422 :
423 0 : if (LocVT == MVT::v2i64 ||
424 0 : LocVT == MVT::v4i32 ||
425 0 : LocVT == MVT::v8i16 ||
426 0 : LocVT == MVT::v16i8 ||
427 : LocVT == MVT::v4f32) {
428 : LocVT = MVT::v2f64;
429 : LocInfo = CCValAssign::BCvt;
430 : }
431 :
432 0 : if (LocVT == MVT::v2f64) {
433 : static const MCPhysReg RegList1[] = {
434 : ARM::Q4, ARM::Q5
435 : };
436 0 : if (unsigned Reg = State.AllocateReg(RegList1)) {
437 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
438 0 : return false;
439 : }
440 : }
441 :
442 0 : if (LocVT == MVT::f64) {
443 : static const MCPhysReg RegList2[] = {
444 : ARM::D8, ARM::D9, ARM::D10, ARM::D11
445 : };
446 0 : if (unsigned Reg = State.AllocateReg(RegList2)) {
447 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
448 0 : return false;
449 : }
450 : }
451 :
452 0 : if (LocVT == MVT::f32) {
453 : static const MCPhysReg RegList3[] = {
454 : ARM::S16, ARM::S17, ARM::S18, ARM::S19, ARM::S20, ARM::S21, ARM::S22, ARM::S23
455 : };
456 0 : if (unsigned Reg = State.AllocateReg(RegList3)) {
457 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
458 0 : return false;
459 : }
460 : }
461 :
462 0 : if (LocVT == MVT::i8 ||
463 : LocVT == MVT::i16) {
464 : LocVT = MVT::i32;
465 0 : if (ArgFlags.isSExt())
466 : LocInfo = CCValAssign::SExt;
467 0 : else if (ArgFlags.isZExt())
468 : LocInfo = CCValAssign::ZExt;
469 : else
470 : LocInfo = CCValAssign::AExt;
471 : }
472 :
473 0 : if (LocVT == MVT::i32) {
474 : static const MCPhysReg RegList4[] = {
475 : ARM::R4, ARM::R5, ARM::R6, ARM::R7, ARM::R8, ARM::R9, ARM::R10, ARM::R11
476 : };
477 0 : if (unsigned Reg = State.AllocateReg(RegList4)) {
478 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
479 0 : return false;
480 : }
481 : }
482 :
483 : return true; // CC didn't match.
484 : }
485 :
486 :
487 124 : static bool FastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
488 : MVT LocVT, CCValAssign::LocInfo LocInfo,
489 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
490 :
491 124 : if (LocVT == MVT::v1i64 ||
492 124 : LocVT == MVT::v2i32 ||
493 124 : LocVT == MVT::v4i16 ||
494 248 : LocVT == MVT::v8i8 ||
495 : LocVT == MVT::v2f32) {
496 : LocVT = MVT::f64;
497 : LocInfo = CCValAssign::BCvt;
498 : }
499 :
500 124 : if (LocVT == MVT::v2i64 ||
501 124 : LocVT == MVT::v4i32 ||
502 124 : LocVT == MVT::v8i16 ||
503 248 : LocVT == MVT::v16i8 ||
504 : LocVT == MVT::v4f32) {
505 : LocVT = MVT::v2f64;
506 : LocInfo = CCValAssign::BCvt;
507 : }
508 :
509 124 : if (LocVT == MVT::v2f64) {
510 : static const MCPhysReg RegList1[] = {
511 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
512 : };
513 0 : if (unsigned Reg = State.AllocateReg(RegList1)) {
514 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
515 0 : return false;
516 : }
517 : }
518 :
519 124 : if (LocVT == MVT::f64) {
520 : static const MCPhysReg RegList2[] = {
521 : ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
522 : };
523 44 : if (unsigned Reg = State.AllocateReg(RegList2)) {
524 41 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
525 41 : return false;
526 : }
527 : }
528 :
529 83 : if (LocVT == MVT::f32) {
530 : static const MCPhysReg RegList3[] = {
531 : ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
532 : };
533 14 : if (unsigned Reg = State.AllocateReg(RegList3)) {
534 11 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
535 11 : return false;
536 : }
537 : }
538 :
539 72 : if (LocVT == MVT::f32) {
540 : static const MCPhysReg ShadowRegList4[] = {
541 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
542 : };
543 3 : unsigned Offset5 = State.AllocateStack(4, 4, ShadowRegList4);
544 3 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset5, LocVT, LocInfo));
545 3 : return false;
546 : }
547 :
548 69 : if (LocVT == MVT::f64) {
549 : static const MCPhysReg ShadowRegList6[] = {
550 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
551 : };
552 3 : unsigned Offset7 = State.AllocateStack(8, 4, ShadowRegList6);
553 3 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset7, LocVT, LocInfo));
554 3 : return false;
555 : }
556 :
557 66 : if (LocVT == MVT::v2f64) {
558 : static const MCPhysReg ShadowRegList8[] = {
559 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
560 : };
561 0 : unsigned Offset9 = State.AllocateStack(16, 4, ShadowRegList8);
562 0 : State.addLoc(CCValAssign::getMem(ValNo, ValVT, Offset9, LocVT, LocInfo));
563 0 : return false;
564 : }
565 :
566 66 : if (!CC_ARM_APCS(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
567 66 : return false;
568 :
569 : return true; // CC didn't match.
570 : }
571 :
572 :
573 23374 : static bool RetCC_ARM_AAPCS(unsigned ValNo, MVT ValVT,
574 : MVT LocVT, CCValAssign::LocInfo LocInfo,
575 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
576 :
577 23197 : if (LocVT == MVT::v1i64 ||
578 22721 : LocVT == MVT::v2i32 ||
579 22317 : LocVT == MVT::v4i16 ||
580 22315 : LocVT == MVT::v4f16 ||
581 45265 : LocVT == MVT::v8i8 ||
582 : LocVT == MVT::v2f32) {
583 1637 : LocVT = MVT::f64;
584 1637 : LocInfo = CCValAssign::BCvt;
585 : }
586 :
587 23154 : if (LocVT == MVT::v2i64 ||
588 22694 : LocVT == MVT::v4i32 ||
589 22302 : LocVT == MVT::v8i16 ||
590 22298 : LocVT == MVT::v8f16 ||
591 45357 : LocVT == MVT::v16i8 ||
592 : LocVT == MVT::v4f32) {
593 1535 : LocVT = MVT::v2f64;
594 1535 : LocInfo = CCValAssign::BCvt;
595 : }
596 :
597 23374 : if (ArgFlags.isSwiftSelf()) {
598 0 : if (LocVT == MVT::i32) {
599 : if (unsigned Reg = State.AllocateReg(ARM::R10)) {
600 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
601 0 : return false;
602 : }
603 : }
604 : }
605 :
606 23374 : if (ArgFlags.isSwiftError()) {
607 12 : if (LocVT == MVT::i32) {
608 : if (unsigned Reg = State.AllocateReg(ARM::R8)) {
609 24 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
610 12 : return false;
611 : }
612 : }
613 : }
614 :
615 23362 : if (LocVT == MVT::f64 ||
616 : LocVT == MVT::v2f64) {
617 3967 : if (RetCC_ARM_AAPCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
618 : return false;
619 : }
620 :
621 19452 : if (LocVT == MVT::f32) {
622 1851 : LocVT = MVT::i32;
623 1851 : LocInfo = CCValAssign::BCvt;
624 : }
625 :
626 19452 : if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
627 19217 : return false;
628 :
629 : return true; // CC didn't match.
630 : }
631 :
632 :
633 22266 : static bool RetCC_ARM_AAPCS_Common(unsigned ValNo, MVT ValVT,
634 : MVT LocVT, CCValAssign::LocInfo LocInfo,
635 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
636 :
637 22259 : if (LocVT == MVT::i1 ||
638 44484 : LocVT == MVT::i8 ||
639 : LocVT == MVT::i16) {
640 : LocVT = MVT::i32;
641 95 : if (ArgFlags.isSExt())
642 : LocInfo = CCValAssign::SExt;
643 85 : else if (ArgFlags.isZExt())
644 : LocInfo = CCValAssign::ZExt;
645 : else
646 : LocInfo = CCValAssign::AExt;
647 : }
648 :
649 22266 : if (LocVT == MVT::i32) {
650 : static const MCPhysReg RegList1[] = {
651 : ARM::R0, ARM::R1, ARM::R2, ARM::R3
652 : };
653 22029 : if (unsigned Reg = State.AllocateReg(RegList1)) {
654 21985 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
655 21985 : return false;
656 : }
657 : }
658 :
659 281 : if (LocVT == MVT::i64) {
660 : static const MCPhysReg RegList2[] = {
661 : ARM::R0, ARM::R2
662 : };
663 : static const MCPhysReg RegList3[] = {
664 : ARM::R1, ARM::R3
665 : };
666 0 : if (unsigned Reg = State.AllocateReg(RegList2, RegList3)) {
667 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
668 0 : return false;
669 : }
670 : }
671 :
672 : return true; // CC didn't match.
673 : }
674 :
675 :
676 6639 : static bool RetCC_ARM_AAPCS_VFP(unsigned ValNo, MVT ValVT,
677 : MVT LocVT, CCValAssign::LocInfo LocInfo,
678 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
679 :
680 6615 : if (LocVT == MVT::v1i64 ||
681 6577 : LocVT == MVT::v2i32 ||
682 6493 : LocVT == MVT::v4i16 ||
683 6341 : LocVT == MVT::v4f16 ||
684 12950 : LocVT == MVT::v8i8 ||
685 : LocVT == MVT::v2f32) {
686 : LocVT = MVT::f64;
687 : LocInfo = CCValAssign::BCvt;
688 : }
689 :
690 6587 : if (LocVT == MVT::v2i64 ||
691 6521 : LocVT == MVT::v4i32 ||
692 6443 : LocVT == MVT::v8i16 ||
693 6295 : LocVT == MVT::v8f16 ||
694 12886 : LocVT == MVT::v16i8 ||
695 : LocVT == MVT::v4f32) {
696 : LocVT = MVT::v2f64;
697 : LocInfo = CCValAssign::BCvt;
698 : }
699 :
700 6639 : if (ArgFlags.isSwiftSelf()) {
701 0 : if (LocVT == MVT::i32) {
702 : if (unsigned Reg = State.AllocateReg(ARM::R10)) {
703 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
704 0 : return false;
705 : }
706 : }
707 : }
708 :
709 6639 : if (ArgFlags.isSwiftError()) {
710 36 : if (LocVT == MVT::i32) {
711 : if (unsigned Reg = State.AllocateReg(ARM::R8)) {
712 36 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
713 36 : return false;
714 : }
715 : }
716 : }
717 :
718 6603 : if (LocVT == MVT::v2f64) {
719 : static const MCPhysReg RegList1[] = {
720 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
721 : };
722 560 : if (unsigned Reg = State.AllocateReg(RegList1)) {
723 560 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
724 560 : return false;
725 : }
726 : }
727 :
728 6043 : if (LocVT == MVT::f64) {
729 : static const MCPhysReg RegList2[] = {
730 : ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
731 : };
732 1579 : if (unsigned Reg = State.AllocateReg(RegList2)) {
733 1579 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
734 1579 : return false;
735 : }
736 : }
737 :
738 4464 : if (LocVT == MVT::f32) {
739 : static const MCPhysReg RegList3[] = {
740 : ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
741 : };
742 1650 : if (unsigned Reg = State.AllocateReg(RegList3)) {
743 1650 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
744 1650 : return false;
745 : }
746 : }
747 :
748 2814 : if (!RetCC_ARM_AAPCS_Common(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
749 2768 : return false;
750 :
751 : return true; // CC didn't match.
752 : }
753 :
754 :
755 5941 : static bool RetCC_ARM_APCS(unsigned ValNo, MVT ValVT,
756 : MVT LocVT, CCValAssign::LocInfo LocInfo,
757 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
758 :
759 5935 : if (LocVT == MVT::i1 ||
760 11864 : LocVT == MVT::i8 ||
761 : LocVT == MVT::i16) {
762 30 : LocVT = MVT::i32;
763 30 : if (ArgFlags.isSExt())
764 0 : LocInfo = CCValAssign::SExt;
765 30 : else if (ArgFlags.isZExt())
766 0 : LocInfo = CCValAssign::ZExt;
767 : else
768 30 : LocInfo = CCValAssign::AExt;
769 : }
770 :
771 5941 : if (LocVT == MVT::f32) {
772 402 : LocVT = MVT::i32;
773 402 : LocInfo = CCValAssign::BCvt;
774 : }
775 :
776 5941 : if (ArgFlags.isSwiftSelf()) {
777 0 : if (LocVT == MVT::i32) {
778 : if (unsigned Reg = State.AllocateReg(ARM::R10)) {
779 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
780 0 : return false;
781 : }
782 : }
783 : }
784 :
785 5941 : if (ArgFlags.isSwiftError()) {
786 24 : if (LocVT == MVT::i32) {
787 : if (unsigned Reg = State.AllocateReg(ARM::R8)) {
788 48 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
789 24 : return false;
790 : }
791 : }
792 : }
793 :
794 5907 : if (LocVT == MVT::v1i64 ||
795 5877 : LocVT == MVT::v2i32 ||
796 5871 : LocVT == MVT::v4i16 ||
797 11762 : LocVT == MVT::v8i8 ||
798 : LocVT == MVT::v2f32) {
799 128 : LocVT = MVT::f64;
800 128 : LocInfo = CCValAssign::BCvt;
801 : }
802 :
803 5903 : if (LocVT == MVT::v2i64 ||
804 5885 : LocVT == MVT::v4i32 ||
805 5869 : LocVT == MVT::v8i16 ||
806 11760 : LocVT == MVT::v16i8 ||
807 : LocVT == MVT::v4f32) {
808 139 : LocVT = MVT::v2f64;
809 139 : LocInfo = CCValAssign::BCvt;
810 : }
811 :
812 5917 : if (LocVT == MVT::f64 ||
813 : LocVT == MVT::v2f64) {
814 452 : if (RetCC_ARM_APCS_Custom_f64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
815 : return false;
816 : }
817 :
818 5469 : if (LocVT == MVT::i32) {
819 : static const MCPhysReg RegList1[] = {
820 : ARM::R0, ARM::R1, ARM::R2, ARM::R3
821 : };
822 5465 : if (unsigned Reg = State.AllocateReg(RegList1)) {
823 10928 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
824 5464 : return false;
825 : }
826 : }
827 :
828 5 : if (LocVT == MVT::i64) {
829 : static const MCPhysReg RegList2[] = {
830 : ARM::R0, ARM::R2
831 : };
832 : static const MCPhysReg RegList3[] = {
833 : ARM::R1, ARM::R3
834 : };
835 0 : if (unsigned Reg = State.AllocateReg(RegList2, RegList3)) {
836 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
837 0 : return false;
838 : }
839 : }
840 :
841 : return true; // CC didn't match.
842 : }
843 :
844 :
845 98 : static bool RetFastCC_ARM_APCS(unsigned ValNo, MVT ValVT,
846 : MVT LocVT, CCValAssign::LocInfo LocInfo,
847 : ISD::ArgFlagsTy ArgFlags, CCState &State) {
848 :
849 98 : if (LocVT == MVT::v1i64 ||
850 98 : LocVT == MVT::v2i32 ||
851 98 : LocVT == MVT::v4i16 ||
852 196 : LocVT == MVT::v8i8 ||
853 : LocVT == MVT::v2f32) {
854 : LocVT = MVT::f64;
855 : LocInfo = CCValAssign::BCvt;
856 : }
857 :
858 98 : if (LocVT == MVT::v2i64 ||
859 98 : LocVT == MVT::v4i32 ||
860 98 : LocVT == MVT::v8i16 ||
861 196 : LocVT == MVT::v16i8 ||
862 : LocVT == MVT::v4f32) {
863 : LocVT = MVT::v2f64;
864 : LocInfo = CCValAssign::BCvt;
865 : }
866 :
867 98 : if (LocVT == MVT::v2f64) {
868 : static const MCPhysReg RegList1[] = {
869 : ARM::Q0, ARM::Q1, ARM::Q2, ARM::Q3
870 : };
871 0 : if (unsigned Reg = State.AllocateReg(RegList1)) {
872 0 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
873 0 : return false;
874 : }
875 : }
876 :
877 98 : if (LocVT == MVT::f64) {
878 : static const MCPhysReg RegList2[] = {
879 : ARM::D0, ARM::D1, ARM::D2, ARM::D3, ARM::D4, ARM::D5, ARM::D6, ARM::D7
880 : };
881 8 : if (unsigned Reg = State.AllocateReg(RegList2)) {
882 8 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
883 8 : return false;
884 : }
885 : }
886 :
887 90 : if (LocVT == MVT::f32) {
888 : static const MCPhysReg RegList3[] = {
889 : ARM::S0, ARM::S1, ARM::S2, ARM::S3, ARM::S4, ARM::S5, ARM::S6, ARM::S7, ARM::S8, ARM::S9, ARM::S10, ARM::S11, ARM::S12, ARM::S13, ARM::S14, ARM::S15
890 : };
891 4 : if (unsigned Reg = State.AllocateReg(RegList3)) {
892 4 : State.addLoc(CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, LocInfo));
893 4 : return false;
894 : }
895 : }
896 :
897 86 : if (!RetCC_ARM_APCS(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
898 86 : return false;
899 :
900 : return true; // CC didn't match.
901 : }
|