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