Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Target Register Enum Values *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 :
10 : #ifdef GET_REGINFO_ENUM
11 : #undef GET_REGINFO_ENUM
12 :
13 : namespace llvm {
14 :
15 : class MCRegisterClass;
16 : extern const MCRegisterClass LanaiMCRegisterClasses[];
17 :
18 : namespace Lanai {
19 : enum {
20 : NoRegister,
21 : FP = 1,
22 : PC = 2,
23 : RCA = 3,
24 : RV = 4,
25 : SP = 5,
26 : SR = 6,
27 : R0 = 7,
28 : R1 = 8,
29 : R2 = 9,
30 : R3 = 10,
31 : R4 = 11,
32 : R5 = 12,
33 : R6 = 13,
34 : R7 = 14,
35 : R8 = 15,
36 : R9 = 16,
37 : R10 = 17,
38 : R11 = 18,
39 : R12 = 19,
40 : R13 = 20,
41 : R14 = 21,
42 : R15 = 22,
43 : R16 = 23,
44 : R17 = 24,
45 : R18 = 25,
46 : R19 = 26,
47 : R20 = 27,
48 : R21 = 28,
49 : R22 = 29,
50 : R23 = 30,
51 : R24 = 31,
52 : R25 = 32,
53 : R26 = 33,
54 : R27 = 34,
55 : R28 = 35,
56 : R29 = 36,
57 : R30 = 37,
58 : R31 = 38,
59 : RR1 = 39,
60 : RR2 = 40,
61 : NUM_TARGET_REGS // 41
62 : };
63 : } // end namespace Lanai
64 :
65 : // Register classes
66 :
67 : namespace Lanai {
68 : enum {
69 : GPRRegClassID = 0,
70 : GPR_with_sub_32RegClassID = 1,
71 : CCRRegClassID = 2,
72 :
73 : };
74 : } // end namespace Lanai
75 :
76 :
77 : // Subregister indices
78 :
79 : namespace Lanai {
80 : enum {
81 : NoSubRegister,
82 : sub_32, // 1
83 : NUM_TARGET_SUBREGS
84 : };
85 : } // end namespace Lanai
86 :
87 : } // end namespace llvm
88 :
89 : #endif // GET_REGINFO_ENUM
90 :
91 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
92 : |* *|
93 : |* MC Register Information *|
94 : |* *|
95 : |* Automatically generated file, do not edit! *|
96 : |* *|
97 : \*===----------------------------------------------------------------------===*/
98 :
99 :
100 : #ifdef GET_REGINFO_MC_DESC
101 : #undef GET_REGINFO_MC_DESC
102 :
103 : namespace llvm {
104 :
105 : extern const MCPhysReg LanaiRegDiffLists[] = {
106 : /* 0 */ 4, 0,
107 : /* 2 */ 6, 0,
108 : /* 4 */ 7, 0,
109 : /* 6 */ 11, 0,
110 : /* 8 */ 19, 0,
111 : /* 10 */ 22, 0,
112 : /* 12 */ 65208, 0,
113 : /* 14 */ 65419, 0,
114 : /* 16 */ 65428, 0,
115 : /* 18 */ 65474, 0,
116 : /* 20 */ 65509, 0,
117 : /* 22 */ 65514, 0,
118 : /* 24 */ 65517, 0,
119 : /* 26 */ 65525, 0,
120 : /* 28 */ 65529, 0,
121 : /* 30 */ 65530, 0,
122 : /* 32 */ 65531, 0,
123 : /* 34 */ 65532, 0,
124 : /* 36 */ 65535, 0,
125 : };
126 :
127 : extern const LaneBitmask LanaiLaneMaskLists[] = {
128 : /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
129 : /* 2 */ LaneBitmask(0x00000001), LaneBitmask::getAll(),
130 : };
131 :
132 : extern const uint16_t LanaiSubRegIdxLists[] = {
133 : /* 0 */ 1, 0,
134 : };
135 :
136 : extern const MCRegisterInfo::SubRegCoveredBits LanaiSubRegIdxRanges[] = {
137 : { 65535, 65535 },
138 : { 0, 32 }, // sub_32
139 : };
140 :
141 : extern const char LanaiRegStrings[] = {
142 : /* 0 */ 'R', '1', '0', 0,
143 : /* 4 */ 'R', '2', '0', 0,
144 : /* 8 */ 'R', '3', '0', 0,
145 : /* 12 */ 'R', '0', 0,
146 : /* 15 */ 'R', '1', '1', 0,
147 : /* 19 */ 'R', '2', '1', 0,
148 : /* 23 */ 'R', '3', '1', 0,
149 : /* 27 */ 'R', 'R', '1', 0,
150 : /* 31 */ 'R', '1', '2', 0,
151 : /* 35 */ 'R', '2', '2', 0,
152 : /* 39 */ 'R', 'R', '2', 0,
153 : /* 43 */ 'R', '1', '3', 0,
154 : /* 47 */ 'R', '2', '3', 0,
155 : /* 51 */ 'R', '3', 0,
156 : /* 54 */ 'R', '1', '4', 0,
157 : /* 58 */ 'R', '2', '4', 0,
158 : /* 62 */ 'R', '4', 0,
159 : /* 65 */ 'R', '1', '5', 0,
160 : /* 69 */ 'R', '2', '5', 0,
161 : /* 73 */ 'R', '5', 0,
162 : /* 76 */ 'R', '1', '6', 0,
163 : /* 80 */ 'R', '2', '6', 0,
164 : /* 84 */ 'R', '6', 0,
165 : /* 87 */ 'R', '1', '7', 0,
166 : /* 91 */ 'R', '2', '7', 0,
167 : /* 95 */ 'R', '7', 0,
168 : /* 98 */ 'R', '1', '8', 0,
169 : /* 102 */ 'R', '2', '8', 0,
170 : /* 106 */ 'R', '8', 0,
171 : /* 109 */ 'R', '1', '9', 0,
172 : /* 113 */ 'R', '2', '9', 0,
173 : /* 117 */ 'R', '9', 0,
174 : /* 120 */ 'R', 'C', 'A', 0,
175 : /* 124 */ 'P', 'C', 0,
176 : /* 127 */ 'F', 'P', 0,
177 : /* 130 */ 'S', 'P', 0,
178 : /* 133 */ 'S', 'R', 0,
179 : /* 136 */ 'R', 'V', 0,
180 : };
181 :
182 : extern const MCRegisterDesc LanaiRegDesc[] = { // Descriptors
183 : { 3, 0, 0, 0, 0, 0 },
184 : { 127, 6, 1, 0, 577, 2 },
185 : { 124, 4, 1, 0, 577, 2 },
186 : { 120, 8, 1, 0, 577, 2 },
187 : { 136, 6, 1, 0, 577, 2 },
188 : { 130, 2, 1, 0, 577, 2 },
189 : { 133, 1, 1, 1, 577, 0 },
190 : { 12, 1, 1, 1, 577, 0 },
191 : { 28, 1, 1, 1, 577, 0 },
192 : { 40, 1, 28, 1, 295, 0 },
193 : { 51, 1, 1, 1, 295, 0 },
194 : { 62, 1, 30, 1, 0, 0 },
195 : { 73, 1, 26, 1, 265, 0 },
196 : { 84, 1, 1, 1, 545, 0 },
197 : { 95, 1, 1, 1, 545, 0 },
198 : { 106, 1, 26, 1, 232, 0 },
199 : { 117, 1, 1, 1, 513, 0 },
200 : { 0, 1, 10, 1, 513, 0 },
201 : { 15, 1, 10, 1, 513, 0 },
202 : { 31, 1, 1, 1, 513, 0 },
203 : { 43, 1, 1, 1, 513, 0 },
204 : { 54, 1, 1, 1, 513, 0 },
205 : { 65, 1, 24, 1, 207, 0 },
206 : { 76, 1, 1, 1, 481, 0 },
207 : { 87, 1, 1, 1, 481, 0 },
208 : { 98, 1, 1, 1, 481, 0 },
209 : { 109, 1, 1, 1, 481, 0 },
210 : { 4, 1, 1, 1, 481, 0 },
211 : { 19, 1, 1, 1, 481, 0 },
212 : { 35, 1, 1, 1, 481, 0 },
213 : { 47, 1, 1, 1, 481, 0 },
214 : { 58, 1, 1, 1, 481, 0 },
215 : { 69, 1, 1, 1, 481, 0 },
216 : { 80, 1, 1, 1, 481, 0 },
217 : { 91, 1, 1, 1, 481, 0 },
218 : { 102, 1, 1, 1, 481, 0 },
219 : { 113, 1, 1, 1, 481, 0 },
220 : { 8, 1, 1, 1, 481, 0 },
221 : { 23, 1, 1, 1, 481, 0 },
222 : { 27, 22, 1, 0, 321, 2 },
223 : { 39, 22, 1, 0, 321, 2 },
224 : };
225 :
226 : extern const MCPhysReg LanaiRegUnitRoots[][2] = {
227 : { Lanai::R5 },
228 : { Lanai::R2 },
229 : { Lanai::R15 },
230 : { Lanai::R8 },
231 : { Lanai::R4 },
232 : { Lanai::SR },
233 : { Lanai::R0 },
234 : { Lanai::R1 },
235 : { Lanai::R3 },
236 : { Lanai::R6 },
237 : { Lanai::R7 },
238 : { Lanai::R9 },
239 : { Lanai::R10 },
240 : { Lanai::R11 },
241 : { Lanai::R12 },
242 : { Lanai::R13 },
243 : { Lanai::R14 },
244 : { Lanai::R16 },
245 : { Lanai::R17 },
246 : { Lanai::R18 },
247 : { Lanai::R19 },
248 : { Lanai::R20 },
249 : { Lanai::R21 },
250 : { Lanai::R22 },
251 : { Lanai::R23 },
252 : { Lanai::R24 },
253 : { Lanai::R25 },
254 : { Lanai::R26 },
255 : { Lanai::R27 },
256 : { Lanai::R28 },
257 : { Lanai::R29 },
258 : { Lanai::R30 },
259 : { Lanai::R31 },
260 : };
261 :
262 : namespace { // Register classes...
263 : // GPR Register Class...
264 : const MCPhysReg GPR[] = {
265 : Lanai::R3, Lanai::R9, Lanai::R12, Lanai::R13, Lanai::R14, Lanai::R16, Lanai::R17, Lanai::R20, Lanai::R21, Lanai::R22, Lanai::R23, Lanai::R24, Lanai::R25, Lanai::R26, Lanai::R27, Lanai::R28, Lanai::R29, Lanai::R30, Lanai::R31, Lanai::R6, Lanai::R7, Lanai::R18, Lanai::R19, Lanai::R15, Lanai::RCA, Lanai::R10, Lanai::RR1, Lanai::R11, Lanai::RR2, Lanai::R8, Lanai::RV, Lanai::R5, Lanai::FP, Lanai::R4, Lanai::SP, Lanai::R2, Lanai::PC, Lanai::R1, Lanai::R0,
266 : };
267 :
268 : // GPR Bit set.
269 : const uint8_t GPRBits[] = {
270 : 0xbe, 0xff, 0xff, 0xff, 0xff, 0x01,
271 : };
272 :
273 : // GPR_with_sub_32 Register Class...
274 : const MCPhysReg GPR_with_sub_32[] = {
275 : Lanai::RCA, Lanai::RR1, Lanai::RR2, Lanai::RV, Lanai::FP, Lanai::SP, Lanai::PC,
276 : };
277 :
278 : // GPR_with_sub_32 Bit set.
279 : const uint8_t GPR_with_sub_32Bits[] = {
280 : 0x3e, 0x00, 0x00, 0x00, 0x80, 0x01,
281 : };
282 :
283 : // CCR Register Class...
284 : const MCPhysReg CCR[] = {
285 : Lanai::SR,
286 : };
287 :
288 : // CCR Bit set.
289 : const uint8_t CCRBits[] = {
290 : 0x40,
291 : };
292 :
293 : } // end anonymous namespace
294 :
295 : extern const char LanaiRegClassStrings[] = {
296 : /* 0 */ 'G', 'P', 'R', '_', 'w', 'i', 't', 'h', '_', 's', 'u', 'b', '_', '3', '2', 0,
297 : /* 16 */ 'C', 'C', 'R', 0,
298 : /* 20 */ 'G', 'P', 'R', 0,
299 : };
300 :
301 : extern const MCRegisterClass LanaiMCRegisterClasses[] = {
302 : { GPR, GPRBits, 20, 39, sizeof(GPRBits), Lanai::GPRRegClassID, 1, true },
303 : { GPR_with_sub_32, GPR_with_sub_32Bits, 0, 7, sizeof(GPR_with_sub_32Bits), Lanai::GPR_with_sub_32RegClassID, 1, true },
304 : { CCR, CCRBits, 16, 1, sizeof(CCRBits), Lanai::CCRRegClassID, -1, false },
305 : };
306 :
307 : // Lanai Dwarf<->LLVM register mappings.
308 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0Dwarf2L[] = {
309 : { 0U, Lanai::R0 },
310 : { 1U, Lanai::R1 },
311 : { 2U, Lanai::R2 },
312 : { 3U, Lanai::R3 },
313 : { 4U, Lanai::R4 },
314 : { 5U, Lanai::R5 },
315 : { 6U, Lanai::R6 },
316 : { 7U, Lanai::R7 },
317 : { 8U, Lanai::R8 },
318 : { 9U, Lanai::R9 },
319 : { 10U, Lanai::R10 },
320 : { 11U, Lanai::R11 },
321 : { 12U, Lanai::R12 },
322 : { 13U, Lanai::R13 },
323 : { 14U, Lanai::R14 },
324 : { 15U, Lanai::R15 },
325 : { 16U, Lanai::R16 },
326 : { 17U, Lanai::R17 },
327 : { 18U, Lanai::R18 },
328 : { 19U, Lanai::R19 },
329 : { 20U, Lanai::R20 },
330 : { 21U, Lanai::R21 },
331 : { 22U, Lanai::R22 },
332 : { 23U, Lanai::R23 },
333 : { 24U, Lanai::R24 },
334 : { 25U, Lanai::R25 },
335 : { 26U, Lanai::R26 },
336 : { 27U, Lanai::R27 },
337 : { 28U, Lanai::R28 },
338 : { 29U, Lanai::R29 },
339 : { 30U, Lanai::R30 },
340 : { 31U, Lanai::R31 },
341 : };
342 : extern const unsigned LanaiDwarfFlavour0Dwarf2LSize = array_lengthof(LanaiDwarfFlavour0Dwarf2L);
343 :
344 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0Dwarf2L[] = {
345 : { 0U, Lanai::R0 },
346 : { 1U, Lanai::R1 },
347 : { 2U, Lanai::R2 },
348 : { 3U, Lanai::R3 },
349 : { 4U, Lanai::R4 },
350 : { 5U, Lanai::R5 },
351 : { 6U, Lanai::R6 },
352 : { 7U, Lanai::R7 },
353 : { 8U, Lanai::R8 },
354 : { 9U, Lanai::R9 },
355 : { 10U, Lanai::R10 },
356 : { 11U, Lanai::R11 },
357 : { 12U, Lanai::R12 },
358 : { 13U, Lanai::R13 },
359 : { 14U, Lanai::R14 },
360 : { 15U, Lanai::R15 },
361 : { 16U, Lanai::R16 },
362 : { 17U, Lanai::R17 },
363 : { 18U, Lanai::R18 },
364 : { 19U, Lanai::R19 },
365 : { 20U, Lanai::R20 },
366 : { 21U, Lanai::R21 },
367 : { 22U, Lanai::R22 },
368 : { 23U, Lanai::R23 },
369 : { 24U, Lanai::R24 },
370 : { 25U, Lanai::R25 },
371 : { 26U, Lanai::R26 },
372 : { 27U, Lanai::R27 },
373 : { 28U, Lanai::R28 },
374 : { 29U, Lanai::R29 },
375 : { 30U, Lanai::R30 },
376 : { 31U, Lanai::R31 },
377 : };
378 : extern const unsigned LanaiEHFlavour0Dwarf2LSize = array_lengthof(LanaiEHFlavour0Dwarf2L);
379 :
380 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0L2Dwarf[] = {
381 : { Lanai::FP, 5U },
382 : { Lanai::PC, 2U },
383 : { Lanai::RCA, 15U },
384 : { Lanai::RV, 8U },
385 : { Lanai::SP, 4U },
386 : { Lanai::R0, 0U },
387 : { Lanai::R1, 1U },
388 : { Lanai::R2, 2U },
389 : { Lanai::R3, 3U },
390 : { Lanai::R4, 4U },
391 : { Lanai::R5, 5U },
392 : { Lanai::R6, 6U },
393 : { Lanai::R7, 7U },
394 : { Lanai::R8, 8U },
395 : { Lanai::R9, 9U },
396 : { Lanai::R10, 10U },
397 : { Lanai::R11, 11U },
398 : { Lanai::R12, 12U },
399 : { Lanai::R13, 13U },
400 : { Lanai::R14, 14U },
401 : { Lanai::R15, 15U },
402 : { Lanai::R16, 16U },
403 : { Lanai::R17, 17U },
404 : { Lanai::R18, 18U },
405 : { Lanai::R19, 19U },
406 : { Lanai::R20, 20U },
407 : { Lanai::R21, 21U },
408 : { Lanai::R22, 22U },
409 : { Lanai::R23, 23U },
410 : { Lanai::R24, 24U },
411 : { Lanai::R25, 25U },
412 : { Lanai::R26, 26U },
413 : { Lanai::R27, 27U },
414 : { Lanai::R28, 28U },
415 : { Lanai::R29, 29U },
416 : { Lanai::R30, 30U },
417 : { Lanai::R31, 31U },
418 : { Lanai::RR1, 10U },
419 : { Lanai::RR2, 11U },
420 : };
421 : extern const unsigned LanaiDwarfFlavour0L2DwarfSize = array_lengthof(LanaiDwarfFlavour0L2Dwarf);
422 :
423 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0L2Dwarf[] = {
424 : { Lanai::FP, 5U },
425 : { Lanai::PC, 2U },
426 : { Lanai::RCA, 15U },
427 : { Lanai::RV, 8U },
428 : { Lanai::SP, 4U },
429 : { Lanai::R0, 0U },
430 : { Lanai::R1, 1U },
431 : { Lanai::R2, 2U },
432 : { Lanai::R3, 3U },
433 : { Lanai::R4, 4U },
434 : { Lanai::R5, 5U },
435 : { Lanai::R6, 6U },
436 : { Lanai::R7, 7U },
437 : { Lanai::R8, 8U },
438 : { Lanai::R9, 9U },
439 : { Lanai::R10, 10U },
440 : { Lanai::R11, 11U },
441 : { Lanai::R12, 12U },
442 : { Lanai::R13, 13U },
443 : { Lanai::R14, 14U },
444 : { Lanai::R15, 15U },
445 : { Lanai::R16, 16U },
446 : { Lanai::R17, 17U },
447 : { Lanai::R18, 18U },
448 : { Lanai::R19, 19U },
449 : { Lanai::R20, 20U },
450 : { Lanai::R21, 21U },
451 : { Lanai::R22, 22U },
452 : { Lanai::R23, 23U },
453 : { Lanai::R24, 24U },
454 : { Lanai::R25, 25U },
455 : { Lanai::R26, 26U },
456 : { Lanai::R27, 27U },
457 : { Lanai::R28, 28U },
458 : { Lanai::R29, 29U },
459 : { Lanai::R30, 30U },
460 : { Lanai::R31, 31U },
461 : { Lanai::RR1, 10U },
462 : { Lanai::RR2, 11U },
463 : };
464 : extern const unsigned LanaiEHFlavour0L2DwarfSize = array_lengthof(LanaiEHFlavour0L2Dwarf);
465 :
466 : extern const uint16_t LanaiRegEncodingTable[] = {
467 : 0,
468 : 0,
469 : 0,
470 : 0,
471 : 0,
472 : 0,
473 : 0,
474 : 0,
475 : 0,
476 : 0,
477 : 0,
478 : 0,
479 : 0,
480 : 0,
481 : 0,
482 : 0,
483 : 0,
484 : 0,
485 : 0,
486 : 0,
487 : 0,
488 : 0,
489 : 0,
490 : 0,
491 : 0,
492 : 0,
493 : 0,
494 : 0,
495 : 0,
496 : 0,
497 : 0,
498 : 0,
499 : 0,
500 : 0,
501 : 0,
502 : 0,
503 : 0,
504 : 0,
505 : 0,
506 : 0,
507 : 0,
508 : };
509 : static inline void InitLanaiMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
510 : RI->InitMCRegisterInfo(LanaiRegDesc, 41, RA, PC, LanaiMCRegisterClasses, 3, LanaiRegUnitRoots, 33, LanaiRegDiffLists, LanaiLaneMaskLists, LanaiRegStrings, LanaiRegClassStrings, LanaiSubRegIdxLists, 2,
511 : LanaiSubRegIdxRanges, LanaiRegEncodingTable);
512 :
513 : switch (DwarfFlavour) {
514 : default:
515 : llvm_unreachable("Unknown DWARF flavour");
516 : case 0:
517 : RI->mapDwarfRegsToLLVMRegs(LanaiDwarfFlavour0Dwarf2L, LanaiDwarfFlavour0Dwarf2LSize, false);
518 : break;
519 : }
520 : switch (EHFlavour) {
521 : default:
522 : llvm_unreachable("Unknown DWARF flavour");
523 : case 0:
524 : RI->mapDwarfRegsToLLVMRegs(LanaiEHFlavour0Dwarf2L, LanaiEHFlavour0Dwarf2LSize, true);
525 : break;
526 : }
527 : switch (DwarfFlavour) {
528 : default:
529 : llvm_unreachable("Unknown DWARF flavour");
530 : case 0:
531 : RI->mapLLVMRegsToDwarfRegs(LanaiDwarfFlavour0L2Dwarf, LanaiDwarfFlavour0L2DwarfSize, false);
532 : break;
533 : }
534 : switch (EHFlavour) {
535 : default:
536 : llvm_unreachable("Unknown DWARF flavour");
537 : case 0:
538 : RI->mapLLVMRegsToDwarfRegs(LanaiEHFlavour0L2Dwarf, LanaiEHFlavour0L2DwarfSize, true);
539 : break;
540 : }
541 : }
542 :
543 : } // end namespace llvm
544 :
545 : #endif // GET_REGINFO_MC_DESC
546 :
547 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
548 : |* *|
549 : |* Register Information Header Fragment *|
550 : |* *|
551 : |* Automatically generated file, do not edit! *|
552 : |* *|
553 : \*===----------------------------------------------------------------------===*/
554 :
555 :
556 : #ifdef GET_REGINFO_HEADER
557 : #undef GET_REGINFO_HEADER
558 :
559 : #include "llvm/CodeGen/TargetRegisterInfo.h"
560 :
561 : namespace llvm {
562 :
563 : class LanaiFrameLowering;
564 :
565 : struct LanaiGenRegisterInfo : public TargetRegisterInfo {
566 : explicit LanaiGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0,
567 : unsigned PC = 0, unsigned HwMode = 0);
568 : unsigned composeSubRegIndicesImpl(unsigned, unsigned) const override;
569 : LaneBitmask composeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
570 : LaneBitmask reverseComposeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
571 : const TargetRegisterClass *getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const override;
572 : const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
573 : unsigned getRegUnitWeight(unsigned RegUnit) const override;
574 : unsigned getNumRegPressureSets() const override;
575 : const char *getRegPressureSetName(unsigned Idx) const override;
576 : unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
577 : const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
578 : const int *getRegUnitPressureSets(unsigned RegUnit) const override;
579 : ArrayRef<const char *> getRegMaskNames() const override;
580 : ArrayRef<const uint32_t *> getRegMasks() const override;
581 : /// Devirtualized TargetFrameLowering.
582 : static const LanaiFrameLowering *getFrameLowering(
583 : const MachineFunction &MF);
584 : };
585 :
586 : namespace Lanai { // Register classes
587 : extern const TargetRegisterClass GPRRegClass;
588 : extern const TargetRegisterClass GPR_with_sub_32RegClass;
589 : extern const TargetRegisterClass CCRRegClass;
590 : } // end namespace Lanai
591 :
592 : } // end namespace llvm
593 :
594 : #endif // GET_REGINFO_HEADER
595 :
596 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
597 : |* *|
598 : |* Target Register and Register Classes Information *|
599 : |* *|
600 : |* Automatically generated file, do not edit! *|
601 : |* *|
602 : \*===----------------------------------------------------------------------===*/
603 :
604 :
605 : #ifdef GET_REGINFO_TARGET_DESC
606 : #undef GET_REGINFO_TARGET_DESC
607 :
608 : namespace llvm {
609 :
610 : extern const MCRegisterClass LanaiMCRegisterClasses[];
611 :
612 : static const MVT::SimpleValueType VTLists[] = {
613 : /* 0 */ MVT::i32, MVT::Other,
614 : };
615 :
616 : static const char *const SubRegIndexNameTable[] = { "sub_32", "" };
617 :
618 :
619 : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
620 : LaneBitmask::getAll(),
621 : LaneBitmask(0x00000001), // sub_32
622 : };
623 :
624 :
625 :
626 : static const TargetRegisterInfo::RegClassInfo RegClassInfos[] = {
627 : // Mode = 0 (Default)
628 : { 32, 32, 32, VTLists+0 }, // GPR
629 : { 32, 32, 32, VTLists+0 }, // GPR_with_sub_32
630 : { 32, 32, 32, VTLists+0 }, // CCR
631 : };
632 :
633 : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
634 :
635 : static const uint32_t GPRSubClassMask[] = {
636 : 0x00000003,
637 : 0x00000002, // sub_32
638 : };
639 :
640 : static const uint32_t GPR_with_sub_32SubClassMask[] = {
641 : 0x00000002,
642 : };
643 :
644 : static const uint32_t CCRSubClassMask[] = {
645 : 0x00000004,
646 : };
647 :
648 : static const uint16_t SuperRegIdxSeqs[] = {
649 : /* 0 */ 1, 0,
650 : };
651 :
652 : static const TargetRegisterClass *const GPR_with_sub_32Superclasses[] = {
653 : &Lanai::GPRRegClass,
654 : nullptr
655 : };
656 :
657 :
658 : namespace Lanai { // Register class instances
659 : extern const TargetRegisterClass GPRRegClass = {
660 : &LanaiMCRegisterClasses[GPRRegClassID],
661 : GPRSubClassMask,
662 : SuperRegIdxSeqs + 0,
663 : LaneBitmask(0x00000001),
664 : 0,
665 : false, /* HasDisjunctSubRegs */
666 : false, /* CoveredBySubRegs */
667 : NullRegClasses,
668 : nullptr
669 : };
670 :
671 : extern const TargetRegisterClass GPR_with_sub_32RegClass = {
672 : &LanaiMCRegisterClasses[GPR_with_sub_32RegClassID],
673 : GPR_with_sub_32SubClassMask,
674 : SuperRegIdxSeqs + 1,
675 : LaneBitmask(0x00000001),
676 : 0,
677 : false, /* HasDisjunctSubRegs */
678 : false, /* CoveredBySubRegs */
679 : GPR_with_sub_32Superclasses,
680 : nullptr
681 : };
682 :
683 : extern const TargetRegisterClass CCRRegClass = {
684 : &LanaiMCRegisterClasses[CCRRegClassID],
685 : CCRSubClassMask,
686 : SuperRegIdxSeqs + 1,
687 : LaneBitmask(0x00000001),
688 : 0,
689 : false, /* HasDisjunctSubRegs */
690 : false, /* CoveredBySubRegs */
691 : NullRegClasses,
692 : nullptr
693 : };
694 :
695 : } // end namespace Lanai
696 :
697 : namespace {
698 : const TargetRegisterClass* const RegisterClasses[] = {
699 : &Lanai::GPRRegClass,
700 : &Lanai::GPR_with_sub_32RegClass,
701 : &Lanai::CCRRegClass,
702 : };
703 : } // end anonymous namespace
704 :
705 : static const TargetRegisterInfoDesc LanaiRegInfoDesc[] = { // Extra Descriptors
706 : { 0, false },
707 : { 0, true },
708 : { 0, true },
709 : { 0, true },
710 : { 0, true },
711 : { 0, true },
712 : { 0, false },
713 : { 0, true },
714 : { 0, true },
715 : { 0, true },
716 : { 0, true },
717 : { 0, true },
718 : { 0, true },
719 : { 0, true },
720 : { 0, true },
721 : { 0, true },
722 : { 0, true },
723 : { 0, true },
724 : { 0, true },
725 : { 0, true },
726 : { 0, true },
727 : { 0, true },
728 : { 0, true },
729 : { 0, true },
730 : { 0, true },
731 : { 0, true },
732 : { 0, true },
733 : { 0, true },
734 : { 0, true },
735 : { 0, true },
736 : { 0, true },
737 : { 0, true },
738 : { 0, true },
739 : { 0, true },
740 : { 0, true },
741 : { 0, true },
742 : { 0, true },
743 : { 0, true },
744 : { 0, true },
745 : { 0, true },
746 : { 0, true },
747 : };
748 0 : unsigned LanaiGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
749 : static const uint8_t Rows[1][1] = {
750 : { 0, },
751 : };
752 :
753 : --IdxA; assert(IdxA < 1);
754 : --IdxB; assert(IdxB < 1);
755 0 : return Rows[0][IdxB];
756 : }
757 :
758 : struct MaskRolOp {
759 : LaneBitmask Mask;
760 : uint8_t RotateLeft;
761 : };
762 : static const MaskRolOp LaneMaskComposeSequences[] = {
763 : { LaneBitmask(0xFFFFFFFF), 0 }, { LaneBitmask::getNone(), 0 } // Sequence 0
764 : };
765 : static const MaskRolOp *const CompositeSequences[] = {
766 : &LaneMaskComposeSequences[0] // to sub_32
767 : };
768 :
769 0 : LaneBitmask LanaiGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
770 : --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
771 : LaneBitmask Result;
772 0 : for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
773 0 : LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
774 0 : if (unsigned S = Ops->RotateLeft)
775 0 : Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
776 : else
777 : Result |= LaneBitmask(M);
778 : }
779 0 : return Result;
780 : }
781 :
782 0 : LaneBitmask LanaiGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
783 0 : LaneMask &= getSubRegIndexLaneMask(IdxA);
784 : --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
785 : LaneBitmask Result;
786 0 : for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
787 : LaneBitmask::Type M = LaneMask.getAsInteger();
788 0 : if (unsigned S = Ops->RotateLeft)
789 0 : Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
790 : else
791 : Result |= LaneBitmask(M);
792 : }
793 0 : return Result;
794 : }
795 :
796 0 : const TargetRegisterClass *LanaiGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
797 : static const uint8_t Table[3][1] = {
798 : { // GPR
799 : 2, // sub_32 -> GPR_with_sub_32
800 : },
801 : { // GPR_with_sub_32
802 : 2, // sub_32 -> GPR_with_sub_32
803 : },
804 : { // CCR
805 : 0, // sub_32
806 : },
807 : };
808 : assert(RC && "Missing regclass");
809 0 : if (!Idx) return RC;
810 0 : --Idx;
811 : assert(Idx < 1 && "Bad subreg");
812 0 : unsigned TV = Table[RC->getID()][Idx];
813 0 : return TV ? getRegClass(TV - 1) : nullptr;
814 : }
815 :
816 : /// Get the weight in units of pressure for this register class.
817 282 : const RegClassWeight &LanaiGenRegisterInfo::
818 : getRegClassWeight(const TargetRegisterClass *RC) const {
819 : static const RegClassWeight RCWeightTable[] = {
820 : {1, 32}, // GPR
821 : {1, 7}, // GPR_with_sub_32
822 : {0, 0}, // CCR
823 : };
824 564 : return RCWeightTable[RC->getID()];
825 : }
826 :
827 : /// Get the weight in units of pressure for this register unit.
828 44 : unsigned LanaiGenRegisterInfo::
829 : getRegUnitWeight(unsigned RegUnit) const {
830 : assert(RegUnit < 33 && "invalid register unit");
831 : // All register units have unit weight.
832 44 : return 1;
833 : }
834 :
835 :
836 : // Get the number of dimensions of register pressure.
837 197 : unsigned LanaiGenRegisterInfo::getNumRegPressureSets() const {
838 197 : return 2;
839 : }
840 :
841 : // Get the name of this register unit pressure set.
842 0 : const char *LanaiGenRegisterInfo::
843 : getRegPressureSetName(unsigned Idx) const {
844 : static const char *const PressureNameTable[] = {
845 : "GPR_with_sub_32",
846 : "GPR",
847 : };
848 0 : return PressureNameTable[Idx];
849 : }
850 :
851 : // Get the register unit pressure limit for this dimension.
852 : // This limit must be adjusted dynamically for reserved registers.
853 182 : unsigned LanaiGenRegisterInfo::
854 : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
855 : static const uint8_t PressureLimitTable[] = {
856 : 7, // 0: GPR_with_sub_32
857 : 32, // 1: GPR
858 : };
859 182 : return PressureLimitTable[Idx];
860 : }
861 :
862 : /// Table of pressure sets per register class or unit.
863 : static const int RCSetsTable[] = {
864 : /* 0 */ 0, 1, -1,
865 : };
866 :
867 : /// Get the dimensions of register pressure impacted by this register class.
868 : /// Returns a -1 terminated array of pressure set IDs
869 272 : const int* LanaiGenRegisterInfo::
870 : getRegClassPressureSets(const TargetRegisterClass *RC) const {
871 : static const uint8_t RCSetStartTable[] = {
872 : 1,0,2,};
873 544 : return &RCSetsTable[RCSetStartTable[RC->getID()]];
874 : }
875 :
876 : /// Get the dimensions of register pressure impacted by this register unit.
877 : /// Returns a -1 terminated array of pressure set IDs
878 44 : const int* LanaiGenRegisterInfo::
879 : getRegUnitPressureSets(unsigned RegUnit) const {
880 : assert(RegUnit < 33 && "invalid register unit");
881 : static const uint8_t RUSetStartTable[] = {
882 : 0,0,0,0,0,2,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,};
883 44 : return &RCSetsTable[RUSetStartTable[RegUnit]];
884 : }
885 :
886 : extern const MCRegisterDesc LanaiRegDesc[];
887 : extern const MCPhysReg LanaiRegDiffLists[];
888 : extern const LaneBitmask LanaiLaneMaskLists[];
889 : extern const char LanaiRegStrings[];
890 : extern const char LanaiRegClassStrings[];
891 : extern const MCPhysReg LanaiRegUnitRoots[][2];
892 : extern const uint16_t LanaiSubRegIdxLists[];
893 : extern const MCRegisterInfo::SubRegCoveredBits LanaiSubRegIdxRanges[];
894 : extern const uint16_t LanaiRegEncodingTable[];
895 : // Lanai Dwarf<->LLVM register mappings.
896 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0Dwarf2L[];
897 : extern const unsigned LanaiDwarfFlavour0Dwarf2LSize;
898 :
899 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0Dwarf2L[];
900 : extern const unsigned LanaiEHFlavour0Dwarf2LSize;
901 :
902 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0L2Dwarf[];
903 : extern const unsigned LanaiDwarfFlavour0L2DwarfSize;
904 :
905 : extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0L2Dwarf[];
906 : extern const unsigned LanaiEHFlavour0L2DwarfSize;
907 :
908 26 : LanaiGenRegisterInfo::
909 : LanaiGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
910 26 : unsigned PC, unsigned HwMode)
911 : : TargetRegisterInfo(LanaiRegInfoDesc, RegisterClasses, RegisterClasses+3,
912 : SubRegIndexNameTable, SubRegIndexLaneMaskTable,
913 52 : LaneBitmask(0xFFFFFFFE), RegClassInfos, HwMode) {
914 : InitMCRegisterInfo(LanaiRegDesc, 41, RA, PC,
915 : LanaiMCRegisterClasses, 3,
916 : LanaiRegUnitRoots,
917 : 33,
918 : LanaiRegDiffLists,
919 : LanaiLaneMaskLists,
920 : LanaiRegStrings,
921 : LanaiRegClassStrings,
922 : LanaiSubRegIdxLists,
923 : 2,
924 : LanaiSubRegIdxRanges,
925 : LanaiRegEncodingTable);
926 :
927 26 : switch (DwarfFlavour) {
928 0 : default:
929 0 : llvm_unreachable("Unknown DWARF flavour");
930 26 : case 0:
931 26 : mapDwarfRegsToLLVMRegs(LanaiDwarfFlavour0Dwarf2L, LanaiDwarfFlavour0Dwarf2LSize, false);
932 : break;
933 : }
934 26 : switch (EHFlavour) {
935 0 : default:
936 0 : llvm_unreachable("Unknown DWARF flavour");
937 26 : case 0:
938 26 : mapDwarfRegsToLLVMRegs(LanaiEHFlavour0Dwarf2L, LanaiEHFlavour0Dwarf2LSize, true);
939 : break;
940 : }
941 : switch (DwarfFlavour) {
942 : default:
943 : llvm_unreachable("Unknown DWARF flavour");
944 : case 0:
945 26 : mapLLVMRegsToDwarfRegs(LanaiDwarfFlavour0L2Dwarf, LanaiDwarfFlavour0L2DwarfSize, false);
946 : break;
947 : }
948 : switch (EHFlavour) {
949 : default:
950 : llvm_unreachable("Unknown DWARF flavour");
951 : case 0:
952 26 : mapLLVMRegsToDwarfRegs(LanaiEHFlavour0L2Dwarf, LanaiEHFlavour0L2DwarfSize, true);
953 : break;
954 : }
955 26 : }
956 :
957 : static const MCPhysReg CSR_SaveList[] = { 0 };
958 : static const uint32_t CSR_RegMask[] = { 0x00000000, 0x00000000, };
959 :
960 :
961 10 : ArrayRef<const uint32_t *> LanaiGenRegisterInfo::getRegMasks() const {
962 : static const uint32_t *const Masks[] = {
963 : CSR_RegMask,
964 : };
965 10 : return makeArrayRef(Masks);
966 : }
967 :
968 3 : ArrayRef<const char *> LanaiGenRegisterInfo::getRegMaskNames() const {
969 : static const char *const Names[] = {
970 : "CSR",
971 : };
972 3 : return makeArrayRef(Names);
973 : }
974 :
975 : const LanaiFrameLowering *
976 0 : LanaiGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
977 : return static_cast<const LanaiFrameLowering *>(
978 0 : MF.getSubtarget().getFrameLowering());
979 : }
980 :
981 : } // end namespace llvm
982 :
983 : #endif // GET_REGINFO_TARGET_DESC
984 :
|