1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Calling Convention Implementation Fragment *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9#ifdef GET_CALLING_CONV_IMPL
10#undef GET_CALLING_CONV_IMPL
11
12static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
13 MVT LocVT, CCValAssign::LocInfo LocInfo,
14 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
15static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
16 MVT LocVT, CCValAssign::LocInfo LocInfo,
17 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
18static bool CC_Hexagon_Legacy(unsigned ValNo, MVT ValVT,
19 MVT LocVT, CCValAssign::LocInfo LocInfo,
20 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
21static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
22 MVT LocVT, CCValAssign::LocInfo LocInfo,
23 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State);
24
25
26static bool CC_Hexagon(unsigned ValNo, MVT ValVT,
27 MVT LocVT, CCValAssign::LocInfo LocInfo,
28 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
29
30 if (LocVT == MVT::i1 ||
31 LocVT == MVT::i8 ||
32 LocVT == MVT::i16) {
33 LocVT = MVT::i32;
34 if (ArgFlags.isSExt())
35 LocInfo = CCValAssign::SExt;
36 else if (ArgFlags.isZExt())
37 LocInfo = CCValAssign::ZExt;
38 else
39 LocInfo = CCValAssign::AExt;
40 }
41
42 if (LocVT == MVT::bf16) {
43 LocVT = MVT::i32;
44 LocInfo = CCValAssign::BCvt;
45 }
46
47 if (LocVT == MVT::f32) {
48 LocVT = MVT::i32;
49 LocInfo = CCValAssign::BCvt;
50 }
51
52 if (LocVT == MVT::f64) {
53 LocVT = MVT::i64;
54 LocInfo = CCValAssign::BCvt;
55 }
56
57 if (ArgFlags.isByVal()) {
58 State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, MinSize: 8, MinAlign: Align(1), ArgFlags);
59 return false;
60 }
61
62 if (State.isVarArg() && ArgFlags.isVarArg()) {
63 if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
64 return false;
65 }
66
67 if (LocVT == MVT::i32) {
68 if (ArgFlags.isSplit()) {
69 if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
70 return false;
71 }
72 }
73
74 if (LocVT == MVT::v2i1) {
75 LocVT = MVT::v2i32;
76 if (ArgFlags.isSExt())
77 LocInfo = CCValAssign::SExt;
78 else if (ArgFlags.isZExt())
79 LocInfo = CCValAssign::ZExt;
80 else
81 LocInfo = CCValAssign::AExt;
82 }
83
84 if (LocVT == MVT::v4i1) {
85 LocVT = MVT::v4i16;
86 if (ArgFlags.isSExt())
87 LocInfo = CCValAssign::SExt;
88 else if (ArgFlags.isZExt())
89 LocInfo = CCValAssign::ZExt;
90 else
91 LocInfo = CCValAssign::AExt;
92 }
93
94 if (LocVT == MVT::v8i1) {
95 LocVT = MVT::v8i8;
96 if (ArgFlags.isSExt())
97 LocInfo = CCValAssign::SExt;
98 else if (ArgFlags.isZExt())
99 LocInfo = CCValAssign::ZExt;
100 else
101 LocInfo = CCValAssign::AExt;
102 }
103
104 if (LocVT == MVT::i32 ||
105 LocVT == MVT::v2i16 ||
106 LocVT == MVT::v4i8) {
107 static const MCPhysReg RegList1[] = {
108 Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
109 };
110 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
111 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
112 return false;
113 }
114 }
115
116 if (LocVT == MVT::i64 ||
117 LocVT == MVT::v2i32 ||
118 LocVT == MVT::v4i16 ||
119 LocVT == MVT::v8i8) {
120 if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
121 return false;
122 }
123
124 if (LocVT == MVT::i64 ||
125 LocVT == MVT::v2i32 ||
126 LocVT == MVT::v4i16 ||
127 LocVT == MVT::v8i8) {
128 static const MCPhysReg RegList2[] = {
129 Hexagon::D0, Hexagon::D1, Hexagon::D2
130 };
131 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
132 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
133 return false;
134 }
135 }
136
137 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
138 if (LocVT == MVT::v16i1) {
139 LocVT = MVT::v16i32;
140 if (ArgFlags.isSExt())
141 LocInfo = CCValAssign::SExt;
142 else if (ArgFlags.isZExt())
143 LocInfo = CCValAssign::ZExt;
144 else
145 LocInfo = CCValAssign::AExt;
146 }
147 }
148
149 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
150 if (LocVT == MVT::v32i1) {
151 LocVT = MVT::v32i16;
152 if (ArgFlags.isSExt())
153 LocInfo = CCValAssign::SExt;
154 else if (ArgFlags.isZExt())
155 LocInfo = CCValAssign::ZExt;
156 else
157 LocInfo = CCValAssign::AExt;
158 }
159 }
160
161 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
162 if (LocVT == MVT::v64i1) {
163 LocVT = MVT::v64i8;
164 if (ArgFlags.isSExt())
165 LocInfo = CCValAssign::SExt;
166 else if (ArgFlags.isZExt())
167 LocInfo = CCValAssign::ZExt;
168 else
169 LocInfo = CCValAssign::AExt;
170 }
171 }
172
173 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
174 if (LocVT == MVT::v16i32 ||
175 LocVT == MVT::v32i16 ||
176 LocVT == MVT::v64i8) {
177 static const MCPhysReg RegList3[] = {
178 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
179 };
180 if (MCRegister Reg = State.AllocateReg(Regs: RegList3)) {
181 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
182 return false;
183 }
184 }
185 }
186
187 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
188 if (LocVT == MVT::v32i32 ||
189 LocVT == MVT::v64i16 ||
190 LocVT == MVT::v128i8) {
191 static const MCPhysReg RegList4[] = {
192 Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
193 };
194 if (MCRegister Reg = State.AllocateReg(Regs: RegList4)) {
195 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
196 return false;
197 }
198 }
199 }
200
201 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
202 if (LocVT == MVT::v16i32 ||
203 LocVT == MVT::v32i16 ||
204 LocVT == MVT::v64i8) {
205 int64_t Offset5 = State.AllocateStack(Size: 64, Alignment: Align(64));
206 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset5, LocVT, HTP: LocInfo));
207 return false;
208 }
209 }
210
211 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
212 if (LocVT == MVT::v32i32 ||
213 LocVT == MVT::v64i16 ||
214 LocVT == MVT::v128i8) {
215 int64_t Offset6 = State.AllocateStack(Size: 128, Alignment: Align(64));
216 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset6, LocVT, HTP: LocInfo));
217 return false;
218 }
219 }
220
221 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
222 if (LocVT == MVT::v32i1) {
223 LocVT = MVT::v32i32;
224 if (ArgFlags.isSExt())
225 LocInfo = CCValAssign::SExt;
226 else if (ArgFlags.isZExt())
227 LocInfo = CCValAssign::ZExt;
228 else
229 LocInfo = CCValAssign::AExt;
230 }
231 }
232
233 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
234 if (LocVT == MVT::v64i1) {
235 LocVT = MVT::v64i16;
236 if (ArgFlags.isSExt())
237 LocInfo = CCValAssign::SExt;
238 else if (ArgFlags.isZExt())
239 LocInfo = CCValAssign::ZExt;
240 else
241 LocInfo = CCValAssign::AExt;
242 }
243 }
244
245 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
246 if (LocVT == MVT::v128i1) {
247 LocVT = MVT::v128i8;
248 if (ArgFlags.isSExt())
249 LocInfo = CCValAssign::SExt;
250 else if (ArgFlags.isZExt())
251 LocInfo = CCValAssign::ZExt;
252 else
253 LocInfo = CCValAssign::AExt;
254 }
255 }
256
257 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
258 if (LocVT == MVT::v32i32 ||
259 LocVT == MVT::v64i16 ||
260 LocVT == MVT::v128i8 ||
261 LocVT == MVT::v32f32 ||
262 LocVT == MVT::v64f16 ||
263 LocVT == MVT::v64bf16) {
264 static const MCPhysReg RegList7[] = {
265 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
266 };
267 if (MCRegister Reg = State.AllocateReg(Regs: RegList7)) {
268 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
269 return false;
270 }
271 }
272 }
273
274 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
275 if (LocVT == MVT::v64i32 ||
276 LocVT == MVT::v128i16 ||
277 LocVT == MVT::v256i8 ||
278 LocVT == MVT::v64f32 ||
279 LocVT == MVT::v128f16 ||
280 LocVT == MVT::v128bf16) {
281 static const MCPhysReg RegList8[] = {
282 Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7
283 };
284 if (MCRegister Reg = State.AllocateReg(Regs: RegList8)) {
285 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
286 return false;
287 }
288 }
289 }
290
291 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
292 if (LocVT == MVT::v32i32 ||
293 LocVT == MVT::v64i16 ||
294 LocVT == MVT::v128i8 ||
295 LocVT == MVT::v32f32 ||
296 LocVT == MVT::v64f16 ||
297 LocVT == MVT::v64bf16) {
298 int64_t Offset9 = State.AllocateStack(Size: 128, Alignment: Align(128));
299 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset9, LocVT, HTP: LocInfo));
300 return false;
301 }
302 }
303
304 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
305 if (LocVT == MVT::v64i32 ||
306 LocVT == MVT::v128i16 ||
307 LocVT == MVT::v256i8 ||
308 LocVT == MVT::v64f32 ||
309 LocVT == MVT::v128f16 ||
310 LocVT == MVT::v64bf16) {
311 int64_t Offset10 = State.AllocateStack(Size: 256, Alignment: Align(128));
312 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset10, LocVT, HTP: LocInfo));
313 return false;
314 }
315 }
316
317 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHLX2048BOps()) {
318 if (LocVT == MVT::v512i32 ||
319 LocVT == MVT::v1024i16 ||
320 LocVT == MVT::v2048i8) {
321 static const MCPhysReg RegList11[] = {
322 Hexagon::L0, Hexagon::L1, Hexagon::L2, Hexagon::L3, Hexagon::L4, Hexagon::L5, Hexagon::L6, Hexagon::L7, Hexagon::L8, Hexagon::L9, Hexagon::L10, Hexagon::L11
323 };
324 if (MCRegister Reg = State.AllocateReg(Regs: RegList11)) {
325 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
326 return false;
327 }
328 }
329 }
330
331 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHLX2048BOps()) {
332 if (LocVT == MVT::v1024i32 ||
333 LocVT == MVT::v2048i16 ||
334 LocVT == MVT::v4096i8) {
335 static const MCPhysReg RegList12[] = {
336 Hexagon::LL0, Hexagon::LL1, Hexagon::LL2, Hexagon::LL3, Hexagon::LL4, Hexagon::LL5
337 };
338 if (MCRegister Reg = State.AllocateReg(Regs: RegList12)) {
339 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
340 return false;
341 }
342 }
343 }
344
345 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHLX2048BOps()) {
346 if (LocVT == MVT::v512i32 ||
347 LocVT == MVT::v1024i16 ||
348 LocVT == MVT::v2048i8 ||
349 LocVT == MVT::v1024i32 ||
350 LocVT == MVT::v2048i16 ||
351 LocVT == MVT::v4096i8) {
352 if (CC_Hexagon_VTCM_Stack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
353 return false;
354 }
355 }
356
357 if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
358 return false;
359
360 return true; // CC didn't match.
361}
362
363
364static bool CC_HexagonStack(unsigned ValNo, MVT ValVT,
365 MVT LocVT, CCValAssign::LocInfo LocInfo,
366 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
367
368 if (LocVT == MVT::i32 ||
369 LocVT == MVT::v2i16 ||
370 LocVT == MVT::v4i8) {
371 int64_t Offset1 = State.AllocateStack(Size: 4, Alignment: Align(4));
372 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset1, LocVT, HTP: LocInfo));
373 return false;
374 }
375
376 if (LocVT == MVT::i64 ||
377 LocVT == MVT::v2i32 ||
378 LocVT == MVT::v4i16 ||
379 LocVT == MVT::v8i8) {
380 int64_t Offset2 = State.AllocateStack(Size: 8, Alignment: Align(8));
381 State.addLoc(V: CCValAssign::getMem(ValNo, ValVT, Offset: Offset2, LocVT, HTP: LocInfo));
382 return false;
383 }
384
385 return true; // CC didn't match.
386}
387
388
389static bool CC_Hexagon_Legacy(unsigned ValNo, MVT ValVT,
390 MVT LocVT, CCValAssign::LocInfo LocInfo,
391 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
392
393 if (LocVT == MVT::i1 ||
394 LocVT == MVT::i8 ||
395 LocVT == MVT::i16) {
396 LocVT = MVT::i32;
397 if (ArgFlags.isSExt())
398 LocInfo = CCValAssign::SExt;
399 else if (ArgFlags.isZExt())
400 LocInfo = CCValAssign::ZExt;
401 else
402 LocInfo = CCValAssign::AExt;
403 }
404
405 if (LocVT == MVT::bf16) {
406 LocVT = MVT::i32;
407 LocInfo = CCValAssign::BCvt;
408 }
409
410 if (LocVT == MVT::f32) {
411 LocVT = MVT::i32;
412 LocInfo = CCValAssign::BCvt;
413 }
414
415 if (LocVT == MVT::f64) {
416 LocVT = MVT::i64;
417 LocInfo = CCValAssign::BCvt;
418 }
419
420 if (ArgFlags.isByVal()) {
421 State.HandleByVal(ValNo, ValVT, LocVT, LocInfo, MinSize: 8, MinAlign: Align(8), ArgFlags);
422 return false;
423 }
424
425 if (State.isVarArg() && ArgFlags.isVarArg()) {
426 if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
427 return false;
428 }
429
430 if (LocVT == MVT::i32) {
431 if (ArgFlags.isSplit()) {
432 if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
433 return false;
434 }
435 }
436
437 if (LocVT == MVT::i32 ||
438 LocVT == MVT::v2i16 ||
439 LocVT == MVT::v4i8) {
440 static const MCPhysReg RegList1[] = {
441 Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5
442 };
443 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
444 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
445 return false;
446 }
447 }
448
449 if (LocVT == MVT::i64 ||
450 LocVT == MVT::v2i32 ||
451 LocVT == MVT::v4i16 ||
452 LocVT == MVT::v8i8) {
453 if (CC_SkipOdd(ValNo, ValVT, LocVT, LocInfo, ArgFlags, State))
454 return false;
455 }
456
457 if (LocVT == MVT::i64 ||
458 LocVT == MVT::v2i32 ||
459 LocVT == MVT::v4i16 ||
460 LocVT == MVT::v8i8) {
461 static const MCPhysReg RegList2[] = {
462 Hexagon::D0, Hexagon::D1, Hexagon::D2
463 };
464 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
465 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
466 return false;
467 }
468 }
469
470 if (!CC_HexagonStack(ValNo, ValVT, LocVT, LocInfo, ArgFlags, OrigTy, State))
471 return false;
472
473 return true; // CC didn't match.
474}
475
476
477static bool RetCC_Hexagon(unsigned ValNo, MVT ValVT,
478 MVT LocVT, CCValAssign::LocInfo LocInfo,
479 ISD::ArgFlagsTy ArgFlags, Type *OrigTy, CCState &State) {
480
481 if (LocVT == MVT::i1 ||
482 LocVT == MVT::i8 ||
483 LocVT == MVT::i16) {
484 LocVT = MVT::i32;
485 if (ArgFlags.isSExt())
486 LocInfo = CCValAssign::SExt;
487 else if (ArgFlags.isZExt())
488 LocInfo = CCValAssign::ZExt;
489 else
490 LocInfo = CCValAssign::AExt;
491 }
492
493 if (LocVT == MVT::bf16) {
494 LocVT = MVT::i32;
495 LocInfo = CCValAssign::BCvt;
496 }
497
498 if (LocVT == MVT::f32) {
499 LocVT = MVT::i32;
500 LocInfo = CCValAssign::BCvt;
501 }
502
503 if (LocVT == MVT::f64) {
504 LocVT = MVT::i64;
505 LocInfo = CCValAssign::BCvt;
506 }
507
508 if (ArgFlags.isSplit()) {
509 static const MCPhysReg RegList1[] = {
510 Hexagon::R0, Hexagon::R1
511 };
512 if (MCRegister Reg = State.AllocateReg(Regs: RegList1)) {
513 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
514 return false;
515 }
516 }
517
518 if (LocVT == MVT::i32 ||
519 LocVT == MVT::v2i16 ||
520 LocVT == MVT::v4i8) {
521 static const MCPhysReg RegList2[] = {
522 Hexagon::R0, Hexagon::R1
523 };
524 if (MCRegister Reg = State.AllocateReg(Regs: RegList2)) {
525 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
526 return false;
527 }
528 }
529
530 if (LocVT == MVT::i64 ||
531 LocVT == MVT::v2i32 ||
532 LocVT == MVT::v4i16 ||
533 LocVT == MVT::v8i8) {
534 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::D0)) {
535 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
536 return false;
537 }
538 }
539
540 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
541 if (LocVT == MVT::v16i32 ||
542 LocVT == MVT::v32i16 ||
543 LocVT == MVT::v64i8) {
544 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::V0)) {
545 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
546 return false;
547 }
548 }
549 }
550
551 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX64BOps()) {
552 if (LocVT == MVT::v32i32 ||
553 LocVT == MVT::v64i16 ||
554 LocVT == MVT::v128i8) {
555 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::W0)) {
556 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
557 return false;
558 }
559 }
560 }
561
562 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
563 if (LocVT == MVT::v32i32 ||
564 LocVT == MVT::v64i16 ||
565 LocVT == MVT::v128i8 ||
566 LocVT == MVT::v32f32 ||
567 LocVT == MVT::v64f16 ||
568 LocVT == MVT::v64bf16) {
569 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::V0)) {
570 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
571 return false;
572 }
573 }
574 }
575
576 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHVX128BOps()) {
577 if (LocVT == MVT::v64i32 ||
578 LocVT == MVT::v128i16 ||
579 LocVT == MVT::v256i8 ||
580 LocVT == MVT::v64f32 ||
581 LocVT == MVT::v128f16 ||
582 LocVT == MVT::v128bf16) {
583 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::W0)) {
584 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
585 return false;
586 }
587 }
588 }
589
590 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHLX2048BOps()) {
591 if (LocVT == MVT::v512i32 ||
592 LocVT == MVT::v1024i16 ||
593 LocVT == MVT::v2048i8) {
594 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::L0)) {
595 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
596 return false;
597 }
598 }
599 }
600
601 if (State.getMachineFunction().getSubtarget<HexagonSubtarget>().useHLX2048BOps()) {
602 if (LocVT == MVT::v1024i32 ||
603 LocVT == MVT::v2048i16 ||
604 LocVT == MVT::v4096i8) {
605 if (MCRegister Reg = State.AllocateReg(Reg: Hexagon::LL0)) {
606 State.addLoc(V: CCValAssign::getReg(ValNo, ValVT, Reg, LocVT, HTP: LocInfo));
607 return false;
608 }
609 }
610 }
611
612 return true; // CC didn't match.
613}
614
615#endif // GET_CALLING_CONV_IMPL
616
617#ifdef GET_CC_REGISTER_LISTS
618#undef GET_CC_REGISTER_LISTS
619
620const MCRegister CC_Hexagon_ArgRegs[] = { Hexagon::D0, Hexagon::D1, Hexagon::D2, Hexagon::L0, Hexagon::L1, Hexagon::L10, Hexagon::L11, Hexagon::L2, Hexagon::L3, Hexagon::L4, Hexagon::L5, Hexagon::L6, Hexagon::L7, Hexagon::L8, Hexagon::L9, Hexagon::LL0, Hexagon::LL1, Hexagon::LL2, Hexagon::LL3, Hexagon::LL4, Hexagon::LL5, Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5, Hexagon::V0, Hexagon::V1, Hexagon::V10, Hexagon::V11, Hexagon::V12, Hexagon::V13, Hexagon::V14, Hexagon::V15, Hexagon::V2, Hexagon::V3, Hexagon::V4, Hexagon::V5, Hexagon::V6, Hexagon::V7, Hexagon::V8, Hexagon::V9, Hexagon::W0, Hexagon::W1, Hexagon::W2, Hexagon::W3, Hexagon::W4, Hexagon::W5, Hexagon::W6, Hexagon::W7 };
621const MCRegister CC_HexagonStack_ArgRegs[] = { 0 };
622const MCRegister CC_Hexagon_Legacy_ArgRegs[] = { Hexagon::D0, Hexagon::D1, Hexagon::D2, Hexagon::R0, Hexagon::R1, Hexagon::R2, Hexagon::R3, Hexagon::R4, Hexagon::R5 };
623const MCRegister RetCC_Hexagon_ArgRegs[] = { Hexagon::D0, Hexagon::L0, Hexagon::LL0, Hexagon::R0, Hexagon::R1, Hexagon::V0, Hexagon::W0 };
624
625#endif // GET_CC_REGISTER_LISTS
626
627