1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Calling Convention Implementation Fragment *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#if !defined(GET_CC_REGISTER_LISTS)
10
11static bool CC_SystemZ(unsigned ValNo, MVT ValVT,
12 MVT LocVT, CCValAssign::LocInfo LocInfo,
13 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
14static bool CC_SystemZ_ELF(unsigned ValNo, MVT ValVT,
15 MVT LocVT, CCValAssign::LocInfo LocInfo,
16 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
17static bool CC_SystemZ_GHC(unsigned ValNo, MVT ValVT,
18 MVT LocVT, CCValAssign::LocInfo LocInfo,
19 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
20static bool CC_SystemZ_XPLINK64(unsigned ValNo, MVT ValVT,
21 MVT LocVT, CCValAssign::LocInfo LocInfo,
22 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
23static bool RetCC_SystemZ(unsigned ValNo, MVT ValVT,
24 MVT LocVT, CCValAssign::LocInfo LocInfo,
25 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
26static bool RetCC_SystemZ_ELF(unsigned ValNo, MVT ValVT,
27 MVT LocVT, CCValAssign::LocInfo LocInfo,
28 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
29static bool RetCC_SystemZ_XPLINK64(unsigned ValNo, MVT ValVT,
30 MVT LocVT, CCValAssign::LocInfo LocInfo,
31 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
32
33
34static bool CC_SystemZ(unsigned ValNo, MVT ValVT,
35 MVT LocVT, CCValAssign::LocInfo LocInfo,
36 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
37
38 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().isTargetXPLINK64()) {
39 if (!CC_SystemZ_XPLINK64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
40 return false;
41 }
42
43 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().isTargetELF()) {
44 if (!CC_SystemZ_ELF(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
45 return false;
46 }
47
48 return true; // CC didn't match.
49}
50
51
52static bool CC_SystemZ_ELF(unsigned ValNo, MVT ValVT,
53 MVT LocVT, CCValAssign::LocInfo LocInfo,
54 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
55
56 if (State.getCallingConv() == CallingConv::GHC) {
57 if (!CC_SystemZ_GHC(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
58 return false;
59 }
60
61 if (LocVT == MVT::i32) {
62 if (ArgFlags.isSExt() || ArgFlags.isZExt()) {
63 LocVT = MVT::i64;
64 if (ArgFlags.isSExt())
65 LocInfo = CCValAssign::SExt;
66 else if (ArgFlags.isZExt())
67 LocInfo = CCValAssign::ZExt;
68 else
69 LocInfo = CCValAssign::AExt;
70 }
71 }
72
73 if (ArgFlags.isSwiftSelf()) {
74 if (LocVT == MVT::i64) {
75 if (MCRegister Reg = State.AllocateReg(Reg: SystemZ::R10D)) {
76 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
77 return false;
78 }
79 }
80 }
81
82 if (ArgFlags.isSwiftError()) {
83 if (LocVT == MVT::i64) {
84 if (MCRegister Reg = State.AllocateReg(Reg: SystemZ::R9D)) {
85 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
86 return false;
87 }
88 }
89 }
90
91 if (LocVT == MVT::i128 ||
92 LocVT == MVT::f128) {
93 LocVT = MVT::i64;
94 LocInfo = CCValAssign::Indirect;
95 }
96
97 if (LocVT == MVT::i64) {
98 if (CC_SystemZ_I128Indirect(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
99 return false;
100 }
101
102 if (LocVT == MVT::i32) {
103 static const MCPhysReg RegList1[] = {
104 SystemZ::R2L, SystemZ::R3L, SystemZ::R4L, SystemZ::R5L, SystemZ::R6L
105 };
106 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
107 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
108 return false;
109 }
110 }
111
112 if (LocVT == MVT::i64) {
113 static const MCPhysReg RegList2[] = {
114 SystemZ::R2D, SystemZ::R3D, SystemZ::R4D, SystemZ::R5D, SystemZ::R6D
115 };
116 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
117 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
118 return false;
119 }
120 }
121
122 if (LocVT == MVT::f16) {
123 static const MCPhysReg RegList3[] = {
124 SystemZ::F0H, SystemZ::F2H, SystemZ::F4H, SystemZ::F6H
125 };
126 if (MCRegister Reg = State.AllocateReg(Regs: RegList3)) {
127 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
128 return false;
129 }
130 }
131
132 if (LocVT == MVT::f32) {
133 static const MCPhysReg RegList4[] = {
134 SystemZ::F0S, SystemZ::F2S, SystemZ::F4S, SystemZ::F6S
135 };
136 if (MCRegister Reg = State.AllocateReg(Regs: RegList4)) {
137 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
138 return false;
139 }
140 }
141
142 if (LocVT == MVT::f64) {
143 static const MCPhysReg RegList5[] = {
144 SystemZ::F0D, SystemZ::F2D, SystemZ::F4D, SystemZ::F6D
145 };
146 if (MCRegister Reg = State.AllocateReg(Regs: RegList5)) {
147 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
148 return false;
149 }
150 }
151
152 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
153 if (LocVT == MVT::v16i8 ||
154 LocVT == MVT::v8i16 ||
155 LocVT == MVT::v4i32 ||
156 LocVT == MVT::v2i64 ||
157 LocVT == MVT::v8f16 ||
158 LocVT == MVT::v4f32 ||
159 LocVT == MVT::v2f64) {
160 if (!ArgFlags.isVarArg()) {
161 static const MCPhysReg RegList6[] = {
162 SystemZ::V24, SystemZ::V26, SystemZ::V28, SystemZ::V30, SystemZ::V25, SystemZ::V27, SystemZ::V29, SystemZ::V31
163 };
164 if (MCRegister Reg = State.AllocateReg(Regs: RegList6)) {
165 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
166 return false;
167 }
168 }
169 }
170 }
171
172 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
173 if (LocVT == MVT::v16i8 ||
174 LocVT == MVT::v8i16 ||
175 LocVT == MVT::v4i32 ||
176 LocVT == MVT::v2i64 ||
177 LocVT == MVT::v8f16 ||
178 LocVT == MVT::v4f32 ||
179 LocVT == MVT::v2f64) {
180 if (OrigTy->isVectorTy() && OrigTy->getPrimitiveSizeInBits() <= 64) {
181 LocVT = MVT::i64;
182 LocInfo = CCValAssign::BCvt;
183 }
184 }
185 }
186
187 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
188 if (LocVT == MVT::v16i8 ||
189 LocVT == MVT::v8i16 ||
190 LocVT == MVT::v4i32 ||
191 LocVT == MVT::v2i64 ||
192 LocVT == MVT::v8f16 ||
193 LocVT == MVT::v4f32 ||
194 LocVT == MVT::v2f64) {
195 int64_t Offset7 = State.AllocateStack(Size: 16, Alignment: Align(8));
196 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset7, LocVT, HTP: LocInfo));
197 return false;
198 }
199 }
200
201 if (LocVT == MVT::i32 ||
202 LocVT == MVT::i64 ||
203 LocVT == MVT::f16 ||
204 LocVT == MVT::f32 ||
205 LocVT == MVT::f64) {
206 int64_t Offset8 = State.AllocateStack(Size: 8, Alignment: Align(8));
207 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset8, LocVT, HTP: LocInfo));
208 return false;
209 }
210
211 return true; // CC didn't match.
212}
213
214
215static bool CC_SystemZ_GHC(unsigned ValNo, MVT ValVT,
216 MVT LocVT, CCValAssign::LocInfo LocInfo,
217 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
218
219 if (LocVT == MVT::i64) {
220 static const MCPhysReg RegList1[] = {
221 SystemZ::R7D, SystemZ::R8D, SystemZ::R10D, SystemZ::R11D, SystemZ::R12D, SystemZ::R13D, SystemZ::R6D, SystemZ::R2D, SystemZ::R3D, SystemZ::R4D, SystemZ::R5D, SystemZ::R9D
222 };
223 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
224 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
225 return false;
226 }
227 }
228
229 if (LocVT == MVT::f32) {
230 static const MCPhysReg RegList2[] = {
231 SystemZ::F8S, SystemZ::F9S, SystemZ::F10S, SystemZ::F11S, SystemZ::F0S, SystemZ::F1S
232 };
233 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
234 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
235 return false;
236 }
237 }
238
239 if (LocVT == MVT::f64) {
240 static const MCPhysReg RegList3[] = {
241 SystemZ::F12D, SystemZ::F13D, SystemZ::F14D, SystemZ::F15D, SystemZ::F2D, SystemZ::F3D
242 };
243 if (MCRegister Reg = State.AllocateReg(Regs: RegList3)) {
244 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
245 return false;
246 }
247 }
248
249 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
250 if (LocVT == MVT::v16i8 ||
251 LocVT == MVT::v8i16 ||
252 LocVT == MVT::v4i32 ||
253 LocVT == MVT::v2i64 ||
254 LocVT == MVT::v4f32 ||
255 LocVT == MVT::v2f64) {
256 if (!ArgFlags.isVarArg()) {
257 static const MCPhysReg RegList4[] = {
258 SystemZ::V16, SystemZ::V17, SystemZ::V18, SystemZ::V19, SystemZ::V20, SystemZ::V21
259 };
260 if (MCRegister Reg = State.AllocateReg(Regs: RegList4)) {
261 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
262 return false;
263 }
264 }
265 }
266 }
267
268 if (CC_SystemZ_GHC_Error(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
269 return false;
270
271 return true; // CC didn't match.
272}
273
274
275static bool CC_SystemZ_XPLINK64(unsigned ValNo, MVT ValVT,
276 MVT LocVT, CCValAssign::LocInfo LocInfo,
277 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
278
279 if (LocVT == MVT::i32) {
280 if (ArgFlags.isSExt() || ArgFlags.isZExt()) {
281 LocVT = MVT::i64;
282 if (ArgFlags.isSExt())
283 LocInfo = CCValAssign::SExt;
284 else if (ArgFlags.isZExt())
285 LocInfo = CCValAssign::ZExt;
286 else
287 LocInfo = CCValAssign::AExt;
288 }
289 }
290
291 if (LocVT == MVT::f32 ||
292 LocVT == MVT::f64) {
293 if (ArgFlags.isVarArg()) {
294 LocVT = MVT::i64;
295 LocInfo = CCValAssign::BCvt;
296 }
297 }
298
299 if (ArgFlags.isPointer()) {
300 if (CC_XPLINK64_Pointer(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
301 return false;
302 }
303
304 if (LocVT == MVT::f128) {
305 if (ArgFlags.isVarArg()) {
306 if (CC_XPLINK64_Allocate128BitVararg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
307 return false;
308 }
309 }
310
311 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
312 if (LocVT == MVT::v16i8 ||
313 LocVT == MVT::v8i16 ||
314 LocVT == MVT::v4i32 ||
315 LocVT == MVT::v2i64 ||
316 LocVT == MVT::v4f32 ||
317 LocVT == MVT::v2f64) {
318 if (ArgFlags.isVarArg()) {
319 if (CC_XPLINK64_Allocate128BitVararg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
320 return false;
321 }
322 }
323 }
324
325 if (ArgFlags.isSwiftSelf()) {
326 if (LocVT == MVT::i64) {
327 if (MCRegister Reg = State.AllocateReg(Reg: SystemZ::R10D)) {
328 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
329 return false;
330 }
331 }
332 }
333
334 if (ArgFlags.isSwiftError()) {
335 if (LocVT == MVT::i64) {
336 if (MCRegister Reg = State.AllocateReg(Reg: SystemZ::R0D)) {
337 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
338 return false;
339 }
340 }
341 }
342
343 if (LocVT == MVT::i128) {
344 LocVT = MVT::i64;
345 LocInfo = CCValAssign::Indirect;
346 }
347
348 if (LocVT == MVT::i64) {
349 if (CC_SystemZ_I128Indirect(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
350 return false;
351 }
352
353 if (LocVT == MVT::i64) {
354 static const MCPhysReg RegList1[] = {
355 SystemZ::R1D, SystemZ::R2D, SystemZ::R3D
356 };
357 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
358 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
359 (void)State.AllocateStack(Size: 8, Alignment: Align(8));
360 return false;
361 }
362 }
363
364 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
365 if (LocVT == MVT::v16i8 ||
366 LocVT == MVT::v8i16 ||
367 LocVT == MVT::v4i32 ||
368 LocVT == MVT::v2i64 ||
369 LocVT == MVT::v4f32 ||
370 LocVT == MVT::v2f64) {
371 if (!ArgFlags.isVarArg()) {
372 if (CC_XPLINK64_Shadow_Reg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
373 return false;
374 }
375 }
376 }
377
378 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
379 if (LocVT == MVT::v16i8 ||
380 LocVT == MVT::v8i16 ||
381 LocVT == MVT::v4i32 ||
382 LocVT == MVT::v2i64 ||
383 LocVT == MVT::v4f32 ||
384 LocVT == MVT::v2f64) {
385 if (!ArgFlags.isVarArg()) {
386 static const MCPhysReg RegList2[] = {
387 SystemZ::V24, SystemZ::V25, SystemZ::V26, SystemZ::V27, SystemZ::V28, SystemZ::V29, SystemZ::V30, SystemZ::V31
388 };
389 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
390 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
391 (void)State.AllocateStack(Size: 16, Alignment: Align(8));
392 return false;
393 }
394 }
395 }
396 }
397
398 if (LocVT == MVT::f32 ||
399 LocVT == MVT::f64) {
400 if (!ArgFlags.isVarArg()) {
401 if (CC_XPLINK64_Shadow_Reg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
402 return false;
403 }
404 }
405
406 if (LocVT == MVT::f32) {
407 if (!ArgFlags.isVarArg()) {
408 static const MCPhysReg RegList3[] = {
409 SystemZ::F0S, SystemZ::F2S, SystemZ::F4S, SystemZ::F6S
410 };
411 if (MCRegister Reg = State.AllocateReg(Regs: RegList3)) {
412 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
413 (void)State.AllocateStack(Size: 4, Alignment: Align(8));
414 return false;
415 }
416 }
417 }
418
419 if (LocVT == MVT::f64) {
420 if (!ArgFlags.isVarArg()) {
421 static const MCPhysReg RegList4[] = {
422 SystemZ::F0D, SystemZ::F2D, SystemZ::F4D, SystemZ::F6D
423 };
424 if (MCRegister Reg = State.AllocateReg(Regs: RegList4)) {
425 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
426 (void)State.AllocateStack(Size: 8, Alignment: Align(8));
427 return false;
428 }
429 }
430 }
431
432 if (LocVT == MVT::f128) {
433 if (!ArgFlags.isVarArg()) {
434 if (CC_XPLINK64_Shadow_Reg(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
435 return false;
436 }
437 }
438
439 if (LocVT == MVT::f128) {
440 if (!ArgFlags.isVarArg()) {
441 static const MCPhysReg RegList5[] = {
442 SystemZ::F0Q, SystemZ::F4Q
443 };
444 if (MCRegister Reg = State.AllocateReg(Regs: RegList5)) {
445 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
446 (void)State.AllocateStack(Size: 16, Alignment: Align(8));
447 return false;
448 }
449 }
450 }
451
452 if (LocVT == MVT::i32 ||
453 LocVT == MVT::i64 ||
454 LocVT == MVT::f32 ||
455 LocVT == MVT::f64) {
456 int64_t Offset6 = State.AllocateStack(Size: 8, Alignment: Align(8));
457 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset6, LocVT, HTP: LocInfo));
458 return false;
459 }
460
461 if (LocVT == MVT::f128) {
462 int64_t Offset7 = State.AllocateStack(Size: 16, Alignment: Align(8));
463 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset7, LocVT, HTP: LocInfo));
464 return false;
465 }
466
467 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
468 if (LocVT == MVT::v16i8 ||
469 LocVT == MVT::v8i16 ||
470 LocVT == MVT::v4i32 ||
471 LocVT == MVT::v2i64 ||
472 LocVT == MVT::v4f32 ||
473 LocVT == MVT::v2f64) {
474 int64_t Offset8 = State.AllocateStack(Size: 16, Alignment: Align(8));
475 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset8, LocVT, HTP: LocInfo));
476 return false;
477 }
478 }
479
480 return true; // CC didn't match.
481}
482
483
484static bool RetCC_SystemZ(unsigned ValNo, MVT ValVT,
485 MVT LocVT, CCValAssign::LocInfo LocInfo,
486 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
487
488 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().isTargetXPLINK64()) {
489 if (!RetCC_SystemZ_XPLINK64(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
490 return false;
491 }
492
493 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().isTargetELF()) {
494 if (!RetCC_SystemZ_ELF(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
495 return false;
496 }
497
498 return true; // CC didn't match.
499}
500
501
502static bool RetCC_SystemZ_ELF(unsigned ValNo, MVT ValVT,
503 MVT LocVT, CCValAssign::LocInfo LocInfo,
504 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
505
506 if (LocVT == MVT::i32) {
507 if (ArgFlags.isSExt() || ArgFlags.isZExt()) {
508 LocVT = MVT::i64;
509 if (ArgFlags.isSExt())
510 LocInfo = CCValAssign::SExt;
511 else if (ArgFlags.isZExt())
512 LocInfo = CCValAssign::ZExt;
513 else
514 LocInfo = CCValAssign::AExt;
515 }
516 }
517
518 if (ArgFlags.isSwiftError()) {
519 if (LocVT == MVT::i64) {
520 if (MCRegister Reg = State.AllocateReg(Reg: SystemZ::R9D)) {
521 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
522 return false;
523 }
524 }
525 }
526
527 if (LocVT == MVT::i32) {
528 static const MCPhysReg RegList1[] = {
529 SystemZ::R2L, SystemZ::R3L, SystemZ::R4L, SystemZ::R5L
530 };
531 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
532 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
533 return false;
534 }
535 }
536
537 if (LocVT == MVT::i64) {
538 static const MCPhysReg RegList2[] = {
539 SystemZ::R2D, SystemZ::R3D, SystemZ::R4D, SystemZ::R5D
540 };
541 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
542 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
543 return false;
544 }
545 }
546
547 if (LocVT == MVT::f16) {
548 static const MCPhysReg RegList3[] = {
549 SystemZ::F0H, SystemZ::F2H, SystemZ::F4H, SystemZ::F6H
550 };
551 if (MCRegister Reg = State.AllocateReg(Regs: RegList3)) {
552 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
553 return false;
554 }
555 }
556
557 if (LocVT == MVT::f32) {
558 static const MCPhysReg RegList4[] = {
559 SystemZ::F0S, SystemZ::F2S, SystemZ::F4S, SystemZ::F6S
560 };
561 if (MCRegister Reg = State.AllocateReg(Regs: RegList4)) {
562 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
563 return false;
564 }
565 }
566
567 if (LocVT == MVT::f64) {
568 static const MCPhysReg RegList5[] = {
569 SystemZ::F0D, SystemZ::F2D, SystemZ::F4D, SystemZ::F6D
570 };
571 if (MCRegister Reg = State.AllocateReg(Regs: RegList5)) {
572 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
573 return false;
574 }
575 }
576
577 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
578 if (LocVT == MVT::v16i8 ||
579 LocVT == MVT::v8i16 ||
580 LocVT == MVT::v4i32 ||
581 LocVT == MVT::v2i64 ||
582 LocVT == MVT::v8f16 ||
583 LocVT == MVT::v4f32 ||
584 LocVT == MVT::v2f64) {
585 static const MCPhysReg RegList6[] = {
586 SystemZ::V24, SystemZ::V26, SystemZ::V28, SystemZ::V30, SystemZ::V25, SystemZ::V27, SystemZ::V29, SystemZ::V31
587 };
588 if (MCRegister Reg = State.AllocateReg(Regs: RegList6)) {
589 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
590 return false;
591 }
592 }
593 }
594
595 return true; // CC didn't match.
596}
597
598
599static bool RetCC_SystemZ_XPLINK64(unsigned ValNo, MVT ValVT,
600 MVT LocVT, CCValAssign::LocInfo LocInfo,
601 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
602
603 if (LocVT == MVT::i32) {
604 LocVT = MVT::i64;
605 if (ArgFlags.isSExt())
606 LocInfo = CCValAssign::SExt;
607 else if (ArgFlags.isZExt())
608 LocInfo = CCValAssign::ZExt;
609 else
610 LocInfo = CCValAssign::AExt;
611 }
612
613 if (LocVT == MVT::i64) {
614 if (ArgFlags.isInReg()) {
615 static const MCPhysReg RegList1[] = {
616 SystemZ::R1D, SystemZ::R2D, SystemZ::R3D
617 };
618 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
619 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
620 return false;
621 }
622 }
623 }
624
625 if (LocVT == MVT::i64) {
626 static const MCPhysReg RegList2[] = {
627 SystemZ::R3D, SystemZ::R2D, SystemZ::R1D
628 };
629 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
630 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
631 return false;
632 }
633 }
634
635 if (LocVT == MVT::f32) {
636 static const MCPhysReg RegList3[] = {
637 SystemZ::F0S, SystemZ::F2S, SystemZ::F4S, SystemZ::F6S
638 };
639 if (MCRegister Reg = State.AllocateReg(Regs: RegList3)) {
640 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
641 return false;
642 }
643 }
644
645 if (LocVT == MVT::f64) {
646 static const MCPhysReg RegList4[] = {
647 SystemZ::F0D, SystemZ::F2D, SystemZ::F4D, SystemZ::F6D
648 };
649 if (MCRegister Reg = State.AllocateReg(Regs: RegList4)) {
650 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
651 return false;
652 }
653 }
654
655 if (LocVT == MVT::f128) {
656 static const MCPhysReg RegList5[] = {
657 SystemZ::F0Q, SystemZ::F4Q
658 };
659 if (MCRegister Reg = State.AllocateReg(Regs: RegList5)) {
660 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
661 return false;
662 }
663 }
664
665 if (State.getMachineFunction().getSubtarget<SystemZSubtarget>().hasVector()) {
666 if (LocVT == MVT::v16i8 ||
667 LocVT == MVT::v8i16 ||
668 LocVT == MVT::v4i32 ||
669 LocVT == MVT::v2i64 ||
670 LocVT == MVT::v4f32 ||
671 LocVT == MVT::v2f64) {
672 static const MCPhysReg RegList6[] = {
673 SystemZ::V24, SystemZ::V25, SystemZ::V26, SystemZ::V27, SystemZ::V28, SystemZ::V29, SystemZ::V30, SystemZ::V31
674 };
675 if (MCRegister Reg = State.AllocateReg(Regs: RegList6)) {
676 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
677 return false;
678 }
679 }
680 }
681
682 return true; // CC didn't match.
683}
684
685#else
686
687const MCRegister CC_SystemZ_ArgRegs[] = { 0 };
688const MCRegister CC_SystemZ_ELF_ArgRegs[] = { SystemZ::F0D, SystemZ::F0H, SystemZ::F0S, SystemZ::F2D, SystemZ::F2H, SystemZ::F2S, SystemZ::F4D, SystemZ::F4H, SystemZ::F4S, SystemZ::F6D, SystemZ::F6H, SystemZ::F6S, SystemZ::R2D, SystemZ::R2L, SystemZ::R3D, SystemZ::R3L, SystemZ::R4D, SystemZ::R4L, SystemZ::R5D, SystemZ::R5L, SystemZ::R6D, SystemZ::R6L, SystemZ::V24, SystemZ::V25, SystemZ::V26, SystemZ::V27, SystemZ::V28, SystemZ::V29, SystemZ::V30, SystemZ::V31 };
689const MCRegister CC_SystemZ_GHC_ArgRegs[] = { SystemZ::F0S, SystemZ::F10S, SystemZ::F11S, SystemZ::F12D, SystemZ::F13D, SystemZ::F14D, SystemZ::F15D, SystemZ::F1S, SystemZ::F2D, SystemZ::F3D, SystemZ::F8S, SystemZ::F9S, SystemZ::R10D, SystemZ::R11D, SystemZ::R12D, SystemZ::R13D, SystemZ::R2D, SystemZ::R3D, SystemZ::R4D, SystemZ::R5D, SystemZ::R6D, SystemZ::R7D, SystemZ::R8D, SystemZ::R9D, SystemZ::V16, SystemZ::V17, SystemZ::V18, SystemZ::V19, SystemZ::V20, SystemZ::V21 };
690const MCRegister CC_SystemZ_XPLINK64_ArgRegs[] = { SystemZ::F0D, SystemZ::F0Q, SystemZ::F0S, SystemZ::F2D, SystemZ::F2S, SystemZ::F4D, SystemZ::F4Q, SystemZ::F4S, SystemZ::F6D, SystemZ::F6S, SystemZ::R1D, SystemZ::R2D, SystemZ::R3D, SystemZ::V24, SystemZ::V25, SystemZ::V26, SystemZ::V27, SystemZ::V28, SystemZ::V29, SystemZ::V30, SystemZ::V31 };
691const MCRegister RetCC_SystemZ_ArgRegs[] = { 0 };
692const MCRegister RetCC_SystemZ_ELF_ArgRegs[] = { SystemZ::F0D, SystemZ::F0H, SystemZ::F0S, SystemZ::F2D, SystemZ::F2H, SystemZ::F2S, SystemZ::F4D, SystemZ::F4H, SystemZ::F4S, SystemZ::F6D, SystemZ::F6H, SystemZ::F6S, SystemZ::R2D, SystemZ::R2L, SystemZ::R3D, SystemZ::R3L, SystemZ::R4D, SystemZ::R4L, SystemZ::R5D, SystemZ::R5L, SystemZ::V24, SystemZ::V25, SystemZ::V26, SystemZ::V27, SystemZ::V28, SystemZ::V29, SystemZ::V30, SystemZ::V31 };
693const MCRegister RetCC_SystemZ_XPLINK64_ArgRegs[] = { SystemZ::F0D, SystemZ::F0Q, SystemZ::F0S, SystemZ::F2D, SystemZ::F2S, SystemZ::F4D, SystemZ::F4Q, SystemZ::F4S, SystemZ::F6D, SystemZ::F6S, SystemZ::R1D, SystemZ::R2D, SystemZ::R3D, SystemZ::V24, SystemZ::V25, SystemZ::V26, SystemZ::V27, SystemZ::V28, SystemZ::V29, SystemZ::V30, SystemZ::V31 };
694
695// Registers used by Swift.
696const MCRegister CC_SystemZ_ELF_Swift_ArgRegs[] = { SystemZ::R10D, SystemZ::R9D };
697const MCRegister CC_SystemZ_XPLINK64_Swift_ArgRegs[] = { SystemZ::R0D, SystemZ::R10D };
698const MCRegister RetCC_SystemZ_ELF_Swift_ArgRegs[] = { SystemZ::R9D };
699
700#endif // !defined(GET_CC_REGISTER_LISTS)
701
702