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 AVRMCRegisterClasses[];
17 :
18 : namespace AVR {
19 : enum {
20 : NoRegister,
21 : SP = 1,
22 : SPH = 2,
23 : SPL = 3,
24 : SREG = 4,
25 : R0 = 5,
26 : R1 = 6,
27 : R2 = 7,
28 : R3 = 8,
29 : R4 = 9,
30 : R5 = 10,
31 : R6 = 11,
32 : R7 = 12,
33 : R8 = 13,
34 : R9 = 14,
35 : R10 = 15,
36 : R11 = 16,
37 : R12 = 17,
38 : R13 = 18,
39 : R14 = 19,
40 : R15 = 20,
41 : R16 = 21,
42 : R17 = 22,
43 : R18 = 23,
44 : R19 = 24,
45 : R20 = 25,
46 : R21 = 26,
47 : R22 = 27,
48 : R23 = 28,
49 : R24 = 29,
50 : R25 = 30,
51 : R26 = 31,
52 : R27 = 32,
53 : R28 = 33,
54 : R29 = 34,
55 : R30 = 35,
56 : R31 = 36,
57 : R1R0 = 37,
58 : R3R2 = 38,
59 : R5R4 = 39,
60 : R7R6 = 40,
61 : R9R8 = 41,
62 : R11R10 = 42,
63 : R13R12 = 43,
64 : R15R14 = 44,
65 : R17R16 = 45,
66 : R19R18 = 46,
67 : R21R20 = 47,
68 : R23R22 = 48,
69 : R25R24 = 49,
70 : R27R26 = 50,
71 : R29R28 = 51,
72 : R31R30 = 52,
73 : NUM_TARGET_REGS // 53
74 : };
75 : } // end namespace AVR
76 :
77 : // Register classes
78 :
79 : namespace AVR {
80 : enum {
81 : GPR8RegClassID = 0,
82 : GPR8loRegClassID = 1,
83 : LD8RegClassID = 2,
84 : LD8loRegClassID = 3,
85 : CCRRegClassID = 4,
86 : DREGSRegClassID = 5,
87 : DLDREGSRegClassID = 6,
88 : DREGS_with_sub_hi_in_GPR8loRegClassID = 7,
89 : DLDREGS_with_sub_hi_in_LD8loRegClassID = 8,
90 : IWREGSRegClassID = 9,
91 : PTRREGSRegClassID = 10,
92 : PTRDISPREGSRegClassID = 11,
93 : GPRSPRegClassID = 12,
94 : ZREGRegClassID = 13,
95 :
96 : };
97 : } // end namespace AVR
98 :
99 :
100 : // Register alternate name indices
101 :
102 : namespace AVR {
103 : enum {
104 : NoRegAltName, // 0
105 : ptr, // 1
106 : NUM_TARGET_REG_ALT_NAMES = 2
107 : };
108 : } // end namespace AVR
109 :
110 :
111 : // Subregister indices
112 :
113 : namespace AVR {
114 : enum {
115 : NoSubRegister,
116 : sub_hi, // 1
117 : sub_lo, // 2
118 : NUM_TARGET_SUBREGS
119 : };
120 : } // end namespace AVR
121 :
122 : } // end namespace llvm
123 :
124 : #endif // GET_REGINFO_ENUM
125 :
126 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
127 : |* *|
128 : |* MC Register Information *|
129 : |* *|
130 : |* Automatically generated file, do not edit! *|
131 : |* *|
132 : \*===----------------------------------------------------------------------===*/
133 :
134 :
135 : #ifdef GET_REGINFO_MC_DESC
136 : #undef GET_REGINFO_MC_DESC
137 :
138 : namespace llvm {
139 :
140 : extern const MCPhysReg AVRRegDiffLists[] = {
141 : /* 0 */ 0, 1, 0,
142 : /* 3 */ 65465, 1, 0,
143 : /* 6 */ 65504, 1, 0,
144 : /* 9 */ 65505, 1, 0,
145 : /* 12 */ 65506, 1, 0,
146 : /* 15 */ 65507, 1, 0,
147 : /* 18 */ 65508, 1, 0,
148 : /* 21 */ 65509, 1, 0,
149 : /* 24 */ 65510, 1, 0,
150 : /* 27 */ 65511, 1, 0,
151 : /* 30 */ 65512, 1, 0,
152 : /* 33 */ 65513, 1, 0,
153 : /* 36 */ 65514, 1, 0,
154 : /* 39 */ 65515, 1, 0,
155 : /* 42 */ 65516, 1, 0,
156 : /* 45 */ 65517, 1, 0,
157 : /* 48 */ 65518, 1, 0,
158 : /* 51 */ 65519, 1, 0,
159 : /* 54 */ 16, 0,
160 : /* 56 */ 17, 0,
161 : /* 58 */ 18, 0,
162 : /* 60 */ 19, 0,
163 : /* 62 */ 20, 0,
164 : /* 64 */ 21, 0,
165 : /* 66 */ 22, 0,
166 : /* 68 */ 23, 0,
167 : /* 70 */ 24, 0,
168 : /* 72 */ 25, 0,
169 : /* 74 */ 26, 0,
170 : /* 76 */ 27, 0,
171 : /* 78 */ 28, 0,
172 : /* 80 */ 29, 0,
173 : /* 82 */ 30, 0,
174 : /* 84 */ 31, 0,
175 : /* 86 */ 32, 0,
176 : /* 88 */ 65530, 0,
177 : /* 90 */ 65534, 0,
178 : /* 92 */ 2, 65535, 0,
179 : };
180 :
181 : extern const LaneBitmask AVRLaneMaskLists[] = {
182 : /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
183 : /* 2 */ LaneBitmask(0x00000002), LaneBitmask(0x00000001), LaneBitmask::getAll(),
184 : };
185 :
186 : extern const uint16_t AVRSubRegIdxLists[] = {
187 : /* 0 */ 2, 1, 0,
188 : };
189 :
190 : extern const MCRegisterInfo::SubRegCoveredBits AVRSubRegIdxRanges[] = {
191 : { 65535, 65535 },
192 : { 8, 8 }, // sub_hi
193 : { 0, 8 }, // sub_lo
194 : };
195 :
196 : extern const char AVRRegStrings[] = {
197 : /* 0 */ 'R', '1', '1', 'R', '1', '0', 0,
198 : /* 7 */ 'R', '2', '1', 'R', '2', '0', 0,
199 : /* 14 */ 'R', '3', '1', 'R', '3', '0', 0,
200 : /* 21 */ 'R', '1', 'R', '0', 0,
201 : /* 26 */ 'R', '1', '1', 0,
202 : /* 30 */ 'R', '2', '1', 0,
203 : /* 34 */ 'R', '3', '1', 0,
204 : /* 38 */ 'R', '1', 0,
205 : /* 41 */ 'R', '1', '3', 'R', '1', '2', 0,
206 : /* 48 */ 'R', '2', '3', 'R', '2', '2', 0,
207 : /* 55 */ 'R', '3', 'R', '2', 0,
208 : /* 60 */ 'R', '1', '3', 0,
209 : /* 64 */ 'R', '2', '3', 0,
210 : /* 68 */ 'R', '3', 0,
211 : /* 71 */ 'R', '1', '5', 'R', '1', '4', 0,
212 : /* 78 */ 'R', '2', '5', 'R', '2', '4', 0,
213 : /* 85 */ 'R', '5', 'R', '4', 0,
214 : /* 90 */ 'R', '1', '5', 0,
215 : /* 94 */ 'R', '2', '5', 0,
216 : /* 98 */ 'R', '5', 0,
217 : /* 101 */ 'R', '1', '7', 'R', '1', '6', 0,
218 : /* 108 */ 'R', '2', '7', 'R', '2', '6', 0,
219 : /* 115 */ 'R', '7', 'R', '6', 0,
220 : /* 120 */ 'R', '1', '7', 0,
221 : /* 124 */ 'R', '2', '7', 0,
222 : /* 128 */ 'R', '7', 0,
223 : /* 131 */ 'R', '1', '9', 'R', '1', '8', 0,
224 : /* 138 */ 'R', '2', '9', 'R', '2', '8', 0,
225 : /* 145 */ 'R', '9', 'R', '8', 0,
226 : /* 150 */ 'R', '1', '9', 0,
227 : /* 154 */ 'R', '2', '9', 0,
228 : /* 158 */ 'R', '9', 0,
229 : /* 161 */ 'S', 'R', 'E', 'G', 0,
230 : /* 166 */ 'S', 'P', 'H', 0,
231 : /* 170 */ 'S', 'P', 'L', 0,
232 : /* 174 */ 'S', 'P', 0,
233 : };
234 :
235 : extern const MCRegisterDesc AVRRegDesc[] = { // Descriptors
236 : { 6, 0, 0, 0, 0, 0 },
237 : { 174, 92, 2, 0, 0, 2 },
238 : { 166, 2, 93, 2, 16, 0 },
239 : { 170, 2, 90, 2, 1410, 0 },
240 : { 161, 2, 2, 2, 1441, 0 },
241 : { 23, 2, 86, 2, 1441, 0 },
242 : { 38, 2, 84, 2, 1441, 0 },
243 : { 57, 2, 84, 2, 1441, 0 },
244 : { 68, 2, 82, 2, 1441, 0 },
245 : { 87, 2, 82, 2, 1441, 0 },
246 : { 98, 2, 80, 2, 1441, 0 },
247 : { 117, 2, 80, 2, 1441, 0 },
248 : { 128, 2, 78, 2, 1441, 0 },
249 : { 147, 2, 78, 2, 1441, 0 },
250 : { 158, 2, 76, 2, 1441, 0 },
251 : { 3, 2, 76, 2, 1441, 0 },
252 : { 26, 2, 74, 2, 1441, 0 },
253 : { 44, 2, 74, 2, 1441, 0 },
254 : { 60, 2, 72, 2, 1441, 0 },
255 : { 74, 2, 72, 2, 1441, 0 },
256 : { 90, 2, 70, 2, 1441, 0 },
257 : { 104, 2, 70, 2, 1441, 0 },
258 : { 120, 2, 68, 2, 1441, 0 },
259 : { 134, 2, 68, 2, 1441, 0 },
260 : { 150, 2, 66, 2, 1441, 0 },
261 : { 10, 2, 66, 2, 1441, 0 },
262 : { 30, 2, 64, 2, 1441, 0 },
263 : { 51, 2, 64, 2, 1441, 0 },
264 : { 64, 2, 62, 2, 1441, 0 },
265 : { 81, 2, 62, 2, 1441, 0 },
266 : { 94, 2, 60, 2, 1441, 0 },
267 : { 111, 2, 60, 2, 1441, 0 },
268 : { 124, 2, 58, 2, 1441, 0 },
269 : { 141, 2, 58, 2, 1441, 0 },
270 : { 154, 2, 56, 2, 1441, 0 },
271 : { 17, 2, 56, 2, 1441, 0 },
272 : { 34, 2, 54, 2, 1441, 0 },
273 : { 21, 6, 2, 0, 50, 2 },
274 : { 55, 9, 2, 0, 50, 2 },
275 : { 85, 12, 2, 0, 50, 2 },
276 : { 115, 15, 2, 0, 50, 2 },
277 : { 145, 18, 2, 0, 50, 2 },
278 : { 0, 21, 2, 0, 50, 2 },
279 : { 41, 24, 2, 0, 50, 2 },
280 : { 71, 27, 2, 0, 50, 2 },
281 : { 101, 30, 2, 0, 50, 2 },
282 : { 131, 33, 2, 0, 50, 2 },
283 : { 7, 36, 2, 0, 50, 2 },
284 : { 48, 39, 2, 0, 50, 2 },
285 : { 78, 42, 2, 0, 50, 2 },
286 : { 108, 45, 2, 0, 50, 2 },
287 : { 138, 48, 2, 0, 50, 2 },
288 : { 14, 51, 2, 0, 50, 2 },
289 : };
290 :
291 : extern const MCPhysReg AVRRegUnitRoots[][2] = {
292 : { AVR::SPL },
293 : { AVR::SPH },
294 : { AVR::SREG },
295 : { AVR::R0 },
296 : { AVR::R1 },
297 : { AVR::R2 },
298 : { AVR::R3 },
299 : { AVR::R4 },
300 : { AVR::R5 },
301 : { AVR::R6 },
302 : { AVR::R7 },
303 : { AVR::R8 },
304 : { AVR::R9 },
305 : { AVR::R10 },
306 : { AVR::R11 },
307 : { AVR::R12 },
308 : { AVR::R13 },
309 : { AVR::R14 },
310 : { AVR::R15 },
311 : { AVR::R16 },
312 : { AVR::R17 },
313 : { AVR::R18 },
314 : { AVR::R19 },
315 : { AVR::R20 },
316 : { AVR::R21 },
317 : { AVR::R22 },
318 : { AVR::R23 },
319 : { AVR::R24 },
320 : { AVR::R25 },
321 : { AVR::R26 },
322 : { AVR::R27 },
323 : { AVR::R28 },
324 : { AVR::R29 },
325 : { AVR::R30 },
326 : { AVR::R31 },
327 : };
328 :
329 : namespace { // Register classes...
330 : // GPR8 Register Class...
331 : const MCPhysReg GPR8[] = {
332 : AVR::R24, AVR::R25, AVR::R18, AVR::R19, AVR::R20, AVR::R21, AVR::R22, AVR::R23, AVR::R30, AVR::R31, AVR::R26, AVR::R27, AVR::R28, AVR::R29, AVR::R17, AVR::R16, AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, AVR::R0, AVR::R1,
333 : };
334 :
335 : // GPR8 Bit set.
336 : const uint8_t GPR8Bits[] = {
337 : 0xe0, 0xff, 0xff, 0xff, 0x1f,
338 : };
339 :
340 : // GPR8lo Register Class...
341 : const MCPhysReg GPR8lo[] = {
342 : AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, AVR::R0, AVR::R1,
343 : };
344 :
345 : // GPR8lo Bit set.
346 : const uint8_t GPR8loBits[] = {
347 : 0xe0, 0xff, 0x1f,
348 : };
349 :
350 : // LD8 Register Class...
351 : const MCPhysReg LD8[] = {
352 : AVR::R24, AVR::R25, AVR::R18, AVR::R19, AVR::R20, AVR::R21, AVR::R22, AVR::R23, AVR::R30, AVR::R31, AVR::R26, AVR::R27, AVR::R28, AVR::R29, AVR::R17, AVR::R16,
353 : };
354 :
355 : // LD8 Bit set.
356 : const uint8_t LD8Bits[] = {
357 : 0x00, 0x00, 0xe0, 0xff, 0x1f,
358 : };
359 :
360 : // LD8lo Register Class...
361 : const MCPhysReg LD8lo[] = {
362 : AVR::R23, AVR::R22, AVR::R21, AVR::R20, AVR::R19, AVR::R18, AVR::R17, AVR::R16,
363 : };
364 :
365 : // LD8lo Bit set.
366 : const uint8_t LD8loBits[] = {
367 : 0x00, 0x00, 0xe0, 0x1f,
368 : };
369 :
370 : // CCR Register Class...
371 : const MCPhysReg CCR[] = {
372 : AVR::SREG,
373 : };
374 :
375 : // CCR Bit set.
376 : const uint8_t CCRBits[] = {
377 : 0x10,
378 : };
379 :
380 : // DREGS Register Class...
381 : const MCPhysReg DREGS[] = {
382 : AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0,
383 : };
384 :
385 : // DREGS Bit set.
386 : const uint8_t DREGSBits[] = {
387 : 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x1f,
388 : };
389 :
390 : // DLDREGS Register Class...
391 : const MCPhysReg DLDREGS[] = {
392 : AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16,
393 : };
394 :
395 : // DLDREGS Bit set.
396 : const uint8_t DLDREGSBits[] = {
397 : 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1f,
398 : };
399 :
400 : // DREGS_with_sub_hi_in_GPR8lo Register Class...
401 : const MCPhysReg DREGS_with_sub_hi_in_GPR8lo[] = {
402 : AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0,
403 : };
404 :
405 : // DREGS_with_sub_hi_in_GPR8lo Bit set.
406 : const uint8_t DREGS_with_sub_hi_in_GPR8loBits[] = {
407 : 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1f,
408 : };
409 :
410 : // DLDREGS_with_sub_hi_in_LD8lo Register Class...
411 : const MCPhysReg DLDREGS_with_sub_hi_in_LD8lo[] = {
412 : AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R17R16,
413 : };
414 :
415 : // DLDREGS_with_sub_hi_in_LD8lo Bit set.
416 : const uint8_t DLDREGS_with_sub_hi_in_LD8loBits[] = {
417 : 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x01,
418 : };
419 :
420 : // IWREGS Register Class...
421 : const MCPhysReg IWREGS[] = {
422 : AVR::R25R24, AVR::R31R30, AVR::R27R26, AVR::R29R28,
423 : };
424 :
425 : // IWREGS Bit set.
426 : const uint8_t IWREGSBits[] = {
427 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e,
428 : };
429 :
430 : // PTRREGS Register Class...
431 : const MCPhysReg PTRREGS[] = {
432 : AVR::R27R26, AVR::R29R28, AVR::R31R30,
433 : };
434 :
435 : // PTRREGS Bit set.
436 : const uint8_t PTRREGSBits[] = {
437 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c,
438 : };
439 :
440 : // PTRDISPREGS Register Class...
441 : const MCPhysReg PTRDISPREGS[] = {
442 : AVR::R31R30, AVR::R29R28,
443 : };
444 :
445 : // PTRDISPREGS Bit set.
446 : const uint8_t PTRDISPREGSBits[] = {
447 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18,
448 : };
449 :
450 : // GPRSP Register Class...
451 : const MCPhysReg GPRSP[] = {
452 : AVR::SP,
453 : };
454 :
455 : // GPRSP Bit set.
456 : const uint8_t GPRSPBits[] = {
457 : 0x02,
458 : };
459 :
460 : // ZREG Register Class...
461 : const MCPhysReg ZREG[] = {
462 : AVR::R31R30,
463 : };
464 :
465 : // ZREG Bit set.
466 : const uint8_t ZREGBits[] = {
467 : 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
468 : };
469 :
470 : } // end anonymous namespace
471 :
472 : extern const char AVRRegClassStrings[] = {
473 : /* 0 */ 'L', 'D', '8', 0,
474 : /* 4 */ 'G', 'P', 'R', '8', 0,
475 : /* 9 */ 'Z', 'R', 'E', 'G', 0,
476 : /* 14 */ 'G', 'P', 'R', 'S', 'P', 0,
477 : /* 20 */ 'C', 'C', 'R', 0,
478 : /* 24 */ 'D', 'L', 'D', 'R', 'E', 'G', 'S', 0,
479 : /* 32 */ 'P', 'T', 'R', 'D', 'I', 'S', 'P', 'R', 'E', 'G', 'S', 0,
480 : /* 44 */ 'P', 'T', 'R', 'R', 'E', 'G', 'S', 0,
481 : /* 52 */ 'I', 'W', 'R', 'E', 'G', 'S', 0,
482 : /* 59 */ 'D', 'L', 'D', 'R', 'E', 'G', 'S', '_', 'w', 'i', 't', 'h', '_', 's', 'u', 'b', '_', 'h', 'i', '_', 'i', 'n', '_', 'L', 'D', '8', 'l', 'o', 0,
483 : /* 88 */ 'D', 'R', 'E', 'G', 'S', '_', 'w', 'i', 't', 'h', '_', 's', 'u', 'b', '_', 'h', 'i', '_', 'i', 'n', '_', 'G', 'P', 'R', '8', 'l', 'o', 0,
484 : };
485 :
486 : extern const MCRegisterClass AVRMCRegisterClasses[] = {
487 : { GPR8, GPR8Bits, 4, 32, sizeof(GPR8Bits), AVR::GPR8RegClassID, 1, true },
488 : { GPR8lo, GPR8loBits, 109, 16, sizeof(GPR8loBits), AVR::GPR8loRegClassID, 1, true },
489 : { LD8, LD8Bits, 0, 16, sizeof(LD8Bits), AVR::LD8RegClassID, 1, true },
490 : { LD8lo, LD8loBits, 82, 8, sizeof(LD8loBits), AVR::LD8loRegClassID, 1, true },
491 : { CCR, CCRBits, 20, 1, sizeof(CCRBits), AVR::CCRRegClassID, -1, true },
492 : { DREGS, DREGSBits, 26, 16, sizeof(DREGSBits), AVR::DREGSRegClassID, 1, true },
493 : { DLDREGS, DLDREGSBits, 24, 8, sizeof(DLDREGSBits), AVR::DLDREGSRegClassID, 1, true },
494 : { DREGS_with_sub_hi_in_GPR8lo, DREGS_with_sub_hi_in_GPR8loBits, 88, 8, sizeof(DREGS_with_sub_hi_in_GPR8loBits), AVR::DREGS_with_sub_hi_in_GPR8loRegClassID, 1, true },
495 : { DLDREGS_with_sub_hi_in_LD8lo, DLDREGS_with_sub_hi_in_LD8loBits, 59, 4, sizeof(DLDREGS_with_sub_hi_in_LD8loBits), AVR::DLDREGS_with_sub_hi_in_LD8loRegClassID, 1, true },
496 : { IWREGS, IWREGSBits, 52, 4, sizeof(IWREGSBits), AVR::IWREGSRegClassID, 1, true },
497 : { PTRREGS, PTRREGSBits, 44, 3, sizeof(PTRREGSBits), AVR::PTRREGSRegClassID, 1, true },
498 : { PTRDISPREGS, PTRDISPREGSBits, 32, 2, sizeof(PTRDISPREGSBits), AVR::PTRDISPREGSRegClassID, 1, true },
499 : { GPRSP, GPRSPBits, 14, 1, sizeof(GPRSPBits), AVR::GPRSPRegClassID, 1, true },
500 : { ZREG, ZREGBits, 9, 1, sizeof(ZREGBits), AVR::ZREGRegClassID, 1, true },
501 : };
502 :
503 : // AVR Dwarf<->LLVM register mappings.
504 : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0Dwarf2L[] = {
505 : { 0U, AVR::R1R0 },
506 : { 1U, AVR::R1 },
507 : { 2U, AVR::R3R2 },
508 : { 3U, AVR::R3 },
509 : { 4U, AVR::R5R4 },
510 : { 5U, AVR::R5 },
511 : { 6U, AVR::R7R6 },
512 : { 7U, AVR::R7 },
513 : { 8U, AVR::R9R8 },
514 : { 9U, AVR::R9 },
515 : { 10U, AVR::R11R10 },
516 : { 11U, AVR::R11 },
517 : { 12U, AVR::R13R12 },
518 : { 13U, AVR::R13 },
519 : { 14U, AVR::R15R14 },
520 : { 15U, AVR::R15 },
521 : { 16U, AVR::R17R16 },
522 : { 17U, AVR::R17 },
523 : { 18U, AVR::R19R18 },
524 : { 19U, AVR::R19 },
525 : { 20U, AVR::R21R20 },
526 : { 21U, AVR::R21 },
527 : { 22U, AVR::R23R22 },
528 : { 23U, AVR::R23 },
529 : { 24U, AVR::R25R24 },
530 : { 25U, AVR::R25 },
531 : { 26U, AVR::R27R26 },
532 : { 27U, AVR::R27 },
533 : { 28U, AVR::R29R28 },
534 : { 29U, AVR::R29 },
535 : { 30U, AVR::R31R30 },
536 : { 31U, AVR::R31 },
537 : { 32U, AVR::SPL },
538 : { 33U, AVR::SPH },
539 : { 88U, AVR::SREG },
540 : };
541 : extern const unsigned AVRDwarfFlavour0Dwarf2LSize = array_lengthof(AVRDwarfFlavour0Dwarf2L);
542 :
543 : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0Dwarf2L[] = {
544 : { 0U, AVR::R1R0 },
545 : { 1U, AVR::R1 },
546 : { 2U, AVR::R3R2 },
547 : { 3U, AVR::R3 },
548 : { 4U, AVR::R5R4 },
549 : { 5U, AVR::R5 },
550 : { 6U, AVR::R7R6 },
551 : { 7U, AVR::R7 },
552 : { 8U, AVR::R9R8 },
553 : { 9U, AVR::R9 },
554 : { 10U, AVR::R11R10 },
555 : { 11U, AVR::R11 },
556 : { 12U, AVR::R13R12 },
557 : { 13U, AVR::R13 },
558 : { 14U, AVR::R15R14 },
559 : { 15U, AVR::R15 },
560 : { 16U, AVR::R17R16 },
561 : { 17U, AVR::R17 },
562 : { 18U, AVR::R19R18 },
563 : { 19U, AVR::R19 },
564 : { 20U, AVR::R21R20 },
565 : { 21U, AVR::R21 },
566 : { 22U, AVR::R23R22 },
567 : { 23U, AVR::R23 },
568 : { 24U, AVR::R25R24 },
569 : { 25U, AVR::R25 },
570 : { 26U, AVR::R27R26 },
571 : { 27U, AVR::R27 },
572 : { 28U, AVR::R29R28 },
573 : { 29U, AVR::R29 },
574 : { 30U, AVR::R31R30 },
575 : { 31U, AVR::R31 },
576 : { 32U, AVR::SPL },
577 : { 33U, AVR::SPH },
578 : { 88U, AVR::SREG },
579 : };
580 : extern const unsigned AVREHFlavour0Dwarf2LSize = array_lengthof(AVREHFlavour0Dwarf2L);
581 :
582 : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0L2Dwarf[] = {
583 : { AVR::SP, 32U },
584 : { AVR::SPH, 33U },
585 : { AVR::SPL, 32U },
586 : { AVR::SREG, 88U },
587 : { AVR::R0, 0U },
588 : { AVR::R1, 1U },
589 : { AVR::R2, 2U },
590 : { AVR::R3, 3U },
591 : { AVR::R4, 4U },
592 : { AVR::R5, 5U },
593 : { AVR::R6, 6U },
594 : { AVR::R7, 7U },
595 : { AVR::R8, 8U },
596 : { AVR::R9, 9U },
597 : { AVR::R10, 10U },
598 : { AVR::R11, 11U },
599 : { AVR::R12, 12U },
600 : { AVR::R13, 13U },
601 : { AVR::R14, 14U },
602 : { AVR::R15, 15U },
603 : { AVR::R16, 16U },
604 : { AVR::R17, 17U },
605 : { AVR::R18, 18U },
606 : { AVR::R19, 19U },
607 : { AVR::R20, 20U },
608 : { AVR::R21, 21U },
609 : { AVR::R22, 22U },
610 : { AVR::R23, 23U },
611 : { AVR::R24, 24U },
612 : { AVR::R25, 25U },
613 : { AVR::R26, 26U },
614 : { AVR::R27, 27U },
615 : { AVR::R28, 28U },
616 : { AVR::R29, 29U },
617 : { AVR::R30, 30U },
618 : { AVR::R31, 31U },
619 : { AVR::R1R0, 0U },
620 : { AVR::R3R2, 2U },
621 : { AVR::R5R4, 4U },
622 : { AVR::R7R6, 6U },
623 : { AVR::R9R8, 8U },
624 : { AVR::R11R10, 10U },
625 : { AVR::R13R12, 12U },
626 : { AVR::R15R14, 14U },
627 : { AVR::R17R16, 16U },
628 : { AVR::R19R18, 18U },
629 : { AVR::R21R20, 20U },
630 : { AVR::R23R22, 22U },
631 : { AVR::R25R24, 24U },
632 : { AVR::R27R26, 26U },
633 : { AVR::R29R28, 28U },
634 : { AVR::R31R30, 30U },
635 : };
636 : extern const unsigned AVRDwarfFlavour0L2DwarfSize = array_lengthof(AVRDwarfFlavour0L2Dwarf);
637 :
638 : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0L2Dwarf[] = {
639 : { AVR::SP, 32U },
640 : { AVR::SPH, 33U },
641 : { AVR::SPL, 32U },
642 : { AVR::SREG, 88U },
643 : { AVR::R0, 0U },
644 : { AVR::R1, 1U },
645 : { AVR::R2, 2U },
646 : { AVR::R3, 3U },
647 : { AVR::R4, 4U },
648 : { AVR::R5, 5U },
649 : { AVR::R6, 6U },
650 : { AVR::R7, 7U },
651 : { AVR::R8, 8U },
652 : { AVR::R9, 9U },
653 : { AVR::R10, 10U },
654 : { AVR::R11, 11U },
655 : { AVR::R12, 12U },
656 : { AVR::R13, 13U },
657 : { AVR::R14, 14U },
658 : { AVR::R15, 15U },
659 : { AVR::R16, 16U },
660 : { AVR::R17, 17U },
661 : { AVR::R18, 18U },
662 : { AVR::R19, 19U },
663 : { AVR::R20, 20U },
664 : { AVR::R21, 21U },
665 : { AVR::R22, 22U },
666 : { AVR::R23, 23U },
667 : { AVR::R24, 24U },
668 : { AVR::R25, 25U },
669 : { AVR::R26, 26U },
670 : { AVR::R27, 27U },
671 : { AVR::R28, 28U },
672 : { AVR::R29, 29U },
673 : { AVR::R30, 30U },
674 : { AVR::R31, 31U },
675 : { AVR::R1R0, 0U },
676 : { AVR::R3R2, 2U },
677 : { AVR::R5R4, 4U },
678 : { AVR::R7R6, 6U },
679 : { AVR::R9R8, 8U },
680 : { AVR::R11R10, 10U },
681 : { AVR::R13R12, 12U },
682 : { AVR::R15R14, 14U },
683 : { AVR::R17R16, 16U },
684 : { AVR::R19R18, 18U },
685 : { AVR::R21R20, 20U },
686 : { AVR::R23R22, 22U },
687 : { AVR::R25R24, 24U },
688 : { AVR::R27R26, 26U },
689 : { AVR::R29R28, 28U },
690 : { AVR::R31R30, 30U },
691 : };
692 : extern const unsigned AVREHFlavour0L2DwarfSize = array_lengthof(AVREHFlavour0L2Dwarf);
693 :
694 : extern const uint16_t AVRRegEncodingTable[] = {
695 : 0,
696 : 32,
697 : 33,
698 : 32,
699 : 14,
700 : 0,
701 : 1,
702 : 2,
703 : 3,
704 : 4,
705 : 5,
706 : 6,
707 : 7,
708 : 8,
709 : 9,
710 : 10,
711 : 11,
712 : 12,
713 : 13,
714 : 14,
715 : 15,
716 : 16,
717 : 17,
718 : 18,
719 : 19,
720 : 20,
721 : 21,
722 : 22,
723 : 23,
724 : 24,
725 : 25,
726 : 26,
727 : 27,
728 : 28,
729 : 29,
730 : 30,
731 : 31,
732 : 0,
733 : 2,
734 : 4,
735 : 6,
736 : 8,
737 : 10,
738 : 12,
739 : 14,
740 : 16,
741 : 18,
742 : 20,
743 : 22,
744 : 24,
745 : 26,
746 : 28,
747 : 30,
748 : };
749 : static inline void InitAVRMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
750 : RI->InitMCRegisterInfo(AVRRegDesc, 53, RA, PC, AVRMCRegisterClasses, 14, AVRRegUnitRoots, 35, AVRRegDiffLists, AVRLaneMaskLists, AVRRegStrings, AVRRegClassStrings, AVRSubRegIdxLists, 3,
751 : AVRSubRegIdxRanges, AVRRegEncodingTable);
752 :
753 : switch (DwarfFlavour) {
754 : default:
755 : llvm_unreachable("Unknown DWARF flavour");
756 : case 0:
757 : RI->mapDwarfRegsToLLVMRegs(AVRDwarfFlavour0Dwarf2L, AVRDwarfFlavour0Dwarf2LSize, false);
758 : break;
759 : }
760 : switch (EHFlavour) {
761 : default:
762 : llvm_unreachable("Unknown DWARF flavour");
763 : case 0:
764 : RI->mapDwarfRegsToLLVMRegs(AVREHFlavour0Dwarf2L, AVREHFlavour0Dwarf2LSize, true);
765 : break;
766 : }
767 : switch (DwarfFlavour) {
768 : default:
769 : llvm_unreachable("Unknown DWARF flavour");
770 : case 0:
771 : RI->mapLLVMRegsToDwarfRegs(AVRDwarfFlavour0L2Dwarf, AVRDwarfFlavour0L2DwarfSize, false);
772 : break;
773 : }
774 : switch (EHFlavour) {
775 : default:
776 : llvm_unreachable("Unknown DWARF flavour");
777 : case 0:
778 : RI->mapLLVMRegsToDwarfRegs(AVREHFlavour0L2Dwarf, AVREHFlavour0L2DwarfSize, true);
779 : break;
780 : }
781 : }
782 :
783 : } // end namespace llvm
784 :
785 : #endif // GET_REGINFO_MC_DESC
786 :
787 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
788 : |* *|
789 : |* Register Information Header Fragment *|
790 : |* *|
791 : |* Automatically generated file, do not edit! *|
792 : |* *|
793 : \*===----------------------------------------------------------------------===*/
794 :
795 :
796 : #ifdef GET_REGINFO_HEADER
797 : #undef GET_REGINFO_HEADER
798 :
799 : #include "llvm/CodeGen/TargetRegisterInfo.h"
800 :
801 : namespace llvm {
802 :
803 : class AVRFrameLowering;
804 :
805 : struct AVRGenRegisterInfo : public TargetRegisterInfo {
806 : explicit AVRGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0,
807 : unsigned PC = 0, unsigned HwMode = 0);
808 : unsigned composeSubRegIndicesImpl(unsigned, unsigned) const override;
809 : LaneBitmask composeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
810 : LaneBitmask reverseComposeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
811 : const TargetRegisterClass *getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const override;
812 : const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
813 : unsigned getRegUnitWeight(unsigned RegUnit) const override;
814 : unsigned getNumRegPressureSets() const override;
815 : const char *getRegPressureSetName(unsigned Idx) const override;
816 : unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
817 : const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
818 : const int *getRegUnitPressureSets(unsigned RegUnit) const override;
819 : ArrayRef<const char *> getRegMaskNames() const override;
820 : ArrayRef<const uint32_t *> getRegMasks() const override;
821 : /// Devirtualized TargetFrameLowering.
822 : static const AVRFrameLowering *getFrameLowering(
823 : const MachineFunction &MF);
824 : };
825 :
826 : namespace AVR { // Register classes
827 : extern const TargetRegisterClass GPR8RegClass;
828 : extern const TargetRegisterClass GPR8loRegClass;
829 : extern const TargetRegisterClass LD8RegClass;
830 : extern const TargetRegisterClass LD8loRegClass;
831 : extern const TargetRegisterClass CCRRegClass;
832 : extern const TargetRegisterClass DREGSRegClass;
833 : extern const TargetRegisterClass DLDREGSRegClass;
834 : extern const TargetRegisterClass DREGS_with_sub_hi_in_GPR8loRegClass;
835 : extern const TargetRegisterClass DLDREGS_with_sub_hi_in_LD8loRegClass;
836 : extern const TargetRegisterClass IWREGSRegClass;
837 : extern const TargetRegisterClass PTRREGSRegClass;
838 : extern const TargetRegisterClass PTRDISPREGSRegClass;
839 : extern const TargetRegisterClass GPRSPRegClass;
840 : extern const TargetRegisterClass ZREGRegClass;
841 : } // end namespace AVR
842 :
843 : } // end namespace llvm
844 :
845 : #endif // GET_REGINFO_HEADER
846 :
847 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
848 : |* *|
849 : |* Target Register and Register Classes Information *|
850 : |* *|
851 : |* Automatically generated file, do not edit! *|
852 : |* *|
853 : \*===----------------------------------------------------------------------===*/
854 :
855 :
856 : #ifdef GET_REGINFO_TARGET_DESC
857 : #undef GET_REGINFO_TARGET_DESC
858 :
859 : namespace llvm {
860 :
861 : extern const MCRegisterClass AVRMCRegisterClasses[];
862 :
863 : static const MVT::SimpleValueType VTLists[] = {
864 : /* 0 */ MVT::i8, MVT::Other,
865 : /* 2 */ MVT::i16, MVT::Other,
866 : };
867 :
868 : static const char *const SubRegIndexNameTable[] = { "sub_hi", "sub_lo", "" };
869 :
870 :
871 : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
872 : LaneBitmask::getAll(),
873 : LaneBitmask(0x00000001), // sub_hi
874 : LaneBitmask(0x00000002), // sub_lo
875 : };
876 :
877 :
878 :
879 : static const TargetRegisterInfo::RegClassInfo RegClassInfos[] = {
880 : // Mode = 0 (Default)
881 : { 8, 8, 8, VTLists+0 }, // GPR8
882 : { 8, 8, 8, VTLists+0 }, // GPR8lo
883 : { 8, 8, 8, VTLists+0 }, // LD8
884 : { 8, 8, 8, VTLists+0 }, // LD8lo
885 : { 8, 8, 8, VTLists+0 }, // CCR
886 : { 16, 16, 8, VTLists+2 }, // DREGS
887 : { 16, 16, 8, VTLists+2 }, // DLDREGS
888 : { 16, 16, 8, VTLists+2 }, // DREGS_with_sub_hi_in_GPR8lo
889 : { 16, 16, 8, VTLists+2 }, // DLDREGS_with_sub_hi_in_LD8lo
890 : { 16, 16, 8, VTLists+2 }, // IWREGS
891 : { 16, 16, 8, VTLists+2 }, // PTRREGS
892 : { 16, 16, 8, VTLists+2 }, // PTRDISPREGS
893 : { 16, 16, 8, VTLists+2 }, // GPRSP
894 : { 16, 16, 8, VTLists+2 }, // ZREG
895 : };
896 :
897 : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
898 :
899 : static const uint32_t GPR8SubClassMask[] = {
900 : 0x0000000f,
901 : 0x00002fe0, // sub_hi
902 : 0x00002fe0, // sub_lo
903 : };
904 :
905 : static const uint32_t GPR8loSubClassMask[] = {
906 : 0x00000002,
907 : 0x00000080, // sub_hi
908 : 0x00000080, // sub_lo
909 : };
910 :
911 : static const uint32_t LD8SubClassMask[] = {
912 : 0x0000000c,
913 : 0x00002f40, // sub_hi
914 : 0x00002f40, // sub_lo
915 : };
916 :
917 : static const uint32_t LD8loSubClassMask[] = {
918 : 0x00000008,
919 : 0x00000100, // sub_hi
920 : 0x00000100, // sub_lo
921 : };
922 :
923 : static const uint32_t CCRSubClassMask[] = {
924 : 0x00000010,
925 : };
926 :
927 : static const uint32_t DREGSSubClassMask[] = {
928 : 0x00002fe0,
929 : };
930 :
931 : static const uint32_t DLDREGSSubClassMask[] = {
932 : 0x00002f40,
933 : };
934 :
935 : static const uint32_t DREGS_with_sub_hi_in_GPR8loSubClassMask[] = {
936 : 0x00000080,
937 : };
938 :
939 : static const uint32_t DLDREGS_with_sub_hi_in_LD8loSubClassMask[] = {
940 : 0x00000100,
941 : };
942 :
943 : static const uint32_t IWREGSSubClassMask[] = {
944 : 0x00002e00,
945 : };
946 :
947 : static const uint32_t PTRREGSSubClassMask[] = {
948 : 0x00002c00,
949 : };
950 :
951 : static const uint32_t PTRDISPREGSSubClassMask[] = {
952 : 0x00002800,
953 : };
954 :
955 : static const uint32_t GPRSPSubClassMask[] = {
956 : 0x00001000,
957 : };
958 :
959 : static const uint32_t ZREGSubClassMask[] = {
960 : 0x00002000,
961 : };
962 :
963 : static const uint16_t SuperRegIdxSeqs[] = {
964 : /* 0 */ 1, 2, 0,
965 : };
966 :
967 : static const TargetRegisterClass *const GPR8loSuperclasses[] = {
968 : &AVR::GPR8RegClass,
969 : nullptr
970 : };
971 :
972 : static const TargetRegisterClass *const LD8Superclasses[] = {
973 : &AVR::GPR8RegClass,
974 : nullptr
975 : };
976 :
977 : static const TargetRegisterClass *const LD8loSuperclasses[] = {
978 : &AVR::GPR8RegClass,
979 : &AVR::LD8RegClass,
980 : nullptr
981 : };
982 :
983 : static const TargetRegisterClass *const DLDREGSSuperclasses[] = {
984 : &AVR::DREGSRegClass,
985 : nullptr
986 : };
987 :
988 : static const TargetRegisterClass *const DREGS_with_sub_hi_in_GPR8loSuperclasses[] = {
989 : &AVR::DREGSRegClass,
990 : nullptr
991 : };
992 :
993 : static const TargetRegisterClass *const DLDREGS_with_sub_hi_in_LD8loSuperclasses[] = {
994 : &AVR::DREGSRegClass,
995 : &AVR::DLDREGSRegClass,
996 : nullptr
997 : };
998 :
999 : static const TargetRegisterClass *const IWREGSSuperclasses[] = {
1000 : &AVR::DREGSRegClass,
1001 : &AVR::DLDREGSRegClass,
1002 : nullptr
1003 : };
1004 :
1005 : static const TargetRegisterClass *const PTRREGSSuperclasses[] = {
1006 : &AVR::DREGSRegClass,
1007 : &AVR::DLDREGSRegClass,
1008 : &AVR::IWREGSRegClass,
1009 : nullptr
1010 : };
1011 :
1012 : static const TargetRegisterClass *const PTRDISPREGSSuperclasses[] = {
1013 : &AVR::DREGSRegClass,
1014 : &AVR::DLDREGSRegClass,
1015 : &AVR::IWREGSRegClass,
1016 : &AVR::PTRREGSRegClass,
1017 : nullptr
1018 : };
1019 :
1020 : static const TargetRegisterClass *const ZREGSuperclasses[] = {
1021 : &AVR::DREGSRegClass,
1022 : &AVR::DLDREGSRegClass,
1023 : &AVR::IWREGSRegClass,
1024 : &AVR::PTRREGSRegClass,
1025 : &AVR::PTRDISPREGSRegClass,
1026 : nullptr
1027 : };
1028 :
1029 :
1030 : namespace AVR { // Register class instances
1031 : extern const TargetRegisterClass GPR8RegClass = {
1032 : &AVRMCRegisterClasses[GPR8RegClassID],
1033 : GPR8SubClassMask,
1034 : SuperRegIdxSeqs + 0,
1035 : LaneBitmask(0x00000001),
1036 : 0,
1037 : false, /* HasDisjunctSubRegs */
1038 : false, /* CoveredBySubRegs */
1039 : NullRegClasses,
1040 : nullptr
1041 : };
1042 :
1043 : extern const TargetRegisterClass GPR8loRegClass = {
1044 : &AVRMCRegisterClasses[GPR8loRegClassID],
1045 : GPR8loSubClassMask,
1046 : SuperRegIdxSeqs + 0,
1047 : LaneBitmask(0x00000001),
1048 : 0,
1049 : false, /* HasDisjunctSubRegs */
1050 : false, /* CoveredBySubRegs */
1051 : GPR8loSuperclasses,
1052 : nullptr
1053 : };
1054 :
1055 : extern const TargetRegisterClass LD8RegClass = {
1056 : &AVRMCRegisterClasses[LD8RegClassID],
1057 : LD8SubClassMask,
1058 : SuperRegIdxSeqs + 0,
1059 : LaneBitmask(0x00000001),
1060 : 0,
1061 : false, /* HasDisjunctSubRegs */
1062 : false, /* CoveredBySubRegs */
1063 : LD8Superclasses,
1064 : nullptr
1065 : };
1066 :
1067 : extern const TargetRegisterClass LD8loRegClass = {
1068 : &AVRMCRegisterClasses[LD8loRegClassID],
1069 : LD8loSubClassMask,
1070 : SuperRegIdxSeqs + 0,
1071 : LaneBitmask(0x00000001),
1072 : 0,
1073 : false, /* HasDisjunctSubRegs */
1074 : false, /* CoveredBySubRegs */
1075 : LD8loSuperclasses,
1076 : nullptr
1077 : };
1078 :
1079 : extern const TargetRegisterClass CCRRegClass = {
1080 : &AVRMCRegisterClasses[CCRRegClassID],
1081 : CCRSubClassMask,
1082 : SuperRegIdxSeqs + 2,
1083 : LaneBitmask(0x00000001),
1084 : 0,
1085 : false, /* HasDisjunctSubRegs */
1086 : false, /* CoveredBySubRegs */
1087 : NullRegClasses,
1088 : nullptr
1089 : };
1090 :
1091 : extern const TargetRegisterClass DREGSRegClass = {
1092 : &AVRMCRegisterClasses[DREGSRegClassID],
1093 : DREGSSubClassMask,
1094 : SuperRegIdxSeqs + 2,
1095 : LaneBitmask(0x00000003),
1096 : 0,
1097 : true, /* HasDisjunctSubRegs */
1098 : true, /* CoveredBySubRegs */
1099 : NullRegClasses,
1100 : nullptr
1101 : };
1102 :
1103 : extern const TargetRegisterClass DLDREGSRegClass = {
1104 : &AVRMCRegisterClasses[DLDREGSRegClassID],
1105 : DLDREGSSubClassMask,
1106 : SuperRegIdxSeqs + 2,
1107 : LaneBitmask(0x00000003),
1108 : 0,
1109 : true, /* HasDisjunctSubRegs */
1110 : true, /* CoveredBySubRegs */
1111 : DLDREGSSuperclasses,
1112 : nullptr
1113 : };
1114 :
1115 : extern const TargetRegisterClass DREGS_with_sub_hi_in_GPR8loRegClass = {
1116 : &AVRMCRegisterClasses[DREGS_with_sub_hi_in_GPR8loRegClassID],
1117 : DREGS_with_sub_hi_in_GPR8loSubClassMask,
1118 : SuperRegIdxSeqs + 2,
1119 : LaneBitmask(0x00000003),
1120 : 0,
1121 : true, /* HasDisjunctSubRegs */
1122 : true, /* CoveredBySubRegs */
1123 : DREGS_with_sub_hi_in_GPR8loSuperclasses,
1124 : nullptr
1125 : };
1126 :
1127 : extern const TargetRegisterClass DLDREGS_with_sub_hi_in_LD8loRegClass = {
1128 : &AVRMCRegisterClasses[DLDREGS_with_sub_hi_in_LD8loRegClassID],
1129 : DLDREGS_with_sub_hi_in_LD8loSubClassMask,
1130 : SuperRegIdxSeqs + 2,
1131 : LaneBitmask(0x00000003),
1132 : 0,
1133 : true, /* HasDisjunctSubRegs */
1134 : true, /* CoveredBySubRegs */
1135 : DLDREGS_with_sub_hi_in_LD8loSuperclasses,
1136 : nullptr
1137 : };
1138 :
1139 : extern const TargetRegisterClass IWREGSRegClass = {
1140 : &AVRMCRegisterClasses[IWREGSRegClassID],
1141 : IWREGSSubClassMask,
1142 : SuperRegIdxSeqs + 2,
1143 : LaneBitmask(0x00000003),
1144 : 0,
1145 : true, /* HasDisjunctSubRegs */
1146 : true, /* CoveredBySubRegs */
1147 : IWREGSSuperclasses,
1148 : nullptr
1149 : };
1150 :
1151 : extern const TargetRegisterClass PTRREGSRegClass = {
1152 : &AVRMCRegisterClasses[PTRREGSRegClassID],
1153 : PTRREGSSubClassMask,
1154 : SuperRegIdxSeqs + 2,
1155 : LaneBitmask(0x00000003),
1156 : 0,
1157 : true, /* HasDisjunctSubRegs */
1158 : true, /* CoveredBySubRegs */
1159 : PTRREGSSuperclasses,
1160 : nullptr
1161 : };
1162 :
1163 : extern const TargetRegisterClass PTRDISPREGSRegClass = {
1164 : &AVRMCRegisterClasses[PTRDISPREGSRegClassID],
1165 : PTRDISPREGSSubClassMask,
1166 : SuperRegIdxSeqs + 2,
1167 : LaneBitmask(0x00000003),
1168 : 0,
1169 : true, /* HasDisjunctSubRegs */
1170 : true, /* CoveredBySubRegs */
1171 : PTRDISPREGSSuperclasses,
1172 : nullptr
1173 : };
1174 :
1175 : extern const TargetRegisterClass GPRSPRegClass = {
1176 : &AVRMCRegisterClasses[GPRSPRegClassID],
1177 : GPRSPSubClassMask,
1178 : SuperRegIdxSeqs + 2,
1179 : LaneBitmask(0x00000003),
1180 : 0,
1181 : true, /* HasDisjunctSubRegs */
1182 : true, /* CoveredBySubRegs */
1183 : NullRegClasses,
1184 : nullptr
1185 : };
1186 :
1187 : extern const TargetRegisterClass ZREGRegClass = {
1188 : &AVRMCRegisterClasses[ZREGRegClassID],
1189 : ZREGSubClassMask,
1190 : SuperRegIdxSeqs + 2,
1191 : LaneBitmask(0x00000003),
1192 : 0,
1193 : true, /* HasDisjunctSubRegs */
1194 : true, /* CoveredBySubRegs */
1195 : ZREGSuperclasses,
1196 : nullptr
1197 : };
1198 :
1199 : } // end namespace AVR
1200 :
1201 : namespace {
1202 : const TargetRegisterClass* const RegisterClasses[] = {
1203 : &AVR::GPR8RegClass,
1204 : &AVR::GPR8loRegClass,
1205 : &AVR::LD8RegClass,
1206 : &AVR::LD8loRegClass,
1207 : &AVR::CCRRegClass,
1208 : &AVR::DREGSRegClass,
1209 : &AVR::DLDREGSRegClass,
1210 : &AVR::DREGS_with_sub_hi_in_GPR8loRegClass,
1211 : &AVR::DLDREGS_with_sub_hi_in_LD8loRegClass,
1212 : &AVR::IWREGSRegClass,
1213 : &AVR::PTRREGSRegClass,
1214 : &AVR::PTRDISPREGSRegClass,
1215 : &AVR::GPRSPRegClass,
1216 : &AVR::ZREGRegClass,
1217 : };
1218 : } // end anonymous namespace
1219 :
1220 : static const TargetRegisterInfoDesc AVRRegInfoDesc[] = { // Extra Descriptors
1221 : { 0, false },
1222 : { 0, true },
1223 : { 0, false },
1224 : { 0, false },
1225 : { 0, true },
1226 : { 0, true },
1227 : { 0, true },
1228 : { 0, true },
1229 : { 0, true },
1230 : { 0, true },
1231 : { 0, true },
1232 : { 0, true },
1233 : { 0, true },
1234 : { 0, true },
1235 : { 0, true },
1236 : { 0, true },
1237 : { 0, true },
1238 : { 0, true },
1239 : { 0, true },
1240 : { 0, true },
1241 : { 0, true },
1242 : { 0, true },
1243 : { 0, true },
1244 : { 0, true },
1245 : { 0, true },
1246 : { 0, true },
1247 : { 0, true },
1248 : { 0, true },
1249 : { 0, true },
1250 : { 0, true },
1251 : { 0, true },
1252 : { 0, true },
1253 : { 0, true },
1254 : { 0, true },
1255 : { 0, true },
1256 : { 0, true },
1257 : { 0, true },
1258 : { 0, true },
1259 : { 0, true },
1260 : { 0, true },
1261 : { 0, true },
1262 : { 0, true },
1263 : { 0, true },
1264 : { 0, true },
1265 : { 0, true },
1266 : { 0, true },
1267 : { 0, true },
1268 : { 0, true },
1269 : { 0, true },
1270 : { 0, true },
1271 : { 0, true },
1272 : { 0, true },
1273 : { 0, true },
1274 : };
1275 0 : unsigned AVRGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
1276 : static const uint8_t Rows[1][2] = {
1277 : { 0, 0, },
1278 : };
1279 :
1280 : --IdxA; assert(IdxA < 2);
1281 0 : --IdxB; assert(IdxB < 2);
1282 0 : return Rows[0][IdxB];
1283 : }
1284 :
1285 : struct MaskRolOp {
1286 : LaneBitmask Mask;
1287 : uint8_t RotateLeft;
1288 : };
1289 : static const MaskRolOp LaneMaskComposeSequences[] = {
1290 : { LaneBitmask(0xFFFFFFFF), 0 }, { LaneBitmask::getNone(), 0 }, // Sequence 0
1291 : { LaneBitmask(0xFFFFFFFF), 1 }, { LaneBitmask::getNone(), 0 } // Sequence 2
1292 : };
1293 : static const MaskRolOp *const CompositeSequences[] = {
1294 : &LaneMaskComposeSequences[0], // to sub_hi
1295 : &LaneMaskComposeSequences[2] // to sub_lo
1296 : };
1297 :
1298 0 : LaneBitmask AVRGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
1299 0 : --IdxA; assert(IdxA < 2 && "Subregister index out of bounds");
1300 : LaneBitmask Result;
1301 0 : for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
1302 0 : LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
1303 0 : if (unsigned S = Ops->RotateLeft)
1304 0 : Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
1305 : else
1306 : Result |= LaneBitmask(M);
1307 : }
1308 0 : return Result;
1309 : }
1310 :
1311 0 : LaneBitmask AVRGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
1312 0 : LaneMask &= getSubRegIndexLaneMask(IdxA);
1313 0 : --IdxA; assert(IdxA < 2 && "Subregister index out of bounds");
1314 : LaneBitmask Result;
1315 0 : for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
1316 : LaneBitmask::Type M = LaneMask.getAsInteger();
1317 0 : if (unsigned S = Ops->RotateLeft)
1318 0 : Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
1319 : else
1320 : Result |= LaneBitmask(M);
1321 : }
1322 0 : return Result;
1323 : }
1324 :
1325 31 : const TargetRegisterClass *AVRGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
1326 : static const uint8_t Table[14][2] = {
1327 : { // GPR8
1328 : 0, // sub_hi
1329 : 0, // sub_lo
1330 : },
1331 : { // GPR8lo
1332 : 0, // sub_hi
1333 : 0, // sub_lo
1334 : },
1335 : { // LD8
1336 : 0, // sub_hi
1337 : 0, // sub_lo
1338 : },
1339 : { // LD8lo
1340 : 0, // sub_hi
1341 : 0, // sub_lo
1342 : },
1343 : { // CCR
1344 : 0, // sub_hi
1345 : 0, // sub_lo
1346 : },
1347 : { // DREGS
1348 : 6, // sub_hi -> DREGS
1349 : 6, // sub_lo -> DREGS
1350 : },
1351 : { // DLDREGS
1352 : 7, // sub_hi -> DLDREGS
1353 : 7, // sub_lo -> DLDREGS
1354 : },
1355 : { // DREGS_with_sub_hi_in_GPR8lo
1356 : 8, // sub_hi -> DREGS_with_sub_hi_in_GPR8lo
1357 : 8, // sub_lo -> DREGS_with_sub_hi_in_GPR8lo
1358 : },
1359 : { // DLDREGS_with_sub_hi_in_LD8lo
1360 : 9, // sub_hi -> DLDREGS_with_sub_hi_in_LD8lo
1361 : 9, // sub_lo -> DLDREGS_with_sub_hi_in_LD8lo
1362 : },
1363 : { // IWREGS
1364 : 10, // sub_hi -> IWREGS
1365 : 10, // sub_lo -> IWREGS
1366 : },
1367 : { // PTRREGS
1368 : 11, // sub_hi -> PTRREGS
1369 : 11, // sub_lo -> PTRREGS
1370 : },
1371 : { // PTRDISPREGS
1372 : 12, // sub_hi -> PTRDISPREGS
1373 : 12, // sub_lo -> PTRDISPREGS
1374 : },
1375 : { // GPRSP
1376 : 13, // sub_hi -> GPRSP
1377 : 13, // sub_lo -> GPRSP
1378 : },
1379 : { // ZREG
1380 : 14, // sub_hi -> ZREG
1381 : 14, // sub_lo -> ZREG
1382 : },
1383 : };
1384 : assert(RC && "Missing regclass");
1385 31 : if (!Idx) return RC;
1386 31 : --Idx;
1387 : assert(Idx < 2 && "Bad subreg");
1388 31 : unsigned TV = Table[RC->getID()][Idx];
1389 31 : return TV ? getRegClass(TV - 1) : nullptr;
1390 : }
1391 :
1392 : /// Get the weight in units of pressure for this register class.
1393 1592 : const RegClassWeight &AVRGenRegisterInfo::
1394 : getRegClassWeight(const TargetRegisterClass *RC) const {
1395 : static const RegClassWeight RCWeightTable[] = {
1396 : {1, 32}, // GPR8
1397 : {1, 16}, // GPR8lo
1398 : {1, 16}, // LD8
1399 : {1, 8}, // LD8lo
1400 : {1, 1}, // CCR
1401 : {2, 32}, // DREGS
1402 : {2, 16}, // DLDREGS
1403 : {2, 16}, // DREGS_with_sub_hi_in_GPR8lo
1404 : {2, 8}, // DLDREGS_with_sub_hi_in_LD8lo
1405 : {2, 8}, // IWREGS
1406 : {2, 6}, // PTRREGS
1407 : {2, 4}, // PTRDISPREGS
1408 : {2, 2}, // GPRSP
1409 : {2, 2}, // ZREG
1410 : };
1411 3184 : return RCWeightTable[RC->getID()];
1412 : }
1413 :
1414 : /// Get the weight in units of pressure for this register unit.
1415 0 : unsigned AVRGenRegisterInfo::
1416 : getRegUnitWeight(unsigned RegUnit) const {
1417 : assert(RegUnit < 35 && "invalid register unit");
1418 : // All register units have unit weight.
1419 0 : return 1;
1420 : }
1421 :
1422 :
1423 : // Get the number of dimensions of register pressure.
1424 588 : unsigned AVRGenRegisterInfo::getNumRegPressureSets() const {
1425 588 : return 7;
1426 : }
1427 :
1428 : // Get the name of this register unit pressure set.
1429 0 : const char *AVRGenRegisterInfo::
1430 : getRegPressureSetName(unsigned Idx) const {
1431 : static const char *const PressureNameTable[] = {
1432 : "CCR",
1433 : "GPRSP",
1434 : "LD8lo",
1435 : "IWREGS",
1436 : "GPR8lo",
1437 : "LD8",
1438 : "GPR8",
1439 : };
1440 0 : return PressureNameTable[Idx];
1441 : }
1442 :
1443 : // Get the register unit pressure limit for this dimension.
1444 : // This limit must be adjusted dynamically for reserved registers.
1445 2065 : unsigned AVRGenRegisterInfo::
1446 : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
1447 : static const uint8_t PressureLimitTable[] = {
1448 : 1, // 0: CCR
1449 : 2, // 1: GPRSP
1450 : 8, // 2: LD8lo
1451 : 8, // 3: IWREGS
1452 : 16, // 4: GPR8lo
1453 : 16, // 5: LD8
1454 : 32, // 6: GPR8
1455 : };
1456 2065 : return PressureLimitTable[Idx];
1457 : }
1458 :
1459 : /// Table of pressure sets per register class or unit.
1460 : static const int RCSetsTable[] = {
1461 : /* 0 */ 0, -1,
1462 : /* 2 */ 1, -1,
1463 : /* 4 */ 4, 6, -1,
1464 : /* 7 */ 2, 5, 6, -1,
1465 : /* 11 */ 3, 5, 6, -1,
1466 : };
1467 :
1468 : /// Get the dimensions of register pressure impacted by this register class.
1469 : /// Returns a -1 terminated array of pressure set IDs
1470 1332 : const int* AVRGenRegisterInfo::
1471 : getRegClassPressureSets(const TargetRegisterClass *RC) const {
1472 : static const uint8_t RCSetStartTable[] = {
1473 : 5,4,8,7,0,5,8,4,7,11,11,11,2,11,};
1474 2664 : return &RCSetsTable[RCSetStartTable[RC->getID()]];
1475 : }
1476 :
1477 : /// Get the dimensions of register pressure impacted by this register unit.
1478 : /// Returns a -1 terminated array of pressure set IDs
1479 0 : const int* AVRGenRegisterInfo::
1480 : getRegUnitPressureSets(unsigned RegUnit) const {
1481 : assert(RegUnit < 35 && "invalid register unit");
1482 : static const uint8_t RUSetStartTable[] = {
1483 : 2,2,0,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,7,7,7,7,7,7,7,7,11,11,11,11,11,11,11,11,};
1484 0 : return &RCSetsTable[RUSetStartTable[RegUnit]];
1485 : }
1486 :
1487 : extern const MCRegisterDesc AVRRegDesc[];
1488 : extern const MCPhysReg AVRRegDiffLists[];
1489 : extern const LaneBitmask AVRLaneMaskLists[];
1490 : extern const char AVRRegStrings[];
1491 : extern const char AVRRegClassStrings[];
1492 : extern const MCPhysReg AVRRegUnitRoots[][2];
1493 : extern const uint16_t AVRSubRegIdxLists[];
1494 : extern const MCRegisterInfo::SubRegCoveredBits AVRSubRegIdxRanges[];
1495 : extern const uint16_t AVRRegEncodingTable[];
1496 : // AVR Dwarf<->LLVM register mappings.
1497 : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0Dwarf2L[];
1498 : extern const unsigned AVRDwarfFlavour0Dwarf2LSize;
1499 :
1500 : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0Dwarf2L[];
1501 : extern const unsigned AVREHFlavour0Dwarf2LSize;
1502 :
1503 : extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0L2Dwarf[];
1504 : extern const unsigned AVRDwarfFlavour0L2DwarfSize;
1505 :
1506 : extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0L2Dwarf[];
1507 : extern const unsigned AVREHFlavour0L2DwarfSize;
1508 :
1509 119 : AVRGenRegisterInfo::
1510 : AVRGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
1511 119 : unsigned PC, unsigned HwMode)
1512 : : TargetRegisterInfo(AVRRegInfoDesc, RegisterClasses, RegisterClasses+14,
1513 : SubRegIndexNameTable, SubRegIndexLaneMaskTable,
1514 238 : LaneBitmask(0xFFFFFFFF), RegClassInfos, HwMode) {
1515 : InitMCRegisterInfo(AVRRegDesc, 53, RA, PC,
1516 : AVRMCRegisterClasses, 14,
1517 : AVRRegUnitRoots,
1518 : 35,
1519 : AVRRegDiffLists,
1520 : AVRLaneMaskLists,
1521 : AVRRegStrings,
1522 : AVRRegClassStrings,
1523 : AVRSubRegIdxLists,
1524 : 3,
1525 : AVRSubRegIdxRanges,
1526 : AVRRegEncodingTable);
1527 :
1528 119 : switch (DwarfFlavour) {
1529 0 : default:
1530 0 : llvm_unreachable("Unknown DWARF flavour");
1531 119 : case 0:
1532 119 : mapDwarfRegsToLLVMRegs(AVRDwarfFlavour0Dwarf2L, AVRDwarfFlavour0Dwarf2LSize, false);
1533 : break;
1534 : }
1535 119 : switch (EHFlavour) {
1536 0 : default:
1537 0 : llvm_unreachable("Unknown DWARF flavour");
1538 119 : case 0:
1539 119 : mapDwarfRegsToLLVMRegs(AVREHFlavour0Dwarf2L, AVREHFlavour0Dwarf2LSize, true);
1540 : break;
1541 : }
1542 : switch (DwarfFlavour) {
1543 : default:
1544 : llvm_unreachable("Unknown DWARF flavour");
1545 : case 0:
1546 119 : mapLLVMRegsToDwarfRegs(AVRDwarfFlavour0L2Dwarf, AVRDwarfFlavour0L2DwarfSize, false);
1547 : break;
1548 : }
1549 : switch (EHFlavour) {
1550 : default:
1551 : llvm_unreachable("Unknown DWARF flavour");
1552 : case 0:
1553 119 : mapLLVMRegsToDwarfRegs(AVREHFlavour0L2Dwarf, AVREHFlavour0L2DwarfSize, true);
1554 : break;
1555 : }
1556 119 : }
1557 :
1558 : static const MCPhysReg CSR_Interrupts_SaveList[] = { AVR::R31, AVR::R30, AVR::R29, AVR::R28, AVR::R27, AVR::R26, AVR::R25, AVR::R24, AVR::R23, AVR::R22, AVR::R21, AVR::R20, AVR::R19, AVR::R18, AVR::R17, AVR::R16, AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, AVR::R1, AVR::R0, 0 };
1559 : static const uint32_t CSR_Interrupts_RegMask[] = { 0xffffffe0, 0x001fffff, };
1560 : static const MCPhysReg CSR_Normal_SaveList[] = { AVR::R29, AVR::R28, AVR::R17, AVR::R16, AVR::R15, AVR::R14, AVR::R13, AVR::R12, AVR::R11, AVR::R10, AVR::R9, AVR::R8, AVR::R7, AVR::R6, AVR::R5, AVR::R4, AVR::R3, AVR::R2, 0 };
1561 : static const uint32_t CSR_Normal_RegMask[] = { 0x007fff80, 0x00083fc6, };
1562 :
1563 :
1564 35 : ArrayRef<const uint32_t *> AVRGenRegisterInfo::getRegMasks() const {
1565 : static const uint32_t *const Masks[] = {
1566 : CSR_Interrupts_RegMask,
1567 : CSR_Normal_RegMask,
1568 : };
1569 35 : return makeArrayRef(Masks);
1570 : }
1571 :
1572 0 : ArrayRef<const char *> AVRGenRegisterInfo::getRegMaskNames() const {
1573 : static const char *const Names[] = {
1574 : "CSR_Interrupts",
1575 : "CSR_Normal",
1576 : };
1577 0 : return makeArrayRef(Names);
1578 : }
1579 :
1580 : const AVRFrameLowering *
1581 0 : AVRGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
1582 : return static_cast<const AVRFrameLowering *>(
1583 0 : MF.getSubtarget().getFrameLowering());
1584 : }
1585 :
1586 : } // end namespace llvm
1587 :
1588 : #endif // GET_REGINFO_TARGET_DESC
1589 :
|
