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