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