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 WebAssemblyRegDiffLists[] = {
12 /* 0 */ 0,
13};
14
15extern const LaneBitmask WebAssemblyLaneMaskLists[] = {
16 /* 0 */ LaneBitmask(0xFFFFFFFFFFFFFFFF),
17};
18
19extern const uint16_t WebAssemblySubRegIdxLists[] = {
20 /* 0 */
21 /* dummy */ 0
22};
23
24
25#ifdef __GNUC__
26#pragma GCC diagnostic push
27#pragma GCC diagnostic ignored "-Woverlength-strings"
28#endif
29extern const char WebAssemblyRegStrings[] = {
30 /* 0 */ "F32_0\000"
31 /* 6 */ "I32_0\000"
32 /* 12 */ "F64_0\000"
33 /* 18 */ "I64_0\000"
34 /* 24 */ "V128_0\000"
35 /* 31 */ "FUNCREF_0\000"
36 /* 41 */ "EXTERNREF_0\000"
37 /* 53 */ "EXNREF_0\000"
38 /* 62 */ "FP32\000"
39 /* 67 */ "SP32\000"
40 /* 72 */ "FP64\000"
41 /* 77 */ "SP64\000"
42 /* 82 */ "VALUE_STACK\000"
43 /* 94 */ "ARGUMENTS\000"
44};
45#ifdef __GNUC__
46#pragma GCC diagnostic pop
47#endif
48
49extern const MCRegisterDesc WebAssemblyRegDesc[] = { // Descriptors
50 { .Name: 5, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 0, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
51 { .Name: 94, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 0, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
52 { .Name: 82, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 1, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
53 { .Name: 53, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 2, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
54 { .Name: 41, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 3, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
55 { .Name: 62, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 4, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
56 { .Name: 72, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 5, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
57 { .Name: 31, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 6, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
58 { .Name: 67, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 7, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
59 { .Name: 77, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 8, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
60 { .Name: 0, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 9, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
61 { .Name: 12, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 10, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
62 { .Name: 6, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 11, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
63 { .Name: 18, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 12, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
64 { .Name: 24, .SubRegs: 0, .SuperRegs: 0, .SubRegIndices: 0, .RegUnits: 13, .RegUnitLaneMasks: 0, .IsConstant: 0, .IsArtificial: 0 },
65};
66
67extern const MCPhysReg WebAssemblyRegUnitRoots[][2] = {
68 { WebAssembly::ARGUMENTS },
69 { WebAssembly::VALUE_STACK },
70 { WebAssembly::EXNREF_0 },
71 { WebAssembly::EXTERNREF_0 },
72 { WebAssembly::FP32 },
73 { WebAssembly::FP64 },
74 { WebAssembly::FUNCREF_0 },
75 { WebAssembly::SP32 },
76 { WebAssembly::SP64 },
77 { WebAssembly::F32_0 },
78 { WebAssembly::F64_0 },
79 { WebAssembly::I32_0 },
80 { WebAssembly::I64_0 },
81 { WebAssembly::V128_0 },
82};
83
84// Register classes...
85
86#ifdef __GNUC__
87#pragma GCC diagnostic push
88#pragma GCC diagnostic ignored "-Woverlength-strings"
89#endif
90extern const char WebAssemblyRegClassStrings[] = {
91 /* 0 */ "F32\000"
92 /* 4 */ "I32\000"
93 /* 8 */ "F64\000"
94 /* 12 */ "I64\000"
95 /* 16 */ "V128\000"
96 /* 21 */ "FUNCREF\000"
97 /* 29 */ "EXTERNREF\000"
98 /* 39 */ "EXNREF\000"
99};
100#ifdef __GNUC__
101#pragma GCC diagnostic pop
102#endif
103
104using WebAssemblyRegisterClassStorage = MCRegisterClassStorage<8, 12, 8, 8, 0, 1, 0>;
105inline constexpr MCRegisterClassStorage<8, 12, 8, 8, 0, 1, 0> WebAssemblyMCRegisterClassStorage = {
106 .Classes: {
107 {
108 offsetof(WebAssemblyRegisterClassStorage, Regs[0]) - 0 * sizeof(MCRegisterClass),
109 offsetof(WebAssemblyRegisterClassStorage, BitSets[0]) - 0 * sizeof(MCRegisterClass),
110 .NameIdx: 39,
111 .RegSizeInBits: 0,
112 .RegsSize: 1,
113 .RegSetBegin: 3, /* MinRegVal */
114 .RegSetSize: 1, /* RegSetSize */
115 .ID: WebAssembly::EXNREFRegClassID,
116 .CopyCost: 1, /* CopyCost */
117 .Allocatable: true, /* Allocatable */
118 .BaseClass: false,
119 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[0]) - 0 * sizeof(MCRegisterClass),
120 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 0 * sizeof(MCRegisterClass),
121 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 0 * sizeof(MCRegisterClass),
122 .LaneMask: LaneBitmask(0x0000000000000001),
123 .AllocationPriority: 0,
124 .GlobalPriority: false,
125 .TSFlags: 0x00, /* TSFlags */
126 .SpillStackID: 0, /* SpillStackID */
127 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
128 .CoveredBySubRegs: false, /* CoveredBySubRegs */
129 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 0 * sizeof(MCRegisterClass),
130 .SuperClassesSize: 0
131 },
132 {
133 offsetof(WebAssemblyRegisterClassStorage, Regs[1]) - 1 * sizeof(MCRegisterClass),
134 offsetof(WebAssemblyRegisterClassStorage, BitSets[1]) - 1 * sizeof(MCRegisterClass),
135 .NameIdx: 29,
136 .RegSizeInBits: 0,
137 .RegsSize: 1,
138 .RegSetBegin: 4, /* MinRegVal */
139 .RegSetSize: 1, /* RegSetSize */
140 .ID: WebAssembly::EXTERNREFRegClassID,
141 .CopyCost: 1, /* CopyCost */
142 .Allocatable: true, /* Allocatable */
143 .BaseClass: false,
144 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[1]) - 1 * sizeof(MCRegisterClass),
145 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 1 * sizeof(MCRegisterClass),
146 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 1 * sizeof(MCRegisterClass),
147 .LaneMask: LaneBitmask(0x0000000000000001),
148 .AllocationPriority: 0,
149 .GlobalPriority: false,
150 .TSFlags: 0x00, /* TSFlags */
151 .SpillStackID: 0, /* SpillStackID */
152 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
153 .CoveredBySubRegs: false, /* CoveredBySubRegs */
154 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 1 * sizeof(MCRegisterClass),
155 .SuperClassesSize: 0
156 },
157 {
158 offsetof(WebAssemblyRegisterClassStorage, Regs[2]) - 2 * sizeof(MCRegisterClass),
159 offsetof(WebAssemblyRegisterClassStorage, BitSets[2]) - 2 * sizeof(MCRegisterClass),
160 .NameIdx: 21,
161 .RegSizeInBits: 0,
162 .RegsSize: 1,
163 .RegSetBegin: 7, /* MinRegVal */
164 .RegSetSize: 1, /* RegSetSize */
165 .ID: WebAssembly::FUNCREFRegClassID,
166 .CopyCost: 1, /* CopyCost */
167 .Allocatable: true, /* Allocatable */
168 .BaseClass: false,
169 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[2]) - 2 * sizeof(MCRegisterClass),
170 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 2 * sizeof(MCRegisterClass),
171 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 2 * sizeof(MCRegisterClass),
172 .LaneMask: LaneBitmask(0x0000000000000001),
173 .AllocationPriority: 0,
174 .GlobalPriority: false,
175 .TSFlags: 0x00, /* TSFlags */
176 .SpillStackID: 0, /* SpillStackID */
177 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
178 .CoveredBySubRegs: false, /* CoveredBySubRegs */
179 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 2 * sizeof(MCRegisterClass),
180 .SuperClassesSize: 0
181 },
182 {
183 offsetof(WebAssemblyRegisterClassStorage, Regs[3]) - 3 * sizeof(MCRegisterClass),
184 offsetof(WebAssemblyRegisterClassStorage, BitSets[3]) - 3 * sizeof(MCRegisterClass),
185 .NameIdx: 4,
186 .RegSizeInBits: 32,
187 .RegsSize: 3,
188 .RegSetBegin: 5, /* MinRegVal */
189 .RegSetSize: 8, /* RegSetSize */
190 .ID: WebAssembly::I32RegClassID,
191 .CopyCost: 1, /* CopyCost */
192 .Allocatable: true, /* Allocatable */
193 .BaseClass: false,
194 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[3]) - 3 * sizeof(MCRegisterClass),
195 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 3 * sizeof(MCRegisterClass),
196 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 3 * sizeof(MCRegisterClass),
197 .LaneMask: LaneBitmask(0x0000000000000001),
198 .AllocationPriority: 0,
199 .GlobalPriority: false,
200 .TSFlags: 0x00, /* TSFlags */
201 .SpillStackID: 0, /* SpillStackID */
202 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
203 .CoveredBySubRegs: false, /* CoveredBySubRegs */
204 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 3 * sizeof(MCRegisterClass),
205 .SuperClassesSize: 0
206 },
207 {
208 offsetof(WebAssemblyRegisterClassStorage, Regs[6]) - 4 * sizeof(MCRegisterClass),
209 offsetof(WebAssemblyRegisterClassStorage, BitSets[4]) - 4 * sizeof(MCRegisterClass),
210 .NameIdx: 0,
211 .RegSizeInBits: 32,
212 .RegsSize: 1,
213 .RegSetBegin: 10, /* MinRegVal */
214 .RegSetSize: 1, /* RegSetSize */
215 .ID: WebAssembly::F32RegClassID,
216 .CopyCost: 1, /* CopyCost */
217 .Allocatable: true, /* Allocatable */
218 .BaseClass: false,
219 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[4]) - 4 * sizeof(MCRegisterClass),
220 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 4 * sizeof(MCRegisterClass),
221 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 4 * sizeof(MCRegisterClass),
222 .LaneMask: LaneBitmask(0x0000000000000001),
223 .AllocationPriority: 0,
224 .GlobalPriority: false,
225 .TSFlags: 0x00, /* TSFlags */
226 .SpillStackID: 0, /* SpillStackID */
227 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
228 .CoveredBySubRegs: false, /* CoveredBySubRegs */
229 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 4 * sizeof(MCRegisterClass),
230 .SuperClassesSize: 0
231 },
232 {
233 offsetof(WebAssemblyRegisterClassStorage, Regs[7]) - 5 * sizeof(MCRegisterClass),
234 offsetof(WebAssemblyRegisterClassStorage, BitSets[5]) - 5 * sizeof(MCRegisterClass),
235 .NameIdx: 12,
236 .RegSizeInBits: 64,
237 .RegsSize: 3,
238 .RegSetBegin: 6, /* MinRegVal */
239 .RegSetSize: 8, /* RegSetSize */
240 .ID: WebAssembly::I64RegClassID,
241 .CopyCost: 1, /* CopyCost */
242 .Allocatable: true, /* Allocatable */
243 .BaseClass: false,
244 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[5]) - 5 * sizeof(MCRegisterClass),
245 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 5 * sizeof(MCRegisterClass),
246 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 5 * sizeof(MCRegisterClass),
247 .LaneMask: LaneBitmask(0x0000000000000001),
248 .AllocationPriority: 0,
249 .GlobalPriority: false,
250 .TSFlags: 0x00, /* TSFlags */
251 .SpillStackID: 0, /* SpillStackID */
252 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
253 .CoveredBySubRegs: false, /* CoveredBySubRegs */
254 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 5 * sizeof(MCRegisterClass),
255 .SuperClassesSize: 0
256 },
257 {
258 offsetof(WebAssemblyRegisterClassStorage, Regs[10]) - 6 * sizeof(MCRegisterClass),
259 offsetof(WebAssemblyRegisterClassStorage, BitSets[6]) - 6 * sizeof(MCRegisterClass),
260 .NameIdx: 8,
261 .RegSizeInBits: 64,
262 .RegsSize: 1,
263 .RegSetBegin: 11, /* MinRegVal */
264 .RegSetSize: 1, /* RegSetSize */
265 .ID: WebAssembly::F64RegClassID,
266 .CopyCost: 1, /* CopyCost */
267 .Allocatable: true, /* Allocatable */
268 .BaseClass: false,
269 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[6]) - 6 * sizeof(MCRegisterClass),
270 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 6 * sizeof(MCRegisterClass),
271 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 6 * sizeof(MCRegisterClass),
272 .LaneMask: LaneBitmask(0x0000000000000001),
273 .AllocationPriority: 0,
274 .GlobalPriority: false,
275 .TSFlags: 0x00, /* TSFlags */
276 .SpillStackID: 0, /* SpillStackID */
277 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
278 .CoveredBySubRegs: false, /* CoveredBySubRegs */
279 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 6 * sizeof(MCRegisterClass),
280 .SuperClassesSize: 0
281 },
282 {
283 offsetof(WebAssemblyRegisterClassStorage, Regs[11]) - 7 * sizeof(MCRegisterClass),
284 offsetof(WebAssemblyRegisterClassStorage, BitSets[7]) - 7 * sizeof(MCRegisterClass),
285 .NameIdx: 16,
286 .RegSizeInBits: 128,
287 .RegsSize: 1,
288 .RegSetBegin: 14, /* MinRegVal */
289 .RegSetSize: 1, /* RegSetSize */
290 .ID: WebAssembly::V128RegClassID,
291 .CopyCost: 1, /* CopyCost */
292 .Allocatable: true, /* Allocatable */
293 .BaseClass: false,
294 offsetof(WebAssemblyRegisterClassStorage, SubClassMasks[7]) - 7 * sizeof(MCRegisterClass),
295 offsetof(WebAssemblyRegisterClassStorage, SuperRegMaskOffsets[0]) - 7 * sizeof(MCRegisterClass),
296 offsetof(WebAssemblyRegisterClassStorage, SuperRegIdxSeqs[0]) - 7 * sizeof(MCRegisterClass),
297 .LaneMask: LaneBitmask(0x0000000000000001),
298 .AllocationPriority: 0,
299 .GlobalPriority: false,
300 .TSFlags: 0x00, /* TSFlags */
301 .SpillStackID: 0, /* SpillStackID */
302 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
303 .CoveredBySubRegs: false, /* CoveredBySubRegs */
304 offsetof(WebAssemblyRegisterClassStorage, SuperClasses[0]) - 7 * sizeof(MCRegisterClass),
305 .SuperClassesSize: 0
306 },
307 },
308 .Regs: {
309 /* 0 */ WebAssembly::EXNREF_0,
310 /* 1 */ WebAssembly::EXTERNREF_0,
311 /* 2 */ WebAssembly::FUNCREF_0,
312 /* 3 */ WebAssembly::FP32, WebAssembly::SP32, WebAssembly::I32_0,
313 /* 6 */ WebAssembly::F32_0,
314 /* 7 */ WebAssembly::FP64, WebAssembly::SP64, WebAssembly::I64_0,
315 /* 10 */ WebAssembly::F64_0,
316 /* 11 */ WebAssembly::V128_0,
317 },
318 .BitSets: {
319 /* 0 */ 0x01,
320 /* 1 */ 0x01,
321 /* 2 */ 0x01,
322 /* 3 */ 0x89,
323 /* 4 */ 0x01,
324 /* 5 */ 0x89,
325 /* 6 */ 0x01,
326 /* 7 */ 0x01,
327 },
328 .SubClassMasks: {
329 // 0 EXNREF
330 0x00000001,
331 // 1 EXTERNREF
332 0x00000002,
333 // 2 FUNCREF
334 0x00000004,
335 // 3 I32
336 0x00000008,
337 // 4 F32
338 0x00000010,
339 // 5 I64
340 0x00000020,
341 // 6 F64
342 0x00000040,
343 // 7 V128
344 0x00000080,
345 },
346 .SuperRegMaskOffsets: {
347 },
348 .SuperRegIdxSeqs: {
349 /* 0 */ 0,
350 },
351 .SuperClasses: {
352 /* 0 EXNREF */
353 /* 0 EXTERNREF */
354 /* 0 FUNCREF */
355 /* 0 I32 */
356 /* 0 F32 */
357 /* 0 I64 */
358 /* 0 F64 */
359 /* 0 V128 */
360 }
361};
362
363const MCRegisterClass &getWebAssemblyMCRegisterClass(unsigned RC) {
364 return WebAssemblyMCRegisterClassStorage.Classes[RC];
365}
366
367extern const uint16_t WebAssemblyRegEncodingTable[] = {
368 0,
369 0,
370 0,
371 0,
372 0,
373 0,
374 0,
375 0,
376 0,
377 0,
378 0,
379 0,
380 0,
381 0,
382 0,
383};
384static inline void InitWebAssemblyMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
385 RI->InitMCRegisterInfo(D: WebAssemblyRegDesc, NR: 15, RA, PC, C: WebAssemblyMCRegisterClassStorage.Classes, NC: 8, RURoots: WebAssemblyRegUnitRoots, NRU: 14, DL: WebAssemblyRegDiffLists, RUMS: WebAssemblyLaneMaskLists, Strings: WebAssemblyRegStrings, ClassStrings: WebAssemblyRegClassStrings, SubIndices: WebAssemblySubRegIdxLists, NumIndices: 1,
386RET: WebAssemblyRegEncodingTable, RUI: nullptr);
387
388}
389
390
391} // namespace llvm
392