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 BPFRegDiffLists[] = {
12 /* 0 */ -12, 0,
13 /* 2 */ 12, 0,
14};
15
16extern const LaneBitmask BPFLaneMaskLists[] = {
17 /* 0 */ LaneBitmask(0x0000000000000001),
18 /* 1 */ LaneBitmask(0xFFFFFFFFFFFFFFFF),
19};
20
21extern const uint16_t BPFSubRegIdxLists[] = {
22 /* 0 */ 1,
23};
24
25
26#ifdef __GNUC__
27#pragma GCC diagnostic push
28#pragma GCC diagnostic ignored "-Woverlength-strings"
29#endif
30extern const char BPFRegStrings[] = {
31 /* 0 */ "R10\000"
32 /* 4 */ "W10\000"
33 /* 8 */ "R0\000"
34 /* 11 */ "W0\000"
35 /* 14 */ "R11\000"
36 /* 18 */ "W11\000"
37 /* 22 */ "R1\000"
38 /* 25 */ "W1\000"
39 /* 28 */ "R2\000"
40 /* 31 */ "W2\000"
41 /* 34 */ "R3\000"
42 /* 37 */ "W3\000"
43 /* 40 */ "R4\000"
44 /* 43 */ "W4\000"
45 /* 46 */ "R5\000"
46 /* 49 */ "W5\000"
47 /* 52 */ "R6\000"
48 /* 55 */ "W6\000"
49 /* 58 */ "R7\000"
50 /* 61 */ "W7\000"
51 /* 64 */ "R8\000"
52 /* 67 */ "W8\000"
53 /* 70 */ "R9\000"
54 /* 73 */ "W9\000"
55};
56#ifdef __GNUC__
57#pragma GCC diagnostic pop
58#endif
59
60extern const MCRegisterDesc BPFRegDesc[] = { // Descriptors
61 { .Name: 3, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 0, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
62 { .Name: 8, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4096, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
63 { .Name: 22, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4097, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
64 { .Name: 28, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4098, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
65 { .Name: 34, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4099, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
66 { .Name: 40, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4100, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
67 { .Name: 46, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4101, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
68 { .Name: 52, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4102, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
69 { .Name: 58, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4103, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
70 { .Name: 64, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4104, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
71 { .Name: 70, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4105, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
72 { .Name: 0, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4106, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
73 { .Name: 14, .SubRegs: 2, .SuperRegs: 1, .SubRegIndices: 0, .RegUnits: 4107, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
74 { .Name: 11, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4096, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
75 { .Name: 25, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4097, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
76 { .Name: 31, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4098, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
77 { .Name: 37, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4099, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
78 { .Name: 43, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4100, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
79 { .Name: 49, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4101, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
80 { .Name: 55, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4102, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
81 { .Name: 61, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4103, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
82 { .Name: 67, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4104, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
83 { .Name: 73, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4105, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
84 { .Name: 4, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4106, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
85 { .Name: 18, .SubRegs: 1, .SuperRegs: 0, .SubRegIndices: 1, .RegUnits: 4107, .RegUnitLaneMasks: 1, .IsConstant: 0, .IsArtificial: 0 },
86};
87
88extern const MCPhysReg BPFRegUnitRoots[][2] = {
89 { BPF::W0 },
90 { BPF::W1 },
91 { BPF::W2 },
92 { BPF::W3 },
93 { BPF::W4 },
94 { BPF::W5 },
95 { BPF::W6 },
96 { BPF::W7 },
97 { BPF::W8 },
98 { BPF::W9 },
99 { BPF::W10 },
100 { BPF::W11 },
101};
102
103// Register classes...
104
105#ifdef __GNUC__
106#pragma GCC diagnostic push
107#pragma GCC diagnostic ignored "-Woverlength-strings"
108#endif
109extern const char BPFRegClassStrings[] = {
110 /* 0 */ "GPR32\000"
111 /* 6 */ "GPR\000"
112};
113#ifdef __GNUC__
114#pragma GCC diagnostic pop
115#endif
116
117using BPFRegisterClassStorage = MCRegisterClassStorage<2, 24, 4, 3, 1, 2, 0>;
118inline constexpr MCRegisterClassStorage<2, 24, 4, 3, 1, 2, 0> BPFMCRegisterClassStorage = {
119 .Classes: {
120 {
121 offsetof(BPFRegisterClassStorage, Regs[0]) - 0 * sizeof(MCRegisterClass),
122 offsetof(BPFRegisterClassStorage, BitSets[0]) - 0 * sizeof(MCRegisterClass),
123 .NameIdx: 0,
124 .RegSizeInBits: 32,
125 .RegsSize: 12,
126 .RegSetBegin: 13, /* MinRegVal */
127 .RegSetSize: 12, /* RegSetSize */
128 .ID: BPF::GPR32RegClassID,
129 .CopyCost: 1, /* CopyCost */
130 .Allocatable: true, /* Allocatable */
131 .BaseClass: false,
132 offsetof(BPFRegisterClassStorage, SubClassMasks[0]) - 0 * sizeof(MCRegisterClass),
133 offsetof(BPFRegisterClassStorage, SuperRegMaskOffsets[0]) - 0 * sizeof(MCRegisterClass),
134 offsetof(BPFRegisterClassStorage, SuperRegIdxSeqs[0]) - 0 * sizeof(MCRegisterClass),
135 .LaneMask: LaneBitmask(0x0000000000000001),
136 .AllocationPriority: 0,
137 .GlobalPriority: false,
138 .TSFlags: 0x00, /* TSFlags */
139 .SpillStackID: 0, /* SpillStackID */
140 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
141 .CoveredBySubRegs: false, /* CoveredBySubRegs */
142 offsetof(BPFRegisterClassStorage, SuperClasses[0]) - 0 * sizeof(MCRegisterClass),
143 .SuperClassesSize: 0
144 },
145 {
146 offsetof(BPFRegisterClassStorage, Regs[12]) - 1 * sizeof(MCRegisterClass),
147 offsetof(BPFRegisterClassStorage, BitSets[2]) - 1 * sizeof(MCRegisterClass),
148 .NameIdx: 6,
149 .RegSizeInBits: 64,
150 .RegsSize: 12,
151 .RegSetBegin: 1, /* MinRegVal */
152 .RegSetSize: 12, /* RegSetSize */
153 .ID: BPF::GPRRegClassID,
154 .CopyCost: 1, /* CopyCost */
155 .Allocatable: true, /* Allocatable */
156 .BaseClass: false,
157 offsetof(BPFRegisterClassStorage, SubClassMasks[1]) - 1 * sizeof(MCRegisterClass),
158 offsetof(BPFRegisterClassStorage, SuperRegMaskOffsets[1]) - 1 * sizeof(MCRegisterClass),
159 offsetof(BPFRegisterClassStorage, SuperRegIdxSeqs[1]) - 1 * sizeof(MCRegisterClass),
160 .LaneMask: LaneBitmask(0x0000000000000001),
161 .AllocationPriority: 0,
162 .GlobalPriority: false,
163 .TSFlags: 0x00, /* TSFlags */
164 .SpillStackID: 0, /* SpillStackID */
165 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
166 .CoveredBySubRegs: false, /* CoveredBySubRegs */
167 offsetof(BPFRegisterClassStorage, SuperClasses[0]) - 1 * sizeof(MCRegisterClass),
168 .SuperClassesSize: 0
169 },
170 },
171 .Regs: {
172 /* 0 */ BPF::W1, BPF::W2, BPF::W3, BPF::W4, BPF::W5, BPF::W6, BPF::W7, BPF::W8, BPF::W9, BPF::W0, BPF::W11, BPF::W10,
173 /* 12 */ BPF::R1, BPF::R2, BPF::R3, BPF::R4, BPF::R5, BPF::R6, BPF::R7, BPF::R8, BPF::R9, BPF::R0, BPF::R11, BPF::R10,
174 },
175 .BitSets: {
176 /* 0 */ 0xff, 0x0f,
177 /* 2 */ 0xff, 0x0f,
178 },
179 .SubClassMasks: {
180 // 0 GPR32
181 0x00000001,
182 // 1 GPR
183 0x00000002,
184 /* 2 */ 0x00000002,
185 },
186 .SuperRegMaskOffsets: {
187 /* 0 GPR32 */ offsetof(BPFRegisterClassStorage, SubClassMasks[2]) - 0 * sizeof(MCRegisterClass),
188 },
189 .SuperRegIdxSeqs: {
190 /* 0 */ 1, 0,
191 },
192 .SuperClasses: {
193 /* 0 GPR32 */
194 /* 0 GPR */
195 }
196};
197
198const MCRegisterClass &getBPFMCRegisterClass(unsigned RC) {
199 return BPFMCRegisterClassStorage.Classes[RC];
200}
201
202// BPF Dwarf<->LLVM register mappings.
203extern const MCRegisterInfo::DwarfLLVMRegPair BPFDwarfFlavour0Dwarf2L[] = {
204 { .FromReg: 0U, .ToReg: BPF::W0 },
205 { .FromReg: 1U, .ToReg: BPF::W1 },
206 { .FromReg: 2U, .ToReg: BPF::W2 },
207 { .FromReg: 3U, .ToReg: BPF::W3 },
208 { .FromReg: 4U, .ToReg: BPF::W4 },
209 { .FromReg: 5U, .ToReg: BPF::W5 },
210 { .FromReg: 6U, .ToReg: BPF::W6 },
211 { .FromReg: 7U, .ToReg: BPF::W7 },
212 { .FromReg: 8U, .ToReg: BPF::W8 },
213 { .FromReg: 9U, .ToReg: BPF::W9 },
214 { .FromReg: 10U, .ToReg: BPF::W10 },
215 { .FromReg: 11U, .ToReg: BPF::W11 },
216};
217extern const unsigned BPFDwarfFlavour0Dwarf2LSize = std::size(BPFDwarfFlavour0Dwarf2L);
218
219extern const MCRegisterInfo::DwarfLLVMRegPair BPFEHFlavour0Dwarf2L[] = {
220 { .FromReg: 0U, .ToReg: BPF::W0 },
221 { .FromReg: 1U, .ToReg: BPF::W1 },
222 { .FromReg: 2U, .ToReg: BPF::W2 },
223 { .FromReg: 3U, .ToReg: BPF::W3 },
224 { .FromReg: 4U, .ToReg: BPF::W4 },
225 { .FromReg: 5U, .ToReg: BPF::W5 },
226 { .FromReg: 6U, .ToReg: BPF::W6 },
227 { .FromReg: 7U, .ToReg: BPF::W7 },
228 { .FromReg: 8U, .ToReg: BPF::W8 },
229 { .FromReg: 9U, .ToReg: BPF::W9 },
230 { .FromReg: 10U, .ToReg: BPF::W10 },
231 { .FromReg: 11U, .ToReg: BPF::W11 },
232};
233extern const unsigned BPFEHFlavour0Dwarf2LSize = std::size(BPFEHFlavour0Dwarf2L);
234
235extern const MCRegisterInfo::DwarfLLVMRegPair BPFDwarfFlavour0L2Dwarf[] = {
236 { .FromReg: BPF::R0, .ToReg: 0U },
237 { .FromReg: BPF::R1, .ToReg: 1U },
238 { .FromReg: BPF::R2, .ToReg: 2U },
239 { .FromReg: BPF::R3, .ToReg: 3U },
240 { .FromReg: BPF::R4, .ToReg: 4U },
241 { .FromReg: BPF::R5, .ToReg: 5U },
242 { .FromReg: BPF::R6, .ToReg: 6U },
243 { .FromReg: BPF::R7, .ToReg: 7U },
244 { .FromReg: BPF::R8, .ToReg: 8U },
245 { .FromReg: BPF::R9, .ToReg: 9U },
246 { .FromReg: BPF::R10, .ToReg: 10U },
247 { .FromReg: BPF::R11, .ToReg: 11U },
248 { .FromReg: BPF::W0, .ToReg: 0U },
249 { .FromReg: BPF::W1, .ToReg: 1U },
250 { .FromReg: BPF::W2, .ToReg: 2U },
251 { .FromReg: BPF::W3, .ToReg: 3U },
252 { .FromReg: BPF::W4, .ToReg: 4U },
253 { .FromReg: BPF::W5, .ToReg: 5U },
254 { .FromReg: BPF::W6, .ToReg: 6U },
255 { .FromReg: BPF::W7, .ToReg: 7U },
256 { .FromReg: BPF::W8, .ToReg: 8U },
257 { .FromReg: BPF::W9, .ToReg: 9U },
258 { .FromReg: BPF::W10, .ToReg: 10U },
259 { .FromReg: BPF::W11, .ToReg: 11U },
260};
261extern const unsigned BPFDwarfFlavour0L2DwarfSize = std::size(BPFDwarfFlavour0L2Dwarf);
262
263extern const MCRegisterInfo::DwarfLLVMRegPair BPFEHFlavour0L2Dwarf[] = {
264 { .FromReg: BPF::R0, .ToReg: 0U },
265 { .FromReg: BPF::R1, .ToReg: 1U },
266 { .FromReg: BPF::R2, .ToReg: 2U },
267 { .FromReg: BPF::R3, .ToReg: 3U },
268 { .FromReg: BPF::R4, .ToReg: 4U },
269 { .FromReg: BPF::R5, .ToReg: 5U },
270 { .FromReg: BPF::R6, .ToReg: 6U },
271 { .FromReg: BPF::R7, .ToReg: 7U },
272 { .FromReg: BPF::R8, .ToReg: 8U },
273 { .FromReg: BPF::R9, .ToReg: 9U },
274 { .FromReg: BPF::R10, .ToReg: 10U },
275 { .FromReg: BPF::R11, .ToReg: 11U },
276 { .FromReg: BPF::W0, .ToReg: 0U },
277 { .FromReg: BPF::W1, .ToReg: 1U },
278 { .FromReg: BPF::W2, .ToReg: 2U },
279 { .FromReg: BPF::W3, .ToReg: 3U },
280 { .FromReg: BPF::W4, .ToReg: 4U },
281 { .FromReg: BPF::W5, .ToReg: 5U },
282 { .FromReg: BPF::W6, .ToReg: 6U },
283 { .FromReg: BPF::W7, .ToReg: 7U },
284 { .FromReg: BPF::W8, .ToReg: 8U },
285 { .FromReg: BPF::W9, .ToReg: 9U },
286 { .FromReg: BPF::W10, .ToReg: 10U },
287 { .FromReg: BPF::W11, .ToReg: 11U },
288};
289extern const unsigned BPFEHFlavour0L2DwarfSize = std::size(BPFEHFlavour0L2Dwarf);
290
291extern const uint16_t BPFRegEncodingTable[] = {
292 0,
293 0,
294 1,
295 2,
296 3,
297 4,
298 5,
299 6,
300 7,
301 8,
302 9,
303 10,
304 11,
305 0,
306 1,
307 2,
308 3,
309 4,
310 5,
311 6,
312 7,
313 8,
314 9,
315 10,
316 11,
317};
318static inline void InitBPFMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
319 RI->InitMCRegisterInfo(D: BPFRegDesc, NR: 25, RA, PC, C: BPFMCRegisterClassStorage.Classes, NC: 2, RURoots: BPFRegUnitRoots, NRU: 12, DL: BPFRegDiffLists, RUMS: BPFLaneMaskLists, Strings: BPFRegStrings, ClassStrings: BPFRegClassStrings, SubIndices: BPFSubRegIdxLists, NumIndices: 2,
320RET: BPFRegEncodingTable, RUI: nullptr);
321
322 switch (DwarfFlavour) {
323 default:
324 llvm_unreachable("Unknown DWARF flavour");
325 case 0:
326 RI->mapDwarfRegsToLLVMRegs(Map: BPFDwarfFlavour0Dwarf2L, Size: BPFDwarfFlavour0Dwarf2LSize, isEH: false);
327 break;
328 }
329 switch (EHFlavour) {
330 default:
331 llvm_unreachable("Unknown DWARF flavour");
332 case 0:
333 RI->mapDwarfRegsToLLVMRegs(Map: BPFEHFlavour0Dwarf2L, Size: BPFEHFlavour0Dwarf2LSize, isEH: true);
334 break;
335 }
336 switch (DwarfFlavour) {
337 default:
338 llvm_unreachable("Unknown DWARF flavour");
339 case 0:
340 RI->mapLLVMRegsToDwarfRegs(Map: BPFDwarfFlavour0L2Dwarf, Size: BPFDwarfFlavour0L2DwarfSize, isEH: false);
341 break;
342 }
343 switch (EHFlavour) {
344 default:
345 llvm_unreachable("Unknown DWARF flavour");
346 case 0:
347 RI->mapLLVMRegsToDwarfRegs(Map: BPFEHFlavour0L2Dwarf, Size: BPFEHFlavour0L2DwarfSize, isEH: true);
348 break;
349 }
350}
351
352
353} // namespace llvm
354