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