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