1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* MC Register Information *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9namespace llvm {
10
11extern const int16_t AVRRegDiffLists[] = {
12 /* 0 */ -2, 0,
13 /* 2 */ 2, -1, 0,
14 /* 5 */ -32, 1, 0,
15 /* 8 */ -31, 1, 0,
16 /* 11 */ -30, 1, 0,
17 /* 14 */ -29, 1, 0,
18 /* 17 */ -28, 1, 0,
19 /* 20 */ -27, 1, 0,
20 /* 23 */ -26, 1, 0,
21 /* 26 */ 27, 1, 0,
22 /* 29 */ 25, 0,
23 /* 31 */ 26, 0,
24 /* 33 */ 27, 0,
25 /* 35 */ 28, 0,
26 /* 37 */ 29, 0,
27 /* 39 */ 30, 0,
28 /* 41 */ 31, 0,
29 /* 43 */ 32, 0,
30};
31
32extern const LaneBitmask AVRLaneMaskLists[] = {
33 /* 0 */ LaneBitmask(0x0000000000000002), LaneBitmask(0x0000000000000001),
34 /* 2 */ LaneBitmask(0xFFFFFFFFFFFFFFFF),
35};
36
37extern const uint16_t AVRSubRegIdxLists[] = {
38 /* 0 */ 2, 1,
39};
40
41
42#ifdef __GNUC__
43#pragma GCC diagnostic push
44#pragma GCC diagnostic ignored "-Woverlength-strings"
45#endif
46extern const char AVRRegStrings[] = {
47 /* 0 */ "R11R10\000"
48 /* 7 */ "R21R20\000"
49 /* 14 */ "R31R30\000"
50 /* 21 */ "R1R0\000"
51 /* 26 */ "R12R11\000"
52 /* 33 */ "R22R21\000"
53 /* 40 */ "R31\000"
54 /* 44 */ "R1\000"
55 /* 47 */ "R13R12\000"
56 /* 54 */ "R23R22\000"
57 /* 61 */ "R3R2\000"
58 /* 66 */ "R14R13\000"
59 /* 73 */ "R24R23\000"
60 /* 80 */ "R3\000"
61 /* 83 */ "R15R14\000"
62 /* 90 */ "R25R24\000"
63 /* 97 */ "R5R4\000"
64 /* 102 */ "R16R15\000"
65 /* 109 */ "R26R25\000"
66 /* 116 */ "R5\000"
67 /* 119 */ "R17R16\000"
68 /* 126 */ "R27R26\000"
69 /* 133 */ "R7R6\000"
70 /* 138 */ "R18R17\000"
71 /* 145 */ "R27\000"
72 /* 149 */ "R7\000"
73 /* 152 */ "R19R18\000"
74 /* 159 */ "R29R28\000"
75 /* 166 */ "R9R8\000"
76 /* 171 */ "R20R19\000"
77 /* 178 */ "R29\000"
78 /* 182 */ "R10R9\000"
79 /* 188 */ "SREG\000"
80 /* 193 */ "SPH\000"
81 /* 197 */ "SPL\000"
82 /* 201 */ "SP\000"
83};
84#ifdef __GNUC__
85#pragma GCC diagnostic pop
86#endif
87
88extern const MCRegisterDesc AVRRegDesc[] = { // Descriptors
89 { .Name: 6, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 0, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
90 { .Name: 201, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24576, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
91 { .Name: 193, .SubRegs: 1, .SuperRegs: 3, .SubRegIndices: 2, .RegUnits: 4097, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
92 { .Name: 197, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 2, .RegUnits: 4096, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
93 { .Name: 188, .SubRegs: 1, .SuperRegs: 1, .SubRegIndices: 2, .RegUnits: 4098, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
94 { .Name: 23, .SubRegs: 1, .SuperRegs: 43, .SubRegIndices: 2, .RegUnits: 4099, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
95 { .Name: 44, .SubRegs: 1, .SuperRegs: 41, .SubRegIndices: 2, .RegUnits: 4100, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
96 { .Name: 63, .SubRegs: 1, .SuperRegs: 41, .SubRegIndices: 2, .RegUnits: 4101, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
97 { .Name: 80, .SubRegs: 1, .SuperRegs: 39, .SubRegIndices: 2, .RegUnits: 4102, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
98 { .Name: 99, .SubRegs: 1, .SuperRegs: 39, .SubRegIndices: 2, .RegUnits: 4103, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
99 { .Name: 116, .SubRegs: 1, .SuperRegs: 37, .SubRegIndices: 2, .RegUnits: 4104, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
100 { .Name: 135, .SubRegs: 1, .SuperRegs: 37, .SubRegIndices: 2, .RegUnits: 4105, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
101 { .Name: 149, .SubRegs: 1, .SuperRegs: 35, .SubRegIndices: 2, .RegUnits: 4106, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
102 { .Name: 168, .SubRegs: 1, .SuperRegs: 35, .SubRegIndices: 2, .RegUnits: 4107, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
103 { .Name: 185, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4108, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
104 { .Name: 3, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4109, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
105 { .Name: 29, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4110, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
106 { .Name: 50, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4111, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
107 { .Name: 69, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4112, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
108 { .Name: 86, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4113, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
109 { .Name: 105, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4114, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
110 { .Name: 122, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4115, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
111 { .Name: 141, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4116, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
112 { .Name: 155, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4117, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
113 { .Name: 174, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4118, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
114 { .Name: 10, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4119, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
115 { .Name: 36, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4120, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
116 { .Name: 57, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4121, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
117 { .Name: 76, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4122, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
118 { .Name: 93, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4123, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
119 { .Name: 112, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4124, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
120 { .Name: 129, .SubRegs: 1, .SuperRegs: 26, .SubRegIndices: 2, .RegUnits: 4125, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
121 { .Name: 145, .SubRegs: 1, .SuperRegs: 33, .SubRegIndices: 2, .RegUnits: 4126, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
122 { .Name: 162, .SubRegs: 1, .SuperRegs: 33, .SubRegIndices: 2, .RegUnits: 4127, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
123 { .Name: 178, .SubRegs: 1, .SuperRegs: 31, .SubRegIndices: 2, .RegUnits: 4128, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
124 { .Name: 17, .SubRegs: 1, .SuperRegs: 31, .SubRegIndices: 2, .RegUnits: 4129, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
125 { .Name: 40, .SubRegs: 1, .SuperRegs: 29, .SubRegIndices: 2, .RegUnits: 4130, .RegUnitLaneMasks: 2, .IsConstant: 0, .IsArtificial: 0 },
126 { .Name: 21, .SubRegs: 5, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24579, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
127 { .Name: 61, .SubRegs: 8, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24581, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
128 { .Name: 97, .SubRegs: 11, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24583, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
129 { .Name: 133, .SubRegs: 14, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24585, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
130 { .Name: 166, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24587, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
131 { .Name: 182, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24588, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
132 { .Name: 0, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24589, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
133 { .Name: 26, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24590, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
134 { .Name: 47, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24591, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
135 { .Name: 66, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24592, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
136 { .Name: 83, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24593, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
137 { .Name: 102, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24594, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
138 { .Name: 119, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24595, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
139 { .Name: 138, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24596, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
140 { .Name: 152, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24597, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
141 { .Name: 171, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24598, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
142 { .Name: 7, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24599, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
143 { .Name: 33, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24600, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
144 { .Name: 54, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24601, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
145 { .Name: 73, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24602, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
146 { .Name: 90, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24603, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
147 { .Name: 109, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24604, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
148 { .Name: 126, .SubRegs: 17, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24605, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
149 { .Name: 159, .SubRegs: 20, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24607, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
150 { .Name: 14, .SubRegs: 23, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 24609, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
151};
152
153extern const MCPhysReg AVRRegUnitRoots[][2] = {
154 { AVR::SPL },
155 { AVR::SPH },
156 { AVR::SREG },
157 { AVR::R0 },
158 { AVR::R1 },
159 { AVR::R2 },
160 { AVR::R3 },
161 { AVR::R4 },
162 { AVR::R5 },
163 { AVR::R6 },
164 { AVR::R7 },
165 { AVR::R8 },
166 { AVR::R9 },
167 { AVR::R10 },
168 { AVR::R11 },
169 { AVR::R12 },
170 { AVR::R13 },
171 { AVR::R14 },
172 { AVR::R15 },
173 { AVR::R16 },
174 { AVR::R17 },
175 { AVR::R18 },
176 { AVR::R19 },
177 { AVR::R20 },
178 { AVR::R21 },
179 { AVR::R22 },
180 { AVR::R23 },
181 { AVR::R24 },
182 { AVR::R25 },
183 { AVR::R26 },
184 { AVR::R27 },
185 { AVR::R28 },
186 { AVR::R29 },
187 { AVR::R30 },
188 { AVR::R31 },
189};
190
191// Register classes...
192
193#ifdef __GNUC__
194#pragma GCC diagnostic push
195#pragma GCC diagnostic ignored "-Woverlength-strings"
196#endif
197extern const char AVRRegClassStrings[] = {
198 /* 0 */ "GPR8NOZ_and_LD8\000"
199 /* 16 */ "DREGSNOZ_and_DREGS_with_sub_hi_in_LD8\000"
200 /* 54 */ "DREGSNOZ_and_DREGS_with_sub_lo_in_LD8\000"
201 /* 92 */ "DREGS_with_sub_hi_in_LD8lo_and_DREGS_with_sub_lo_in_LD8\000"
202 /* 148 */ "GPR8\000"
203 /* 153 */ "ZREG\000"
204 /* 158 */ "GPRSP\000"
205 /* 164 */ "CCR\000"
206 /* 168 */ "DLDREGS\000"
207 /* 176 */ "DREGSNOZ_and_PTRDISPREGS\000"
208 /* 201 */ "DREGSNOZ_and_PTRREGS\000"
209 /* 222 */ "DREGSNOZ_and_IWREGS\000"
210 /* 242 */ "DREGSMOVW\000"
211 /* 252 */ "GPR8NOZ\000"
212 /* 260 */ "DLDREGS_and_DREGSNOZ\000"
213 /* 281 */ "DREGSMOVW_and_DREGSNOZ\000"
214 /* 304 */ "DREGSLD8lo\000"
215 /* 315 */ "DREGS_with_sub_hi_in_LD8lo\000"
216 /* 342 */ "DREGS_with_sub_lo_in_LD8lo\000"
217 /* 369 */ "DREGS_with_sub_hi_in_GPR8lo\000"
218 /* 397 */ "DREGS_with_sub_hi_in_LD8_and_DREGS_with_sub_lo_in_GPR8lo\000"
219 /* 454 */ "DREGSlo\000"
220};
221#ifdef __GNUC__
222#pragma GCC diagnostic pop
223#endif
224
225using AVRRegisterClassStorage = MCRegisterClassStorage<33, 340, 61, 86, 12, 3, 153>;
226inline constexpr MCRegisterClassStorage<33, 340, 61, 86, 12, 3, 153> AVRMCRegisterClassStorage = {
227 .Classes: {
228 {
229 offsetof(AVRRegisterClassStorage, Regs[0]) - 0 * sizeof(MCRegisterClass),
230 offsetof(AVRRegisterClassStorage, BitSets[0]) - 0 * sizeof(MCRegisterClass),
231 .NameIdx: 148,
232 .RegSizeInBits: 8,
233 .RegsSize: 32,
234 .RegSetBegin: 5, /* MinRegVal */
235 .RegSetSize: 32, /* RegSetSize */
236 .ID: AVR::GPR8RegClassID,
237 .CopyCost: 1, /* CopyCost */
238 .Allocatable: true, /* Allocatable */
239 .BaseClass: false,
240 offsetof(AVRRegisterClassStorage, SubClassMasks[0]) - 0 * sizeof(MCRegisterClass),
241 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[0]) - 0 * sizeof(MCRegisterClass),
242 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[0]) - 0 * sizeof(MCRegisterClass),
243 .LaneMask: LaneBitmask(0x0000000000000001),
244 .AllocationPriority: 0,
245 .GlobalPriority: false,
246 .TSFlags: 0x00, /* TSFlags */
247 .SpillStackID: 0, /* SpillStackID */
248 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
249 .CoveredBySubRegs: false, /* CoveredBySubRegs */
250 offsetof(AVRRegisterClassStorage, SuperClasses[0]) - 0 * sizeof(MCRegisterClass),
251 .SuperClassesSize: 0
252 },
253 {
254 offsetof(AVRRegisterClassStorage, Regs[32]) - 1 * sizeof(MCRegisterClass),
255 offsetof(AVRRegisterClassStorage, BitSets[4]) - 1 * sizeof(MCRegisterClass),
256 .NameIdx: 252,
257 .RegSizeInBits: 8,
258 .RegsSize: 30,
259 .RegSetBegin: 5, /* MinRegVal */
260 .RegSetSize: 30, /* RegSetSize */
261 .ID: AVR::GPR8NOZRegClassID,
262 .CopyCost: 1, /* CopyCost */
263 .Allocatable: true, /* Allocatable */
264 .BaseClass: false,
265 offsetof(AVRRegisterClassStorage, SubClassMasks[2]) - 1 * sizeof(MCRegisterClass),
266 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[2]) - 1 * sizeof(MCRegisterClass),
267 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[0]) - 1 * sizeof(MCRegisterClass),
268 .LaneMask: LaneBitmask(0x0000000000000001),
269 .AllocationPriority: 0,
270 .GlobalPriority: false,
271 .TSFlags: 0x00, /* TSFlags */
272 .SpillStackID: 0, /* SpillStackID */
273 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
274 .CoveredBySubRegs: false, /* CoveredBySubRegs */
275 offsetof(AVRRegisterClassStorage, SuperClasses[0]) - 1 * sizeof(MCRegisterClass),
276 .SuperClassesSize: 1
277 },
278 {
279 offsetof(AVRRegisterClassStorage, Regs[62]) - 2 * sizeof(MCRegisterClass),
280 offsetof(AVRRegisterClassStorage, BitSets[8]) - 2 * sizeof(MCRegisterClass),
281 .NameIdx: 390,
282 .RegSizeInBits: 8,
283 .RegsSize: 16,
284 .RegSetBegin: 5, /* MinRegVal */
285 .RegSetSize: 16, /* RegSetSize */
286 .ID: AVR::GPR8loRegClassID,
287 .CopyCost: 1, /* CopyCost */
288 .Allocatable: true, /* Allocatable */
289 .BaseClass: false,
290 offsetof(AVRRegisterClassStorage, SubClassMasks[4]) - 2 * sizeof(MCRegisterClass),
291 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[4]) - 2 * sizeof(MCRegisterClass),
292 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[0]) - 2 * sizeof(MCRegisterClass),
293 .LaneMask: LaneBitmask(0x0000000000000001),
294 .AllocationPriority: 0,
295 .GlobalPriority: false,
296 .TSFlags: 0x00, /* TSFlags */
297 .SpillStackID: 0, /* SpillStackID */
298 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
299 .CoveredBySubRegs: false, /* CoveredBySubRegs */
300 offsetof(AVRRegisterClassStorage, SuperClasses[1]) - 2 * sizeof(MCRegisterClass),
301 .SuperClassesSize: 2
302 },
303 {
304 offsetof(AVRRegisterClassStorage, Regs[78]) - 3 * sizeof(MCRegisterClass),
305 offsetof(AVRRegisterClassStorage, BitSets[10]) - 3 * sizeof(MCRegisterClass),
306 .NameIdx: 12,
307 .RegSizeInBits: 8,
308 .RegsSize: 16,
309 .RegSetBegin: 21, /* MinRegVal */
310 .RegSetSize: 16, /* RegSetSize */
311 .ID: AVR::LD8RegClassID,
312 .CopyCost: 1, /* CopyCost */
313 .Allocatable: true, /* Allocatable */
314 .BaseClass: false,
315 offsetof(AVRRegisterClassStorage, SubClassMasks[6]) - 3 * sizeof(MCRegisterClass),
316 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[6]) - 3 * sizeof(MCRegisterClass),
317 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[0]) - 3 * sizeof(MCRegisterClass),
318 .LaneMask: LaneBitmask(0x0000000000000001),
319 .AllocationPriority: 0,
320 .GlobalPriority: false,
321 .TSFlags: 0x00, /* TSFlags */
322 .SpillStackID: 0, /* SpillStackID */
323 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
324 .CoveredBySubRegs: false, /* CoveredBySubRegs */
325 offsetof(AVRRegisterClassStorage, SuperClasses[3]) - 3 * sizeof(MCRegisterClass),
326 .SuperClassesSize: 1
327 },
328 {
329 offsetof(AVRRegisterClassStorage, Regs[94]) - 4 * sizeof(MCRegisterClass),
330 offsetof(AVRRegisterClassStorage, BitSets[12]) - 4 * sizeof(MCRegisterClass),
331 .NameIdx: 0,
332 .RegSizeInBits: 8,
333 .RegsSize: 14,
334 .RegSetBegin: 21, /* MinRegVal */
335 .RegSetSize: 14, /* RegSetSize */
336 .ID: AVR::GPR8NOZ_and_LD8RegClassID,
337 .CopyCost: 1, /* CopyCost */
338 .Allocatable: true, /* Allocatable */
339 .BaseClass: false,
340 offsetof(AVRRegisterClassStorage, SubClassMasks[8]) - 4 * sizeof(MCRegisterClass),
341 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[8]) - 4 * sizeof(MCRegisterClass),
342 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[0]) - 4 * sizeof(MCRegisterClass),
343 .LaneMask: LaneBitmask(0x0000000000000001),
344 .AllocationPriority: 0,
345 .GlobalPriority: false,
346 .TSFlags: 0x00, /* TSFlags */
347 .SpillStackID: 0, /* SpillStackID */
348 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
349 .CoveredBySubRegs: false, /* CoveredBySubRegs */
350 offsetof(AVRRegisterClassStorage, SuperClasses[4]) - 4 * sizeof(MCRegisterClass),
351 .SuperClassesSize: 3
352 },
353 {
354 offsetof(AVRRegisterClassStorage, Regs[108]) - 5 * sizeof(MCRegisterClass),
355 offsetof(AVRRegisterClassStorage, BitSets[14]) - 5 * sizeof(MCRegisterClass),
356 .NameIdx: 309,
357 .RegSizeInBits: 8,
358 .RegsSize: 8,
359 .RegSetBegin: 21, /* MinRegVal */
360 .RegSetSize: 8, /* RegSetSize */
361 .ID: AVR::LD8loRegClassID,
362 .CopyCost: 1, /* CopyCost */
363 .Allocatable: true, /* Allocatable */
364 .BaseClass: false,
365 offsetof(AVRRegisterClassStorage, SubClassMasks[10]) - 5 * sizeof(MCRegisterClass),
366 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[10]) - 5 * sizeof(MCRegisterClass),
367 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[0]) - 5 * sizeof(MCRegisterClass),
368 .LaneMask: LaneBitmask(0x0000000000000001),
369 .AllocationPriority: 0,
370 .GlobalPriority: false,
371 .TSFlags: 0x00, /* TSFlags */
372 .SpillStackID: 0, /* SpillStackID */
373 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
374 .CoveredBySubRegs: false, /* CoveredBySubRegs */
375 offsetof(AVRRegisterClassStorage, SuperClasses[7]) - 5 * sizeof(MCRegisterClass),
376 .SuperClassesSize: 4
377 },
378 {
379 offsetof(AVRRegisterClassStorage, Regs[116]) - 6 * sizeof(MCRegisterClass),
380 offsetof(AVRRegisterClassStorage, BitSets[15]) - 6 * sizeof(MCRegisterClass),
381 .NameIdx: 164,
382 .RegSizeInBits: 8,
383 .RegsSize: 1,
384 .RegSetBegin: 4, /* MinRegVal */
385 .RegSetSize: 1, /* RegSetSize */
386 .ID: AVR::CCRRegClassID,
387 .CopyCost: 255, /* CopyCost */
388 .Allocatable: true, /* Allocatable */
389 .BaseClass: false,
390 offsetof(AVRRegisterClassStorage, SubClassMasks[12]) - 6 * sizeof(MCRegisterClass),
391 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 6 * sizeof(MCRegisterClass),
392 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 6 * sizeof(MCRegisterClass),
393 .LaneMask: LaneBitmask(0x0000000000000001),
394 .AllocationPriority: 0,
395 .GlobalPriority: false,
396 .TSFlags: 0x00, /* TSFlags */
397 .SpillStackID: 0, /* SpillStackID */
398 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
399 .CoveredBySubRegs: false, /* CoveredBySubRegs */
400 offsetof(AVRRegisterClassStorage, SuperClasses[11]) - 6 * sizeof(MCRegisterClass),
401 .SuperClassesSize: 0
402 },
403 {
404 offsetof(AVRRegisterClassStorage, Regs[117]) - 7 * sizeof(MCRegisterClass),
405 offsetof(AVRRegisterClassStorage, BitSets[16]) - 7 * sizeof(MCRegisterClass),
406 .NameIdx: 170,
407 .RegSizeInBits: 16,
408 .RegsSize: 25,
409 .RegSetBegin: 37, /* MinRegVal */
410 .RegSetSize: 25, /* RegSetSize */
411 .ID: AVR::DREGSRegClassID,
412 .CopyCost: 1, /* CopyCost */
413 .Allocatable: true, /* Allocatable */
414 .BaseClass: false,
415 offsetof(AVRRegisterClassStorage, SubClassMasks[14]) - 7 * sizeof(MCRegisterClass),
416 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 7 * sizeof(MCRegisterClass),
417 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 7 * sizeof(MCRegisterClass),
418 .LaneMask: LaneBitmask(0x0000000000000003),
419 .AllocationPriority: 0,
420 .GlobalPriority: false,
421 .TSFlags: 0x00, /* TSFlags */
422 .SpillStackID: 0, /* SpillStackID */
423 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
424 .CoveredBySubRegs: true, /* CoveredBySubRegs */
425 offsetof(AVRRegisterClassStorage, SuperClasses[11]) - 7 * sizeof(MCRegisterClass),
426 .SuperClassesSize: 0
427 },
428 {
429 offsetof(AVRRegisterClassStorage, Regs[142]) - 8 * sizeof(MCRegisterClass),
430 offsetof(AVRRegisterClassStorage, BitSets[20]) - 8 * sizeof(MCRegisterClass),
431 .NameIdx: 272,
432 .RegSizeInBits: 16,
433 .RegsSize: 24,
434 .RegSetBegin: 37, /* MinRegVal */
435 .RegSetSize: 24, /* RegSetSize */
436 .ID: AVR::DREGSNOZRegClassID,
437 .CopyCost: 1, /* CopyCost */
438 .Allocatable: true, /* Allocatable */
439 .BaseClass: false,
440 offsetof(AVRRegisterClassStorage, SubClassMasks[16]) - 8 * sizeof(MCRegisterClass),
441 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 8 * sizeof(MCRegisterClass),
442 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 8 * sizeof(MCRegisterClass),
443 .LaneMask: LaneBitmask(0x0000000000000003),
444 .AllocationPriority: 0,
445 .GlobalPriority: false,
446 .TSFlags: 0x00, /* TSFlags */
447 .SpillStackID: 0, /* SpillStackID */
448 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
449 .CoveredBySubRegs: true, /* CoveredBySubRegs */
450 offsetof(AVRRegisterClassStorage, SuperClasses[11]) - 8 * sizeof(MCRegisterClass),
451 .SuperClassesSize: 1
452 },
453 {
454 offsetof(AVRRegisterClassStorage, Regs[166]) - 9 * sizeof(MCRegisterClass),
455 offsetof(AVRRegisterClassStorage, BitSets[23]) - 9 * sizeof(MCRegisterClass),
456 .NameIdx: 242,
457 .RegSizeInBits: 16,
458 .RegsSize: 16,
459 .RegSetBegin: 37, /* MinRegVal */
460 .RegSetSize: 25, /* RegSetSize */
461 .ID: AVR::DREGSMOVWRegClassID,
462 .CopyCost: 1, /* CopyCost */
463 .Allocatable: true, /* Allocatable */
464 .BaseClass: false,
465 offsetof(AVRRegisterClassStorage, SubClassMasks[18]) - 9 * sizeof(MCRegisterClass),
466 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 9 * sizeof(MCRegisterClass),
467 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 9 * sizeof(MCRegisterClass),
468 .LaneMask: LaneBitmask(0x0000000000000003),
469 .AllocationPriority: 0,
470 .GlobalPriority: false,
471 .TSFlags: 0x00, /* TSFlags */
472 .SpillStackID: 0, /* SpillStackID */
473 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
474 .CoveredBySubRegs: true, /* CoveredBySubRegs */
475 offsetof(AVRRegisterClassStorage, SuperClasses[12]) - 9 * sizeof(MCRegisterClass),
476 .SuperClassesSize: 1
477 },
478 {
479 offsetof(AVRRegisterClassStorage, Regs[182]) - 10 * sizeof(MCRegisterClass),
480 offsetof(AVRRegisterClassStorage, BitSets[27]) - 10 * sizeof(MCRegisterClass),
481 .NameIdx: 281,
482 .RegSizeInBits: 16,
483 .RegsSize: 15,
484 .RegSetBegin: 37, /* MinRegVal */
485 .RegSetSize: 24, /* RegSetSize */
486 .ID: AVR::DREGSMOVW_and_DREGSNOZRegClassID,
487 .CopyCost: 1, /* CopyCost */
488 .Allocatable: true, /* Allocatable */
489 .BaseClass: false,
490 offsetof(AVRRegisterClassStorage, SubClassMasks[20]) - 10 * sizeof(MCRegisterClass),
491 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 10 * sizeof(MCRegisterClass),
492 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 10 * sizeof(MCRegisterClass),
493 .LaneMask: LaneBitmask(0x0000000000000003),
494 .AllocationPriority: 0,
495 .GlobalPriority: false,
496 .TSFlags: 0x00, /* TSFlags */
497 .SpillStackID: 0, /* SpillStackID */
498 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
499 .CoveredBySubRegs: true, /* CoveredBySubRegs */
500 offsetof(AVRRegisterClassStorage, SuperClasses[13]) - 10 * sizeof(MCRegisterClass),
501 .SuperClassesSize: 3
502 },
503 {
504 offsetof(AVRRegisterClassStorage, Regs[197]) - 11 * sizeof(MCRegisterClass),
505 offsetof(AVRRegisterClassStorage, BitSets[30]) - 11 * sizeof(MCRegisterClass),
506 .NameIdx: 29,
507 .RegSizeInBits: 16,
508 .RegsSize: 14,
509 .RegSetBegin: 48, /* MinRegVal */
510 .RegSetSize: 14, /* RegSetSize */
511 .ID: AVR::DREGS_with_sub_hi_in_LD8RegClassID,
512 .CopyCost: 1, /* CopyCost */
513 .Allocatable: true, /* Allocatable */
514 .BaseClass: false,
515 offsetof(AVRRegisterClassStorage, SubClassMasks[22]) - 11 * sizeof(MCRegisterClass),
516 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 11 * sizeof(MCRegisterClass),
517 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 11 * sizeof(MCRegisterClass),
518 .LaneMask: LaneBitmask(0x0000000000000003),
519 .AllocationPriority: 0,
520 .GlobalPriority: false,
521 .TSFlags: 0x00, /* TSFlags */
522 .SpillStackID: 0, /* SpillStackID */
523 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
524 .CoveredBySubRegs: true, /* CoveredBySubRegs */
525 offsetof(AVRRegisterClassStorage, SuperClasses[16]) - 11 * sizeof(MCRegisterClass),
526 .SuperClassesSize: 1
527 },
528 {
529 offsetof(AVRRegisterClassStorage, Regs[211]) - 12 * sizeof(MCRegisterClass),
530 offsetof(AVRRegisterClassStorage, BitSets[32]) - 12 * sizeof(MCRegisterClass),
531 .NameIdx: 16,
532 .RegSizeInBits: 16,
533 .RegsSize: 13,
534 .RegSetBegin: 48, /* MinRegVal */
535 .RegSetSize: 13, /* RegSetSize */
536 .ID: AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID,
537 .CopyCost: 1, /* CopyCost */
538 .Allocatable: true, /* Allocatable */
539 .BaseClass: false,
540 offsetof(AVRRegisterClassStorage, SubClassMasks[24]) - 12 * sizeof(MCRegisterClass),
541 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 12 * sizeof(MCRegisterClass),
542 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 12 * sizeof(MCRegisterClass),
543 .LaneMask: LaneBitmask(0x0000000000000003),
544 .AllocationPriority: 0,
545 .GlobalPriority: false,
546 .TSFlags: 0x00, /* TSFlags */
547 .SpillStackID: 0, /* SpillStackID */
548 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
549 .CoveredBySubRegs: true, /* CoveredBySubRegs */
550 offsetof(AVRRegisterClassStorage, SuperClasses[17]) - 12 * sizeof(MCRegisterClass),
551 .SuperClassesSize: 3
552 },
553 {
554 offsetof(AVRRegisterClassStorage, Regs[224]) - 13 * sizeof(MCRegisterClass),
555 offsetof(AVRRegisterClassStorage, BitSets[34]) - 13 * sizeof(MCRegisterClass),
556 .NameIdx: 67,
557 .RegSizeInBits: 16,
558 .RegsSize: 13,
559 .RegSetBegin: 49, /* MinRegVal */
560 .RegSetSize: 13, /* RegSetSize */
561 .ID: AVR::DREGS_with_sub_lo_in_LD8RegClassID,
562 .CopyCost: 1, /* CopyCost */
563 .Allocatable: true, /* Allocatable */
564 .BaseClass: false,
565 offsetof(AVRRegisterClassStorage, SubClassMasks[26]) - 13 * sizeof(MCRegisterClass),
566 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 13 * sizeof(MCRegisterClass),
567 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 13 * sizeof(MCRegisterClass),
568 .LaneMask: LaneBitmask(0x0000000000000003),
569 .AllocationPriority: 0,
570 .GlobalPriority: false,
571 .TSFlags: 0x00, /* TSFlags */
572 .SpillStackID: 0, /* SpillStackID */
573 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
574 .CoveredBySubRegs: true, /* CoveredBySubRegs */
575 offsetof(AVRRegisterClassStorage, SuperClasses[20]) - 13 * sizeof(MCRegisterClass),
576 .SuperClassesSize: 2
577 },
578 {
579 offsetof(AVRRegisterClassStorage, Regs[237]) - 14 * sizeof(MCRegisterClass),
580 offsetof(AVRRegisterClassStorage, BitSets[36]) - 14 * sizeof(MCRegisterClass),
581 .NameIdx: 54,
582 .RegSizeInBits: 16,
583 .RegsSize: 12,
584 .RegSetBegin: 49, /* MinRegVal */
585 .RegSetSize: 12, /* RegSetSize */
586 .ID: AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID,
587 .CopyCost: 1, /* CopyCost */
588 .Allocatable: true, /* Allocatable */
589 .BaseClass: false,
590 offsetof(AVRRegisterClassStorage, SubClassMasks[28]) - 14 * sizeof(MCRegisterClass),
591 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 14 * sizeof(MCRegisterClass),
592 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 14 * sizeof(MCRegisterClass),
593 .LaneMask: LaneBitmask(0x0000000000000003),
594 .AllocationPriority: 0,
595 .GlobalPriority: false,
596 .TSFlags: 0x00, /* TSFlags */
597 .SpillStackID: 0, /* SpillStackID */
598 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
599 .CoveredBySubRegs: true, /* CoveredBySubRegs */
600 offsetof(AVRRegisterClassStorage, SuperClasses[22]) - 14 * sizeof(MCRegisterClass),
601 .SuperClassesSize: 5
602 },
603 {
604 offsetof(AVRRegisterClassStorage, Regs[249]) - 15 * sizeof(MCRegisterClass),
605 offsetof(AVRRegisterClassStorage, BitSets[38]) - 15 * sizeof(MCRegisterClass),
606 .NameIdx: 426,
607 .RegSizeInBits: 16,
608 .RegsSize: 12,
609 .RegSetBegin: 37, /* MinRegVal */
610 .RegSetSize: 12, /* RegSetSize */
611 .ID: AVR::DREGS_with_sub_lo_in_GPR8loRegClassID,
612 .CopyCost: 1, /* CopyCost */
613 .Allocatable: true, /* Allocatable */
614 .BaseClass: false,
615 offsetof(AVRRegisterClassStorage, SubClassMasks[30]) - 15 * sizeof(MCRegisterClass),
616 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 15 * sizeof(MCRegisterClass),
617 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 15 * sizeof(MCRegisterClass),
618 .LaneMask: LaneBitmask(0x0000000000000003),
619 .AllocationPriority: 0,
620 .GlobalPriority: false,
621 .TSFlags: 0x00, /* TSFlags */
622 .SpillStackID: 0, /* SpillStackID */
623 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
624 .CoveredBySubRegs: true, /* CoveredBySubRegs */
625 offsetof(AVRRegisterClassStorage, SuperClasses[27]) - 15 * sizeof(MCRegisterClass),
626 .SuperClassesSize: 2
627 },
628 {
629 offsetof(AVRRegisterClassStorage, Regs[261]) - 16 * sizeof(MCRegisterClass),
630 offsetof(AVRRegisterClassStorage, BitSets[40]) - 16 * sizeof(MCRegisterClass),
631 .NameIdx: 369,
632 .RegSizeInBits: 16,
633 .RegsSize: 11,
634 .RegSetBegin: 37, /* MinRegVal */
635 .RegSetSize: 11, /* RegSetSize */
636 .ID: AVR::DREGS_with_sub_hi_in_GPR8loRegClassID,
637 .CopyCost: 1, /* CopyCost */
638 .Allocatable: true, /* Allocatable */
639 .BaseClass: false,
640 offsetof(AVRRegisterClassStorage, SubClassMasks[32]) - 16 * sizeof(MCRegisterClass),
641 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 16 * sizeof(MCRegisterClass),
642 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 16 * sizeof(MCRegisterClass),
643 .LaneMask: LaneBitmask(0x0000000000000003),
644 .AllocationPriority: 0,
645 .GlobalPriority: false,
646 .TSFlags: 0x00, /* TSFlags */
647 .SpillStackID: 0, /* SpillStackID */
648 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
649 .CoveredBySubRegs: true, /* CoveredBySubRegs */
650 offsetof(AVRRegisterClassStorage, SuperClasses[29]) - 16 * sizeof(MCRegisterClass),
651 .SuperClassesSize: 3
652 },
653 {
654 offsetof(AVRRegisterClassStorage, Regs[272]) - 17 * sizeof(MCRegisterClass),
655 offsetof(AVRRegisterClassStorage, BitSets[42]) - 17 * sizeof(MCRegisterClass),
656 .NameIdx: 168,
657 .RegSizeInBits: 16,
658 .RegsSize: 8,
659 .RegSetBegin: 49, /* MinRegVal */
660 .RegSetSize: 13, /* RegSetSize */
661 .ID: AVR::DLDREGSRegClassID,
662 .CopyCost: 1, /* CopyCost */
663 .Allocatable: true, /* Allocatable */
664 .BaseClass: false,
665 offsetof(AVRRegisterClassStorage, SubClassMasks[34]) - 17 * sizeof(MCRegisterClass),
666 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 17 * sizeof(MCRegisterClass),
667 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 17 * sizeof(MCRegisterClass),
668 .LaneMask: LaneBitmask(0x0000000000000003),
669 .AllocationPriority: 0,
670 .GlobalPriority: false,
671 .TSFlags: 0x00, /* TSFlags */
672 .SpillStackID: 0, /* SpillStackID */
673 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
674 .CoveredBySubRegs: true, /* CoveredBySubRegs */
675 offsetof(AVRRegisterClassStorage, SuperClasses[32]) - 17 * sizeof(MCRegisterClass),
676 .SuperClassesSize: 4
677 },
678 {
679 offsetof(AVRRegisterClassStorage, Regs[280]) - 18 * sizeof(MCRegisterClass),
680 offsetof(AVRRegisterClassStorage, BitSets[44]) - 18 * sizeof(MCRegisterClass),
681 .NameIdx: 315,
682 .RegSizeInBits: 16,
683 .RegsSize: 8,
684 .RegSetBegin: 48, /* MinRegVal */
685 .RegSetSize: 8, /* RegSetSize */
686 .ID: AVR::DREGS_with_sub_hi_in_LD8loRegClassID,
687 .CopyCost: 1, /* CopyCost */
688 .Allocatable: true, /* Allocatable */
689 .BaseClass: false,
690 offsetof(AVRRegisterClassStorage, SubClassMasks[36]) - 18 * sizeof(MCRegisterClass),
691 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 18 * sizeof(MCRegisterClass),
692 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 18 * sizeof(MCRegisterClass),
693 .LaneMask: LaneBitmask(0x0000000000000003),
694 .AllocationPriority: 0,
695 .GlobalPriority: false,
696 .TSFlags: 0x00, /* TSFlags */
697 .SpillStackID: 0, /* SpillStackID */
698 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
699 .CoveredBySubRegs: true, /* CoveredBySubRegs */
700 offsetof(AVRRegisterClassStorage, SuperClasses[36]) - 18 * sizeof(MCRegisterClass),
701 .SuperClassesSize: 4
702 },
703 {
704 offsetof(AVRRegisterClassStorage, Regs[288]) - 19 * sizeof(MCRegisterClass),
705 offsetof(AVRRegisterClassStorage, BitSets[45]) - 19 * sizeof(MCRegisterClass),
706 .NameIdx: 342,
707 .RegSizeInBits: 16,
708 .RegsSize: 8,
709 .RegSetBegin: 49, /* MinRegVal */
710 .RegSetSize: 8, /* RegSetSize */
711 .ID: AVR::DREGS_with_sub_lo_in_LD8loRegClassID,
712 .CopyCost: 1, /* CopyCost */
713 .Allocatable: true, /* Allocatable */
714 .BaseClass: false,
715 offsetof(AVRRegisterClassStorage, SubClassMasks[38]) - 19 * sizeof(MCRegisterClass),
716 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 19 * sizeof(MCRegisterClass),
717 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 19 * sizeof(MCRegisterClass),
718 .LaneMask: LaneBitmask(0x0000000000000003),
719 .AllocationPriority: 0,
720 .GlobalPriority: false,
721 .TSFlags: 0x00, /* TSFlags */
722 .SpillStackID: 0, /* SpillStackID */
723 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
724 .CoveredBySubRegs: true, /* CoveredBySubRegs */
725 offsetof(AVRRegisterClassStorage, SuperClasses[40]) - 19 * sizeof(MCRegisterClass),
726 .SuperClassesSize: 6
727 },
728 {
729 offsetof(AVRRegisterClassStorage, Regs[296]) - 20 * sizeof(MCRegisterClass),
730 offsetof(AVRRegisterClassStorage, BitSets[46]) - 20 * sizeof(MCRegisterClass),
731 .NameIdx: 454,
732 .RegSizeInBits: 16,
733 .RegsSize: 8,
734 .RegSetBegin: 37, /* MinRegVal */
735 .RegSetSize: 11, /* RegSetSize */
736 .ID: AVR::DREGSloRegClassID,
737 .CopyCost: 1, /* CopyCost */
738 .Allocatable: true, /* Allocatable */
739 .BaseClass: false,
740 offsetof(AVRRegisterClassStorage, SubClassMasks[40]) - 20 * sizeof(MCRegisterClass),
741 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 20 * sizeof(MCRegisterClass),
742 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 20 * sizeof(MCRegisterClass),
743 .LaneMask: LaneBitmask(0x0000000000000003),
744 .AllocationPriority: 0,
745 .GlobalPriority: false,
746 .TSFlags: 0x00, /* TSFlags */
747 .SpillStackID: 0, /* SpillStackID */
748 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
749 .CoveredBySubRegs: true, /* CoveredBySubRegs */
750 offsetof(AVRRegisterClassStorage, SuperClasses[46]) - 20 * sizeof(MCRegisterClass),
751 .SuperClassesSize: 6
752 },
753 {
754 offsetof(AVRRegisterClassStorage, Regs[304]) - 21 * sizeof(MCRegisterClass),
755 offsetof(AVRRegisterClassStorage, BitSets[48]) - 21 * sizeof(MCRegisterClass),
756 .NameIdx: 260,
757 .RegSizeInBits: 16,
758 .RegsSize: 7,
759 .RegSetBegin: 49, /* MinRegVal */
760 .RegSetSize: 12, /* RegSetSize */
761 .ID: AVR::DLDREGS_and_DREGSNOZRegClassID,
762 .CopyCost: 1, /* CopyCost */
763 .Allocatable: true, /* Allocatable */
764 .BaseClass: false,
765 offsetof(AVRRegisterClassStorage, SubClassMasks[42]) - 21 * sizeof(MCRegisterClass),
766 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 21 * sizeof(MCRegisterClass),
767 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 21 * sizeof(MCRegisterClass),
768 .LaneMask: LaneBitmask(0x0000000000000003),
769 .AllocationPriority: 0,
770 .GlobalPriority: false,
771 .TSFlags: 0x00, /* TSFlags */
772 .SpillStackID: 0, /* SpillStackID */
773 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
774 .CoveredBySubRegs: true, /* CoveredBySubRegs */
775 offsetof(AVRRegisterClassStorage, SuperClasses[52]) - 21 * sizeof(MCRegisterClass),
776 .SuperClassesSize: 9
777 },
778 {
779 offsetof(AVRRegisterClassStorage, Regs[311]) - 22 * sizeof(MCRegisterClass),
780 offsetof(AVRRegisterClassStorage, BitSets[50]) - 22 * sizeof(MCRegisterClass),
781 .NameIdx: 92,
782 .RegSizeInBits: 16,
783 .RegsSize: 7,
784 .RegSetBegin: 49, /* MinRegVal */
785 .RegSetSize: 7, /* RegSetSize */
786 .ID: AVR::DREGS_with_sub_hi_in_LD8lo_and_DREGS_with_sub_lo_in_LD8RegClassID,
787 .CopyCost: 1, /* CopyCost */
788 .Allocatable: true, /* Allocatable */
789 .BaseClass: false,
790 offsetof(AVRRegisterClassStorage, SubClassMasks[44]) - 22 * sizeof(MCRegisterClass),
791 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 22 * sizeof(MCRegisterClass),
792 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 22 * sizeof(MCRegisterClass),
793 .LaneMask: LaneBitmask(0x0000000000000003),
794 .AllocationPriority: 0,
795 .GlobalPriority: false,
796 .TSFlags: 0x00, /* TSFlags */
797 .SpillStackID: 0, /* SpillStackID */
798 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
799 .CoveredBySubRegs: true, /* CoveredBySubRegs */
800 offsetof(AVRRegisterClassStorage, SuperClasses[61]) - 22 * sizeof(MCRegisterClass),
801 .SuperClassesSize: 8
802 },
803 {
804 offsetof(AVRRegisterClassStorage, Regs[318]) - 23 * sizeof(MCRegisterClass),
805 offsetof(AVRRegisterClassStorage, BitSets[51]) - 23 * sizeof(MCRegisterClass),
806 .NameIdx: 304,
807 .RegSizeInBits: 16,
808 .RegsSize: 4,
809 .RegSetBegin: 49, /* MinRegVal */
810 .RegSetSize: 7, /* RegSetSize */
811 .ID: AVR::DREGSLD8loRegClassID,
812 .CopyCost: 1, /* CopyCost */
813 .Allocatable: true, /* Allocatable */
814 .BaseClass: false,
815 offsetof(AVRRegisterClassStorage, SubClassMasks[46]) - 23 * sizeof(MCRegisterClass),
816 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 23 * sizeof(MCRegisterClass),
817 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 23 * sizeof(MCRegisterClass),
818 .LaneMask: LaneBitmask(0x0000000000000003),
819 .AllocationPriority: 0,
820 .GlobalPriority: false,
821 .TSFlags: 0x00, /* TSFlags */
822 .SpillStackID: 0, /* SpillStackID */
823 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
824 .CoveredBySubRegs: true, /* CoveredBySubRegs */
825 offsetof(AVRRegisterClassStorage, SuperClasses[69]) - 23 * sizeof(MCRegisterClass),
826 .SuperClassesSize: 13
827 },
828 {
829 offsetof(AVRRegisterClassStorage, Regs[322]) - 24 * sizeof(MCRegisterClass),
830 offsetof(AVRRegisterClassStorage, BitSets[52]) - 24 * sizeof(MCRegisterClass),
831 .NameIdx: 235,
832 .RegSizeInBits: 16,
833 .RegsSize: 4,
834 .RegSetBegin: 57, /* MinRegVal */
835 .RegSetSize: 5, /* RegSetSize */
836 .ID: AVR::IWREGSRegClassID,
837 .CopyCost: 1, /* CopyCost */
838 .Allocatable: true, /* Allocatable */
839 .BaseClass: false,
840 offsetof(AVRRegisterClassStorage, SubClassMasks[48]) - 24 * sizeof(MCRegisterClass),
841 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 24 * sizeof(MCRegisterClass),
842 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 24 * sizeof(MCRegisterClass),
843 .LaneMask: LaneBitmask(0x0000000000000003),
844 .AllocationPriority: 0,
845 .GlobalPriority: false,
846 .TSFlags: 0x00, /* TSFlags */
847 .SpillStackID: 0, /* SpillStackID */
848 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
849 .CoveredBySubRegs: true, /* CoveredBySubRegs */
850 offsetof(AVRRegisterClassStorage, SuperClasses[82]) - 24 * sizeof(MCRegisterClass),
851 .SuperClassesSize: 5
852 },
853 {
854 offsetof(AVRRegisterClassStorage, Regs[326]) - 25 * sizeof(MCRegisterClass),
855 offsetof(AVRRegisterClassStorage, BitSets[53]) - 25 * sizeof(MCRegisterClass),
856 .NameIdx: 222,
857 .RegSizeInBits: 16,
858 .RegsSize: 3,
859 .RegSetBegin: 57, /* MinRegVal */
860 .RegSetSize: 4, /* RegSetSize */
861 .ID: AVR::DREGSNOZ_and_IWREGSRegClassID,
862 .CopyCost: 1, /* CopyCost */
863 .Allocatable: true, /* Allocatable */
864 .BaseClass: false,
865 offsetof(AVRRegisterClassStorage, SubClassMasks[50]) - 25 * sizeof(MCRegisterClass),
866 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 25 * sizeof(MCRegisterClass),
867 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 25 * sizeof(MCRegisterClass),
868 .LaneMask: LaneBitmask(0x0000000000000003),
869 .AllocationPriority: 0,
870 .GlobalPriority: false,
871 .TSFlags: 0x00, /* TSFlags */
872 .SpillStackID: 0, /* SpillStackID */
873 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
874 .CoveredBySubRegs: true, /* CoveredBySubRegs */
875 offsetof(AVRRegisterClassStorage, SuperClasses[87]) - 25 * sizeof(MCRegisterClass),
876 .SuperClassesSize: 11
877 },
878 {
879 offsetof(AVRRegisterClassStorage, Regs[329]) - 26 * sizeof(MCRegisterClass),
880 offsetof(AVRRegisterClassStorage, BitSets[54]) - 26 * sizeof(MCRegisterClass),
881 .NameIdx: 214,
882 .RegSizeInBits: 16,
883 .RegsSize: 3,
884 .RegSetBegin: 59, /* MinRegVal */
885 .RegSetSize: 3, /* RegSetSize */
886 .ID: AVR::PTRREGSRegClassID,
887 .CopyCost: 1, /* CopyCost */
888 .Allocatable: true, /* Allocatable */
889 .BaseClass: false,
890 offsetof(AVRRegisterClassStorage, SubClassMasks[52]) - 26 * sizeof(MCRegisterClass),
891 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 26 * sizeof(MCRegisterClass),
892 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 26 * sizeof(MCRegisterClass),
893 .LaneMask: LaneBitmask(0x0000000000000003),
894 .AllocationPriority: 0,
895 .GlobalPriority: false,
896 .TSFlags: 0x00, /* TSFlags */
897 .SpillStackID: 0, /* SpillStackID */
898 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
899 .CoveredBySubRegs: true, /* CoveredBySubRegs */
900 offsetof(AVRRegisterClassStorage, SuperClasses[98]) - 26 * sizeof(MCRegisterClass),
901 .SuperClassesSize: 6
902 },
903 {
904 offsetof(AVRRegisterClassStorage, Regs[332]) - 27 * sizeof(MCRegisterClass),
905 offsetof(AVRRegisterClassStorage, BitSets[55]) - 27 * sizeof(MCRegisterClass),
906 .NameIdx: 201,
907 .RegSizeInBits: 16,
908 .RegsSize: 2,
909 .RegSetBegin: 59, /* MinRegVal */
910 .RegSetSize: 2, /* RegSetSize */
911 .ID: AVR::DREGSNOZ_and_PTRREGSRegClassID,
912 .CopyCost: 1, /* CopyCost */
913 .Allocatable: true, /* Allocatable */
914 .BaseClass: false,
915 offsetof(AVRRegisterClassStorage, SubClassMasks[54]) - 27 * sizeof(MCRegisterClass),
916 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 27 * sizeof(MCRegisterClass),
917 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 27 * sizeof(MCRegisterClass),
918 .LaneMask: LaneBitmask(0x0000000000000003),
919 .AllocationPriority: 0,
920 .GlobalPriority: false,
921 .TSFlags: 0x00, /* TSFlags */
922 .SpillStackID: 0, /* SpillStackID */
923 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
924 .CoveredBySubRegs: true, /* CoveredBySubRegs */
925 offsetof(AVRRegisterClassStorage, SuperClasses[104]) - 27 * sizeof(MCRegisterClass),
926 .SuperClassesSize: 13
927 },
928 {
929 offsetof(AVRRegisterClassStorage, Regs[334]) - 28 * sizeof(MCRegisterClass),
930 offsetof(AVRRegisterClassStorage, BitSets[56]) - 28 * sizeof(MCRegisterClass),
931 .NameIdx: 189,
932 .RegSizeInBits: 16,
933 .RegsSize: 2,
934 .RegSetBegin: 60, /* MinRegVal */
935 .RegSetSize: 2, /* RegSetSize */
936 .ID: AVR::PTRDISPREGSRegClassID,
937 .CopyCost: 1, /* CopyCost */
938 .Allocatable: true, /* Allocatable */
939 .BaseClass: false,
940 offsetof(AVRRegisterClassStorage, SubClassMasks[56]) - 28 * sizeof(MCRegisterClass),
941 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 28 * sizeof(MCRegisterClass),
942 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 28 * sizeof(MCRegisterClass),
943 .LaneMask: LaneBitmask(0x0000000000000003),
944 .AllocationPriority: 0,
945 .GlobalPriority: false,
946 .TSFlags: 0x00, /* TSFlags */
947 .SpillStackID: 0, /* SpillStackID */
948 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
949 .CoveredBySubRegs: true, /* CoveredBySubRegs */
950 offsetof(AVRRegisterClassStorage, SuperClasses[117]) - 28 * sizeof(MCRegisterClass),
951 .SuperClassesSize: 7
952 },
953 {
954 offsetof(AVRRegisterClassStorage, Regs[336]) - 29 * sizeof(MCRegisterClass),
955 offsetof(AVRRegisterClassStorage, BitSets[57]) - 29 * sizeof(MCRegisterClass),
956 .NameIdx: 176,
957 .RegSizeInBits: 16,
958 .RegsSize: 1,
959 .RegSetBegin: 60, /* MinRegVal */
960 .RegSetSize: 1, /* RegSetSize */
961 .ID: AVR::DREGSNOZ_and_PTRDISPREGSRegClassID,
962 .CopyCost: 1, /* CopyCost */
963 .Allocatable: true, /* Allocatable */
964 .BaseClass: false,
965 offsetof(AVRRegisterClassStorage, SubClassMasks[58]) - 29 * sizeof(MCRegisterClass),
966 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 29 * sizeof(MCRegisterClass),
967 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 29 * sizeof(MCRegisterClass),
968 .LaneMask: LaneBitmask(0x0000000000000003),
969 .AllocationPriority: 0,
970 .GlobalPriority: false,
971 .TSFlags: 0x00, /* TSFlags */
972 .SpillStackID: 0, /* SpillStackID */
973 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
974 .CoveredBySubRegs: true, /* CoveredBySubRegs */
975 offsetof(AVRRegisterClassStorage, SuperClasses[124]) - 29 * sizeof(MCRegisterClass),
976 .SuperClassesSize: 15
977 },
978 {
979 offsetof(AVRRegisterClassStorage, Regs[337]) - 30 * sizeof(MCRegisterClass),
980 offsetof(AVRRegisterClassStorage, BitSets[58]) - 30 * sizeof(MCRegisterClass),
981 .NameIdx: 397,
982 .RegSizeInBits: 16,
983 .RegsSize: 1,
984 .RegSetBegin: 48, /* MinRegVal */
985 .RegSetSize: 1, /* RegSetSize */
986 .ID: AVR::DREGS_with_sub_hi_in_LD8_and_DREGS_with_sub_lo_in_GPR8loRegClassID,
987 .CopyCost: 1, /* CopyCost */
988 .Allocatable: true, /* Allocatable */
989 .BaseClass: false,
990 offsetof(AVRRegisterClassStorage, SubClassMasks[60]) - 30 * sizeof(MCRegisterClass),
991 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 30 * sizeof(MCRegisterClass),
992 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 30 * sizeof(MCRegisterClass),
993 .LaneMask: LaneBitmask(0x0000000000000003),
994 .AllocationPriority: 0,
995 .GlobalPriority: false,
996 .TSFlags: 0x00, /* TSFlags */
997 .SpillStackID: 0, /* SpillStackID */
998 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
999 .CoveredBySubRegs: true, /* CoveredBySubRegs */
1000 offsetof(AVRRegisterClassStorage, SuperClasses[139]) - 30 * sizeof(MCRegisterClass),
1001 .SuperClassesSize: 6
1002 },
1003 {
1004 offsetof(AVRRegisterClassStorage, Regs[338]) - 31 * sizeof(MCRegisterClass),
1005 offsetof(AVRRegisterClassStorage, BitSets[59]) - 31 * sizeof(MCRegisterClass),
1006 .NameIdx: 158,
1007 .RegSizeInBits: 16,
1008 .RegsSize: 1,
1009 .RegSetBegin: 1, /* MinRegVal */
1010 .RegSetSize: 1, /* RegSetSize */
1011 .ID: AVR::GPRSPRegClassID,
1012 .CopyCost: 1, /* CopyCost */
1013 .Allocatable: false, /* Allocatable */
1014 .BaseClass: false,
1015 offsetof(AVRRegisterClassStorage, SubClassMasks[62]) - 31 * sizeof(MCRegisterClass),
1016 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 31 * sizeof(MCRegisterClass),
1017 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 31 * sizeof(MCRegisterClass),
1018 .LaneMask: LaneBitmask(0x0000000000000003),
1019 .AllocationPriority: 0,
1020 .GlobalPriority: false,
1021 .TSFlags: 0x00, /* TSFlags */
1022 .SpillStackID: 0, /* SpillStackID */
1023 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
1024 .CoveredBySubRegs: true, /* CoveredBySubRegs */
1025 offsetof(AVRRegisterClassStorage, SuperClasses[145]) - 31 * sizeof(MCRegisterClass),
1026 .SuperClassesSize: 0
1027 },
1028 {
1029 offsetof(AVRRegisterClassStorage, Regs[339]) - 32 * sizeof(MCRegisterClass),
1030 offsetof(AVRRegisterClassStorage, BitSets[60]) - 32 * sizeof(MCRegisterClass),
1031 .NameIdx: 153,
1032 .RegSizeInBits: 16,
1033 .RegsSize: 1,
1034 .RegSetBegin: 61, /* MinRegVal */
1035 .RegSetSize: 1, /* RegSetSize */
1036 .ID: AVR::ZREGRegClassID,
1037 .CopyCost: 1, /* CopyCost */
1038 .Allocatable: true, /* Allocatable */
1039 .BaseClass: false,
1040 offsetof(AVRRegisterClassStorage, SubClassMasks[64]) - 32 * sizeof(MCRegisterClass),
1041 offsetof(AVRRegisterClassStorage, SuperRegMaskOffsets[12]) - 32 * sizeof(MCRegisterClass),
1042 offsetof(AVRRegisterClassStorage, SuperRegIdxSeqs[2]) - 32 * sizeof(MCRegisterClass),
1043 .LaneMask: LaneBitmask(0x0000000000000003),
1044 .AllocationPriority: 0,
1045 .GlobalPriority: false,
1046 .TSFlags: 0x00, /* TSFlags */
1047 .SpillStackID: 0, /* SpillStackID */
1048 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
1049 .CoveredBySubRegs: true, /* CoveredBySubRegs */
1050 offsetof(AVRRegisterClassStorage, SuperClasses[145]) - 32 * sizeof(MCRegisterClass),
1051 .SuperClassesSize: 8
1052 },
1053 },
1054 .Regs: {
1055 /* 0 */ 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,
1056 /* 32 */ AVR::R24, AVR::R25, AVR::R18, AVR::R19, AVR::R20, AVR::R21, AVR::R22, AVR::R23, 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,
1057 /* 62 */ 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,
1058 /* 78 */ 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,
1059 /* 94 */ AVR::R24, AVR::R25, AVR::R18, AVR::R19, AVR::R20, AVR::R21, AVR::R22, AVR::R23, AVR::R26, AVR::R27, AVR::R28, AVR::R29, AVR::R17, AVR::R16,
1060 /* 108 */ AVR::R23, AVR::R22, AVR::R21, AVR::R20, AVR::R19, AVR::R18, AVR::R17, AVR::R16,
1061 /* 116 */ AVR::SREG,
1062 /* 117 */ 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, AVR::R26R25, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17, AVR::R16R15, AVR::R14R13, AVR::R12R11, AVR::R10R9,
1063 /* 142 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0, AVR::R26R25, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17, AVR::R16R15, AVR::R14R13, AVR::R12R11, AVR::R10R9,
1064 /* 166 */ 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,
1065 /* 182 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0,
1066 /* 197 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R26R25, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17, AVR::R16R15,
1067 /* 211 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R26R25, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17, AVR::R16R15,
1068 /* 224 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R26R25, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17,
1069 /* 237 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R27R26, AVR::R29R28, AVR::R17R16, AVR::R26R25, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17,
1070 /* 249 */ AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0, AVR::R16R15, AVR::R14R13, AVR::R12R11, AVR::R10R9,
1071 /* 261 */ AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0, AVR::R14R13, AVR::R12R11, AVR::R10R9,
1072 /* 272 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R31R30, AVR::R27R26, AVR::R29R28, AVR::R17R16,
1073 /* 280 */ AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R17R16, AVR::R22R21, AVR::R20R19, AVR::R18R17, AVR::R16R15,
1074 /* 288 */ AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R17R16, AVR::R24R23, AVR::R22R21, AVR::R20R19, AVR::R18R17,
1075 /* 296 */ AVR::R15R14, AVR::R13R12, AVR::R11R10, AVR::R9R8, AVR::R7R6, AVR::R5R4, AVR::R3R2, AVR::R1R0,
1076 /* 304 */ AVR::R25R24, AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R27R26, AVR::R29R28, AVR::R17R16,
1077 /* 311 */ AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R17R16, AVR::R22R21, AVR::R20R19, AVR::R18R17,
1078 /* 318 */ AVR::R19R18, AVR::R21R20, AVR::R23R22, AVR::R17R16,
1079 /* 322 */ AVR::R25R24, AVR::R31R30, AVR::R27R26, AVR::R29R28,
1080 /* 326 */ AVR::R25R24, AVR::R27R26, AVR::R29R28,
1081 /* 329 */ AVR::R27R26, AVR::R29R28, AVR::R31R30,
1082 /* 332 */ AVR::R27R26, AVR::R29R28,
1083 /* 334 */ AVR::R31R30, AVR::R29R28,
1084 /* 336 */ AVR::R29R28,
1085 /* 337 */ AVR::R16R15,
1086 /* 338 */ AVR::SP,
1087 /* 339 */ AVR::R31R30,
1088 },
1089 .BitSets: {
1090 /* 0 */ 0xff, 0xff, 0xff, 0xff,
1091 /* 4 */ 0xff, 0xff, 0xff, 0x3f,
1092 /* 8 */ 0xff, 0xff,
1093 /* 10 */ 0xff, 0xff,
1094 /* 12 */ 0xff, 0x3f,
1095 /* 14 */ 0xff,
1096 /* 15 */ 0x01,
1097 /* 16 */ 0xff, 0xff, 0xff, 0x01,
1098 /* 20 */ 0xff, 0xff, 0xff,
1099 /* 23 */ 0x5f, 0x55, 0xd5, 0x01,
1100 /* 27 */ 0x5f, 0x55, 0xd5,
1101 /* 30 */ 0xff, 0x3f,
1102 /* 32 */ 0xff, 0x1f,
1103 /* 34 */ 0xff, 0x1f,
1104 /* 36 */ 0xff, 0x0f,
1105 /* 38 */ 0xff, 0x0f,
1106 /* 40 */ 0xff, 0x07,
1107 /* 42 */ 0x55, 0x1d,
1108 /* 44 */ 0xff,
1109 /* 45 */ 0xff,
1110 /* 46 */ 0x5f, 0x05,
1111 /* 48 */ 0x55, 0x0d,
1112 /* 50 */ 0x7f,
1113 /* 51 */ 0x55,
1114 /* 52 */ 0x1d,
1115 /* 53 */ 0x0d,
1116 /* 54 */ 0x07,
1117 /* 55 */ 0x03,
1118 /* 56 */ 0x03,
1119 /* 57 */ 0x01,
1120 /* 58 */ 0x01,
1121 /* 59 */ 0x01,
1122 /* 60 */ 0x01,
1123 },
1124 .SubClassMasks: {
1125 // 0 GPR8
1126 0x0000003f, 0x00000000,
1127 // 2 GPR8NOZ
1128 0x00000036, 0x00000000,
1129 // 4 GPR8lo
1130 0x00000004, 0x00000000,
1131 // 6 LD8
1132 0x00000038, 0x00000000,
1133 // 8 GPR8NOZ_and_LD8
1134 0x00000030, 0x00000000,
1135 // 10 LD8lo
1136 0x00000020, 0x00000000,
1137 // 12 CCR
1138 0x00000040, 0x00000000,
1139 // 14 DREGS
1140 0x7fffff80, 0x00000001,
1141 // 16 DREGSNOZ
1142 0x6afdd500, 0x00000000,
1143 // 18 DREGSMOVW
1144 0x3fb20600, 0x00000001,
1145 // 20 DREGSMOVW_and_DREGSNOZ
1146 0x2ab00400, 0x00000000,
1147 // 22 DREGS_with_sub_hi_in_LD8
1148 0x7fee7800, 0x00000001,
1149 // 24 DREGSNOZ_and_DREGS_with_sub_hi_in_LD8
1150 0x6aec5000, 0x00000000,
1151 // 26 DREGS_with_sub_lo_in_LD8
1152 0x3fea6000, 0x00000001,
1153 // 28 DREGSNOZ_and_DREGS_with_sub_lo_in_LD8
1154 0x2ae84000, 0x00000000,
1155 // 30 DREGS_with_sub_lo_in_GPR8lo
1156 0x40118000, 0x00000000,
1157 // 32 DREGS_with_sub_hi_in_GPR8lo
1158 0x00110000, 0x00000000,
1159 // 34 DLDREGS
1160 0x3fa20000, 0x00000001,
1161 // 36 DREGS_with_sub_hi_in_LD8lo
1162 0x40c40000, 0x00000000,
1163 // 38 DREGS_with_sub_lo_in_LD8lo
1164 0x00c80000, 0x00000000,
1165 // 40 DREGSlo
1166 0x00100000, 0x00000000,
1167 // 42 DLDREGS_and_DREGSNOZ
1168 0x2aa00000, 0x00000000,
1169 // 44 DREGS_with_sub_hi_in_LD8lo_and_DREGS_with_sub_lo_in_LD8
1170 0x00c00000, 0x00000000,
1171 // 46 DREGSLD8lo
1172 0x00800000, 0x00000000,
1173 // 48 IWREGS
1174 0x3f000000, 0x00000001,
1175 // 50 DREGSNOZ_and_IWREGS
1176 0x2a000000, 0x00000000,
1177 // 52 PTRREGS
1178 0x3c000000, 0x00000001,
1179 // 54 DREGSNOZ_and_PTRREGS
1180 0x28000000, 0x00000000,
1181 // 56 PTRDISPREGS
1182 0x30000000, 0x00000001,
1183 // 58 DREGSNOZ_and_PTRDISPREGS
1184 0x20000000, 0x00000000,
1185 // 60 DREGS_with_sub_hi_in_LD8_and_DREGS_with_sub_lo_in_GPR8lo
1186 0x40000000, 0x00000000,
1187 // 62 GPRSP
1188 0x80000000, 0x00000000,
1189 // 64 ZREG
1190 0x00000000, 0x00000001,
1191 /* 66 */ 0x7fffff80, 0x00000001,
1192 /* 68 */ 0x6afdd500, 0x00000000,
1193 /* 70 */ 0x00110000, 0x00000000,
1194 /* 72 */ 0x40118000, 0x00000000,
1195 /* 74 */ 0x7fee7800, 0x00000001,
1196 /* 76 */ 0x3fea6000, 0x00000001,
1197 /* 78 */ 0x6aec5000, 0x00000000,
1198 /* 80 */ 0x2ae84000, 0x00000000,
1199 /* 82 */ 0x40c40000, 0x00000000,
1200 /* 84 */ 0x00c80000, 0x00000000,
1201 },
1202 .SuperRegMaskOffsets: {
1203 /* 0 GPR8 */ offsetof(AVRRegisterClassStorage, SubClassMasks[66]) - 0 * sizeof(MCRegisterClass), offsetof(AVRRegisterClassStorage, SubClassMasks[66]) - 0 * sizeof(MCRegisterClass),
1204 /* 2 GPR8NOZ */ offsetof(AVRRegisterClassStorage, SubClassMasks[68]) - 1 * sizeof(MCRegisterClass), offsetof(AVRRegisterClassStorage, SubClassMasks[68]) - 1 * sizeof(MCRegisterClass),
1205 /* 4 GPR8lo */ offsetof(AVRRegisterClassStorage, SubClassMasks[70]) - 2 * sizeof(MCRegisterClass), offsetof(AVRRegisterClassStorage, SubClassMasks[72]) - 2 * sizeof(MCRegisterClass),
1206 /* 6 LD8 */ offsetof(AVRRegisterClassStorage, SubClassMasks[74]) - 3 * sizeof(MCRegisterClass), offsetof(AVRRegisterClassStorage, SubClassMasks[76]) - 3 * sizeof(MCRegisterClass),
1207 /* 8 GPR8NOZ_and_LD8 */ offsetof(AVRRegisterClassStorage, SubClassMasks[78]) - 4 * sizeof(MCRegisterClass), offsetof(AVRRegisterClassStorage, SubClassMasks[80]) - 4 * sizeof(MCRegisterClass),
1208 /* 10 LD8lo */ offsetof(AVRRegisterClassStorage, SubClassMasks[82]) - 5 * sizeof(MCRegisterClass), offsetof(AVRRegisterClassStorage, SubClassMasks[84]) - 5 * sizeof(MCRegisterClass),
1209 },
1210 .SuperRegIdxSeqs: {
1211 /* 0 */ 1, 2, 0,
1212 },
1213 .SuperClasses: {
1214 /* 0 GPR8 */
1215 /* 0 GPR8NOZ */ AVR::GPR8RegClassID,
1216 /* 1 GPR8lo */ AVR::GPR8RegClassID, AVR::GPR8NOZRegClassID,
1217 /* 3 LD8 */ AVR::GPR8RegClassID,
1218 /* 4 GPR8NOZ_and_LD8 */ AVR::GPR8RegClassID, AVR::GPR8NOZRegClassID, AVR::LD8RegClassID,
1219 /* 7 LD8lo */ AVR::GPR8RegClassID, AVR::GPR8NOZRegClassID, AVR::LD8RegClassID, AVR::GPR8NOZ_and_LD8RegClassID,
1220 /* 11 CCR */
1221 /* 11 DREGS */
1222 /* 11 DREGSNOZ */ AVR::DREGSRegClassID,
1223 /* 12 DREGSMOVW */ AVR::DREGSRegClassID,
1224 /* 13 DREGSMOVW_and_DREGSNOZ */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID,
1225 /* 16 DREGS_with_sub_hi_in_LD8 */ AVR::DREGSRegClassID,
1226 /* 17 DREGSNOZ_and_DREGS_with_sub_hi_in_LD8 */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID,
1227 /* 20 DREGS_with_sub_lo_in_LD8 */ AVR::DREGSRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID,
1228 /* 22 DREGSNOZ_and_DREGS_with_sub_lo_in_LD8 */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID,
1229 /* 27 DREGS_with_sub_lo_in_GPR8lo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID,
1230 /* 29 DREGS_with_sub_hi_in_GPR8lo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_lo_in_GPR8loRegClassID,
1231 /* 32 DLDREGS */ AVR::DREGSRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID,
1232 /* 36 DREGS_with_sub_hi_in_LD8lo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID,
1233 /* 40 DREGS_with_sub_lo_in_LD8lo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID,
1234 /* 46 DREGSlo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGSMOVW_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_lo_in_GPR8loRegClassID, AVR::DREGS_with_sub_hi_in_GPR8loRegClassID,
1235 /* 52 DLDREGS_and_DREGSNOZ */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGSMOVW_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID,
1236 /* 61 DREGS_with_sub_hi_in_LD8lo_and_DREGS_with_sub_lo_in_LD8 */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGS_with_sub_hi_in_LD8loRegClassID, AVR::DREGS_with_sub_lo_in_LD8loRegClassID,
1237 /* 69 DREGSLD8lo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGSMOVW_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::DREGS_with_sub_hi_in_LD8loRegClassID, AVR::DREGS_with_sub_lo_in_LD8loRegClassID, AVR::DLDREGS_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8lo_and_DREGS_with_sub_lo_in_LD8RegClassID,
1238 /* 82 IWREGS */ AVR::DREGSRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID,
1239 /* 87 DREGSNOZ_and_IWREGS */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGSMOVW_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::DLDREGS_and_DREGSNOZRegClassID, AVR::IWREGSRegClassID,
1240 /* 98 PTRREGS */ AVR::DREGSRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::IWREGSRegClassID,
1241 /* 104 DREGSNOZ_and_PTRREGS */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGSMOVW_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::DLDREGS_and_DREGSNOZRegClassID, AVR::IWREGSRegClassID, AVR::DREGSNOZ_and_IWREGSRegClassID, AVR::PTRREGSRegClassID,
1242 /* 117 PTRDISPREGS */ AVR::DREGSRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::IWREGSRegClassID, AVR::PTRREGSRegClassID,
1243 /* 124 DREGSNOZ_and_PTRDISPREGS */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGSMOVW_and_DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::DLDREGS_and_DREGSNOZRegClassID, AVR::IWREGSRegClassID, AVR::DREGSNOZ_and_IWREGSRegClassID, AVR::PTRREGSRegClassID, AVR::DREGSNOZ_and_PTRREGSRegClassID, AVR::PTRDISPREGSRegClassID,
1244 /* 139 DREGS_with_sub_hi_in_LD8_and_DREGS_with_sub_lo_in_GPR8lo */ AVR::DREGSRegClassID, AVR::DREGSNOZRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGSNOZ_and_DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_GPR8loRegClassID, AVR::DREGS_with_sub_hi_in_LD8loRegClassID,
1245 /* 145 GPRSP */
1246 /* 145 ZREG */ AVR::DREGSRegClassID, AVR::DREGSMOVWRegClassID, AVR::DREGS_with_sub_hi_in_LD8RegClassID, AVR::DREGS_with_sub_lo_in_LD8RegClassID, AVR::DLDREGSRegClassID, AVR::IWREGSRegClassID, AVR::PTRREGSRegClassID, AVR::PTRDISPREGSRegClassID,
1247 }
1248};
1249
1250const MCRegisterClass &getAVRMCRegisterClass(unsigned RC) {
1251 return AVRMCRegisterClassStorage.Classes[RC];
1252}
1253
1254// AVR Dwarf<->LLVM register mappings.
1255extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0Dwarf2L[] = {
1256 { .FromReg: 0U, .ToReg: AVR::R1R0 },
1257 { .FromReg: 1U, .ToReg: AVR::R1 },
1258 { .FromReg: 2U, .ToReg: AVR::R3R2 },
1259 { .FromReg: 3U, .ToReg: AVR::R3 },
1260 { .FromReg: 4U, .ToReg: AVR::R5R4 },
1261 { .FromReg: 5U, .ToReg: AVR::R5 },
1262 { .FromReg: 6U, .ToReg: AVR::R7R6 },
1263 { .FromReg: 7U, .ToReg: AVR::R7 },
1264 { .FromReg: 8U, .ToReg: AVR::R9R8 },
1265 { .FromReg: 9U, .ToReg: AVR::R10R9 },
1266 { .FromReg: 10U, .ToReg: AVR::R11R10 },
1267 { .FromReg: 11U, .ToReg: AVR::R12R11 },
1268 { .FromReg: 12U, .ToReg: AVR::R13R12 },
1269 { .FromReg: 13U, .ToReg: AVR::R14R13 },
1270 { .FromReg: 14U, .ToReg: AVR::R15R14 },
1271 { .FromReg: 15U, .ToReg: AVR::R16R15 },
1272 { .FromReg: 16U, .ToReg: AVR::R17R16 },
1273 { .FromReg: 17U, .ToReg: AVR::R18R17 },
1274 { .FromReg: 18U, .ToReg: AVR::R19R18 },
1275 { .FromReg: 19U, .ToReg: AVR::R20R19 },
1276 { .FromReg: 20U, .ToReg: AVR::R21R20 },
1277 { .FromReg: 21U, .ToReg: AVR::R22R21 },
1278 { .FromReg: 22U, .ToReg: AVR::R23R22 },
1279 { .FromReg: 23U, .ToReg: AVR::R24R23 },
1280 { .FromReg: 24U, .ToReg: AVR::R25R24 },
1281 { .FromReg: 25U, .ToReg: AVR::R26R25 },
1282 { .FromReg: 26U, .ToReg: AVR::R27R26 },
1283 { .FromReg: 27U, .ToReg: AVR::R27 },
1284 { .FromReg: 28U, .ToReg: AVR::R29R28 },
1285 { .FromReg: 29U, .ToReg: AVR::R29 },
1286 { .FromReg: 30U, .ToReg: AVR::R31R30 },
1287 { .FromReg: 31U, .ToReg: AVR::R31 },
1288 { .FromReg: 32U, .ToReg: AVR::SPL },
1289 { .FromReg: 33U, .ToReg: AVR::SPH },
1290 { .FromReg: 88U, .ToReg: AVR::SREG },
1291};
1292extern const unsigned AVRDwarfFlavour0Dwarf2LSize = std::size(AVRDwarfFlavour0Dwarf2L);
1293
1294extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0Dwarf2L[] = {
1295 { .FromReg: 0U, .ToReg: AVR::R1R0 },
1296 { .FromReg: 1U, .ToReg: AVR::R1 },
1297 { .FromReg: 2U, .ToReg: AVR::R3R2 },
1298 { .FromReg: 3U, .ToReg: AVR::R3 },
1299 { .FromReg: 4U, .ToReg: AVR::R5R4 },
1300 { .FromReg: 5U, .ToReg: AVR::R5 },
1301 { .FromReg: 6U, .ToReg: AVR::R7R6 },
1302 { .FromReg: 7U, .ToReg: AVR::R7 },
1303 { .FromReg: 8U, .ToReg: AVR::R9R8 },
1304 { .FromReg: 9U, .ToReg: AVR::R10R9 },
1305 { .FromReg: 10U, .ToReg: AVR::R11R10 },
1306 { .FromReg: 11U, .ToReg: AVR::R12R11 },
1307 { .FromReg: 12U, .ToReg: AVR::R13R12 },
1308 { .FromReg: 13U, .ToReg: AVR::R14R13 },
1309 { .FromReg: 14U, .ToReg: AVR::R15R14 },
1310 { .FromReg: 15U, .ToReg: AVR::R16R15 },
1311 { .FromReg: 16U, .ToReg: AVR::R17R16 },
1312 { .FromReg: 17U, .ToReg: AVR::R18R17 },
1313 { .FromReg: 18U, .ToReg: AVR::R19R18 },
1314 { .FromReg: 19U, .ToReg: AVR::R20R19 },
1315 { .FromReg: 20U, .ToReg: AVR::R21R20 },
1316 { .FromReg: 21U, .ToReg: AVR::R22R21 },
1317 { .FromReg: 22U, .ToReg: AVR::R23R22 },
1318 { .FromReg: 23U, .ToReg: AVR::R24R23 },
1319 { .FromReg: 24U, .ToReg: AVR::R25R24 },
1320 { .FromReg: 25U, .ToReg: AVR::R26R25 },
1321 { .FromReg: 26U, .ToReg: AVR::R27R26 },
1322 { .FromReg: 27U, .ToReg: AVR::R27 },
1323 { .FromReg: 28U, .ToReg: AVR::R29R28 },
1324 { .FromReg: 29U, .ToReg: AVR::R29 },
1325 { .FromReg: 30U, .ToReg: AVR::R31R30 },
1326 { .FromReg: 31U, .ToReg: AVR::R31 },
1327 { .FromReg: 32U, .ToReg: AVR::SPL },
1328 { .FromReg: 33U, .ToReg: AVR::SPH },
1329 { .FromReg: 88U, .ToReg: AVR::SREG },
1330};
1331extern const unsigned AVREHFlavour0Dwarf2LSize = std::size(AVREHFlavour0Dwarf2L);
1332
1333extern const MCRegisterInfo::DwarfLLVMRegPair AVRDwarfFlavour0L2Dwarf[] = {
1334 { .FromReg: AVR::SP, .ToReg: 32U },
1335 { .FromReg: AVR::SPH, .ToReg: 33U },
1336 { .FromReg: AVR::SPL, .ToReg: 32U },
1337 { .FromReg: AVR::SREG, .ToReg: 88U },
1338 { .FromReg: AVR::R0, .ToReg: 0U },
1339 { .FromReg: AVR::R1, .ToReg: 1U },
1340 { .FromReg: AVR::R2, .ToReg: 2U },
1341 { .FromReg: AVR::R3, .ToReg: 3U },
1342 { .FromReg: AVR::R4, .ToReg: 4U },
1343 { .FromReg: AVR::R5, .ToReg: 5U },
1344 { .FromReg: AVR::R6, .ToReg: 6U },
1345 { .FromReg: AVR::R7, .ToReg: 7U },
1346 { .FromReg: AVR::R8, .ToReg: 8U },
1347 { .FromReg: AVR::R9, .ToReg: 9U },
1348 { .FromReg: AVR::R10, .ToReg: 10U },
1349 { .FromReg: AVR::R11, .ToReg: 11U },
1350 { .FromReg: AVR::R12, .ToReg: 12U },
1351 { .FromReg: AVR::R13, .ToReg: 13U },
1352 { .FromReg: AVR::R14, .ToReg: 14U },
1353 { .FromReg: AVR::R15, .ToReg: 15U },
1354 { .FromReg: AVR::R16, .ToReg: 16U },
1355 { .FromReg: AVR::R17, .ToReg: 17U },
1356 { .FromReg: AVR::R18, .ToReg: 18U },
1357 { .FromReg: AVR::R19, .ToReg: 19U },
1358 { .FromReg: AVR::R20, .ToReg: 20U },
1359 { .FromReg: AVR::R21, .ToReg: 21U },
1360 { .FromReg: AVR::R22, .ToReg: 22U },
1361 { .FromReg: AVR::R23, .ToReg: 23U },
1362 { .FromReg: AVR::R24, .ToReg: 24U },
1363 { .FromReg: AVR::R25, .ToReg: 25U },
1364 { .FromReg: AVR::R26, .ToReg: 26U },
1365 { .FromReg: AVR::R27, .ToReg: 27U },
1366 { .FromReg: AVR::R28, .ToReg: 28U },
1367 { .FromReg: AVR::R29, .ToReg: 29U },
1368 { .FromReg: AVR::R30, .ToReg: 30U },
1369 { .FromReg: AVR::R31, .ToReg: 31U },
1370 { .FromReg: AVR::R1R0, .ToReg: 0U },
1371 { .FromReg: AVR::R3R2, .ToReg: 2U },
1372 { .FromReg: AVR::R5R4, .ToReg: 4U },
1373 { .FromReg: AVR::R7R6, .ToReg: 6U },
1374 { .FromReg: AVR::R9R8, .ToReg: 8U },
1375 { .FromReg: AVR::R10R9, .ToReg: 9U },
1376 { .FromReg: AVR::R11R10, .ToReg: 10U },
1377 { .FromReg: AVR::R12R11, .ToReg: 11U },
1378 { .FromReg: AVR::R13R12, .ToReg: 12U },
1379 { .FromReg: AVR::R14R13, .ToReg: 13U },
1380 { .FromReg: AVR::R15R14, .ToReg: 14U },
1381 { .FromReg: AVR::R16R15, .ToReg: 15U },
1382 { .FromReg: AVR::R17R16, .ToReg: 16U },
1383 { .FromReg: AVR::R18R17, .ToReg: 17U },
1384 { .FromReg: AVR::R19R18, .ToReg: 18U },
1385 { .FromReg: AVR::R20R19, .ToReg: 19U },
1386 { .FromReg: AVR::R21R20, .ToReg: 20U },
1387 { .FromReg: AVR::R22R21, .ToReg: 21U },
1388 { .FromReg: AVR::R23R22, .ToReg: 22U },
1389 { .FromReg: AVR::R24R23, .ToReg: 23U },
1390 { .FromReg: AVR::R25R24, .ToReg: 24U },
1391 { .FromReg: AVR::R26R25, .ToReg: 25U },
1392 { .FromReg: AVR::R27R26, .ToReg: 26U },
1393 { .FromReg: AVR::R29R28, .ToReg: 28U },
1394 { .FromReg: AVR::R31R30, .ToReg: 30U },
1395};
1396extern const unsigned AVRDwarfFlavour0L2DwarfSize = std::size(AVRDwarfFlavour0L2Dwarf);
1397
1398extern const MCRegisterInfo::DwarfLLVMRegPair AVREHFlavour0L2Dwarf[] = {
1399 { .FromReg: AVR::SP, .ToReg: 32U },
1400 { .FromReg: AVR::SPH, .ToReg: 33U },
1401 { .FromReg: AVR::SPL, .ToReg: 32U },
1402 { .FromReg: AVR::SREG, .ToReg: 88U },
1403 { .FromReg: AVR::R0, .ToReg: 0U },
1404 { .FromReg: AVR::R1, .ToReg: 1U },
1405 { .FromReg: AVR::R2, .ToReg: 2U },
1406 { .FromReg: AVR::R3, .ToReg: 3U },
1407 { .FromReg: AVR::R4, .ToReg: 4U },
1408 { .FromReg: AVR::R5, .ToReg: 5U },
1409 { .FromReg: AVR::R6, .ToReg: 6U },
1410 { .FromReg: AVR::R7, .ToReg: 7U },
1411 { .FromReg: AVR::R8, .ToReg: 8U },
1412 { .FromReg: AVR::R9, .ToReg: 9U },
1413 { .FromReg: AVR::R10, .ToReg: 10U },
1414 { .FromReg: AVR::R11, .ToReg: 11U },
1415 { .FromReg: AVR::R12, .ToReg: 12U },
1416 { .FromReg: AVR::R13, .ToReg: 13U },
1417 { .FromReg: AVR::R14, .ToReg: 14U },
1418 { .FromReg: AVR::R15, .ToReg: 15U },
1419 { .FromReg: AVR::R16, .ToReg: 16U },
1420 { .FromReg: AVR::R17, .ToReg: 17U },
1421 { .FromReg: AVR::R18, .ToReg: 18U },
1422 { .FromReg: AVR::R19, .ToReg: 19U },
1423 { .FromReg: AVR::R20, .ToReg: 20U },
1424 { .FromReg: AVR::R21, .ToReg: 21U },
1425 { .FromReg: AVR::R22, .ToReg: 22U },
1426 { .FromReg: AVR::R23, .ToReg: 23U },
1427 { .FromReg: AVR::R24, .ToReg: 24U },
1428 { .FromReg: AVR::R25, .ToReg: 25U },
1429 { .FromReg: AVR::R26, .ToReg: 26U },
1430 { .FromReg: AVR::R27, .ToReg: 27U },
1431 { .FromReg: AVR::R28, .ToReg: 28U },
1432 { .FromReg: AVR::R29, .ToReg: 29U },
1433 { .FromReg: AVR::R30, .ToReg: 30U },
1434 { .FromReg: AVR::R31, .ToReg: 31U },
1435 { .FromReg: AVR::R1R0, .ToReg: 0U },
1436 { .FromReg: AVR::R3R2, .ToReg: 2U },
1437 { .FromReg: AVR::R5R4, .ToReg: 4U },
1438 { .FromReg: AVR::R7R6, .ToReg: 6U },
1439 { .FromReg: AVR::R9R8, .ToReg: 8U },
1440 { .FromReg: AVR::R10R9, .ToReg: 9U },
1441 { .FromReg: AVR::R11R10, .ToReg: 10U },
1442 { .FromReg: AVR::R12R11, .ToReg: 11U },
1443 { .FromReg: AVR::R13R12, .ToReg: 12U },
1444 { .FromReg: AVR::R14R13, .ToReg: 13U },
1445 { .FromReg: AVR::R15R14, .ToReg: 14U },
1446 { .FromReg: AVR::R16R15, .ToReg: 15U },
1447 { .FromReg: AVR::R17R16, .ToReg: 16U },
1448 { .FromReg: AVR::R18R17, .ToReg: 17U },
1449 { .FromReg: AVR::R19R18, .ToReg: 18U },
1450 { .FromReg: AVR::R20R19, .ToReg: 19U },
1451 { .FromReg: AVR::R21R20, .ToReg: 20U },
1452 { .FromReg: AVR::R22R21, .ToReg: 21U },
1453 { .FromReg: AVR::R23R22, .ToReg: 22U },
1454 { .FromReg: AVR::R24R23, .ToReg: 23U },
1455 { .FromReg: AVR::R25R24, .ToReg: 24U },
1456 { .FromReg: AVR::R26R25, .ToReg: 25U },
1457 { .FromReg: AVR::R27R26, .ToReg: 26U },
1458 { .FromReg: AVR::R29R28, .ToReg: 28U },
1459 { .FromReg: AVR::R31R30, .ToReg: 30U },
1460};
1461extern const unsigned AVREHFlavour0L2DwarfSize = std::size(AVREHFlavour0L2Dwarf);
1462
1463extern const uint16_t AVRRegEncodingTable[] = {
1464 0,
1465 16,
1466 33,
1467 32,
1468 14,
1469 0,
1470 1,
1471 2,
1472 3,
1473 4,
1474 5,
1475 6,
1476 7,
1477 8,
1478 9,
1479 10,
1480 11,
1481 12,
1482 13,
1483 14,
1484 15,
1485 16,
1486 17,
1487 18,
1488 19,
1489 20,
1490 21,
1491 22,
1492 23,
1493 24,
1494 25,
1495 26,
1496 27,
1497 28,
1498 29,
1499 30,
1500 31,
1501 0,
1502 1,
1503 2,
1504 3,
1505 4,
1506 9,
1507 5,
1508 11,
1509 6,
1510 13,
1511 7,
1512 15,
1513 8,
1514 17,
1515 9,
1516 19,
1517 10,
1518 21,
1519 11,
1520 23,
1521 12,
1522 25,
1523 13,
1524 14,
1525 15,
1526};
1527static inline void InitAVRMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
1528 RI->InitMCRegisterInfo(D: AVRRegDesc, NR: 62, RA, PC, C: AVRMCRegisterClassStorage.Classes, NC: 33, RURoots: AVRRegUnitRoots, NRU: 35, DL: AVRRegDiffLists, RUMS: AVRLaneMaskLists, Strings: AVRRegStrings, ClassStrings: AVRRegClassStrings, SubIndices: AVRSubRegIdxLists, NumIndices: 3,
1529RET: AVRRegEncodingTable, RUI: nullptr);
1530
1531 switch (DwarfFlavour) {
1532 default:
1533 llvm_unreachable("Unknown DWARF flavour");
1534 case 0:
1535 RI->mapDwarfRegsToLLVMRegs(Map: AVRDwarfFlavour0Dwarf2L, Size: AVRDwarfFlavour0Dwarf2LSize, isEH: false);
1536 break;
1537 }
1538 switch (EHFlavour) {
1539 default:
1540 llvm_unreachable("Unknown DWARF flavour");
1541 case 0:
1542 RI->mapDwarfRegsToLLVMRegs(Map: AVREHFlavour0Dwarf2L, Size: AVREHFlavour0Dwarf2LSize, isEH: true);
1543 break;
1544 }
1545 switch (DwarfFlavour) {
1546 default:
1547 llvm_unreachable("Unknown DWARF flavour");
1548 case 0:
1549 RI->mapLLVMRegsToDwarfRegs(Map: AVRDwarfFlavour0L2Dwarf, Size: AVRDwarfFlavour0L2DwarfSize, isEH: false);
1550 break;
1551 }
1552 switch (EHFlavour) {
1553 default:
1554 llvm_unreachable("Unknown DWARF flavour");
1555 case 0:
1556 RI->mapLLVMRegsToDwarfRegs(Map: AVREHFlavour0L2Dwarf, Size: AVREHFlavour0L2DwarfSize, isEH: true);
1557 break;
1558 }
1559}
1560
1561
1562} // namespace llvm
1563