Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Target Register Enum Values *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 :
10 : #ifdef GET_REGINFO_ENUM
11 : #undef GET_REGINFO_ENUM
12 :
13 : namespace llvm {
14 :
15 : class MCRegisterClass;
16 : extern const MCRegisterClass WebAssemblyMCRegisterClasses[];
17 :
18 : namespace WebAssembly {
19 : enum {
20 : NoRegister,
21 : ARGUMENTS = 1,
22 : VALUE_STACK = 2,
23 : EXCEPT_REF_0 = 3,
24 : FP32 = 4,
25 : FP64 = 5,
26 : SP32 = 6,
27 : SP64 = 7,
28 : F32_0 = 8,
29 : F64_0 = 9,
30 : I32_0 = 10,
31 : I64_0 = 11,
32 : V128_0 = 12,
33 : NUM_TARGET_REGS // 13
34 : };
35 : } // end namespace WebAssembly
36 :
37 : // Register classes
38 :
39 : namespace WebAssembly {
40 : enum {
41 : EXCEPT_REFRegClassID = 0,
42 : I32RegClassID = 1,
43 : F32RegClassID = 2,
44 : I64RegClassID = 3,
45 : F64RegClassID = 4,
46 : V128RegClassID = 5,
47 :
48 : };
49 : } // end namespace WebAssembly
50 :
51 : } // end namespace llvm
52 :
53 : #endif // GET_REGINFO_ENUM
54 :
55 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
56 : |* *|
57 : |* MC Register Information *|
58 : |* *|
59 : |* Automatically generated file, do not edit! *|
60 : |* *|
61 : \*===----------------------------------------------------------------------===*/
62 :
63 :
64 : #ifdef GET_REGINFO_MC_DESC
65 : #undef GET_REGINFO_MC_DESC
66 :
67 : namespace llvm {
68 :
69 : extern const MCPhysReg WebAssemblyRegDiffLists[] = {
70 : /* 0 */ 65535, 0,
71 : };
72 :
73 : extern const LaneBitmask WebAssemblyLaneMaskLists[] = {
74 : /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
75 : };
76 :
77 : extern const uint16_t WebAssemblySubRegIdxLists[] = {
78 : /* 0 */ 0,
79 : };
80 :
81 : extern const MCRegisterInfo::SubRegCoveredBits WebAssemblySubRegIdxRanges[] = {
82 : { 65535, 65535 },
83 : };
84 :
85 : extern const char WebAssemblyRegStrings[] = {
86 : /* 0 */ 'F', '3', '2', '_', '0', 0,
87 : /* 6 */ 'I', '3', '2', '_', '0', 0,
88 : /* 12 */ 'F', '6', '4', '_', '0', 0,
89 : /* 18 */ 'I', '6', '4', '_', '0', 0,
90 : /* 24 */ 'V', '1', '2', '8', '_', '0', 0,
91 : /* 31 */ 'E', 'X', 'C', 'E', 'P', 'T', '_', 'R', 'E', 'F', '_', '0', 0,
92 : /* 44 */ 'F', 'P', '3', '2', 0,
93 : /* 49 */ 'S', 'P', '3', '2', 0,
94 : /* 54 */ 'F', 'P', '6', '4', 0,
95 : /* 59 */ 'S', 'P', '6', '4', 0,
96 : /* 64 */ 'V', 'A', 'L', 'U', 'E', '_', 'S', 'T', 'A', 'C', 'K', 0,
97 : /* 76 */ 'A', 'R', 'G', 'U', 'M', 'E', 'N', 'T', 'S', 0,
98 : };
99 :
100 : extern const MCRegisterDesc WebAssemblyRegDesc[] = { // Descriptors
101 : { 5, 0, 0, 0, 0, 0 },
102 : { 76, 1, 1, 0, 1, 0 },
103 : { 64, 1, 1, 0, 1, 0 },
104 : { 31, 1, 1, 0, 1, 0 },
105 : { 44, 1, 1, 0, 1, 0 },
106 : { 54, 1, 1, 0, 1, 0 },
107 : { 49, 1, 1, 0, 1, 0 },
108 : { 59, 1, 1, 0, 1, 0 },
109 : { 0, 1, 1, 0, 1, 0 },
110 : { 12, 1, 1, 0, 1, 0 },
111 : { 6, 1, 1, 0, 1, 0 },
112 : { 18, 1, 1, 0, 1, 0 },
113 : { 24, 1, 1, 0, 1, 0 },
114 : };
115 :
116 : extern const MCPhysReg WebAssemblyRegUnitRoots[][2] = {
117 : { WebAssembly::ARGUMENTS },
118 : { WebAssembly::VALUE_STACK },
119 : { WebAssembly::EXCEPT_REF_0 },
120 : { WebAssembly::FP32 },
121 : { WebAssembly::FP64 },
122 : { WebAssembly::SP32 },
123 : { WebAssembly::SP64 },
124 : { WebAssembly::F32_0 },
125 : { WebAssembly::F64_0 },
126 : { WebAssembly::I32_0 },
127 : { WebAssembly::I64_0 },
128 : { WebAssembly::V128_0 },
129 : };
130 :
131 : namespace { // Register classes...
132 : // EXCEPT_REF Register Class...
133 : const MCPhysReg EXCEPT_REF[] = {
134 : WebAssembly::EXCEPT_REF_0,
135 : };
136 :
137 : // EXCEPT_REF Bit set.
138 : const uint8_t EXCEPT_REFBits[] = {
139 : 0x08,
140 : };
141 :
142 : // I32 Register Class...
143 : const MCPhysReg I32[] = {
144 : WebAssembly::FP32, WebAssembly::SP32, WebAssembly::I32_0,
145 : };
146 :
147 : // I32 Bit set.
148 : const uint8_t I32Bits[] = {
149 : 0x50, 0x04,
150 : };
151 :
152 : // F32 Register Class...
153 : const MCPhysReg F32[] = {
154 : WebAssembly::F32_0,
155 : };
156 :
157 : // F32 Bit set.
158 : const uint8_t F32Bits[] = {
159 : 0x00, 0x01,
160 : };
161 :
162 : // I64 Register Class...
163 : const MCPhysReg I64[] = {
164 : WebAssembly::FP64, WebAssembly::SP64, WebAssembly::I64_0,
165 : };
166 :
167 : // I64 Bit set.
168 : const uint8_t I64Bits[] = {
169 : 0xa0, 0x08,
170 : };
171 :
172 : // F64 Register Class...
173 : const MCPhysReg F64[] = {
174 : WebAssembly::F64_0,
175 : };
176 :
177 : // F64 Bit set.
178 : const uint8_t F64Bits[] = {
179 : 0x00, 0x02,
180 : };
181 :
182 : // V128 Register Class...
183 : const MCPhysReg V128[] = {
184 : WebAssembly::V128_0,
185 : };
186 :
187 : // V128 Bit set.
188 : const uint8_t V128Bits[] = {
189 : 0x00, 0x10,
190 : };
191 :
192 : } // end anonymous namespace
193 :
194 : extern const char WebAssemblyRegClassStrings[] = {
195 : /* 0 */ 'F', '3', '2', 0,
196 : /* 4 */ 'I', '3', '2', 0,
197 : /* 8 */ 'F', '6', '4', 0,
198 : /* 12 */ 'I', '6', '4', 0,
199 : /* 16 */ 'V', '1', '2', '8', 0,
200 : /* 21 */ 'E', 'X', 'C', 'E', 'P', 'T', '_', 'R', 'E', 'F', 0,
201 : };
202 :
203 : extern const MCRegisterClass WebAssemblyMCRegisterClasses[] = {
204 : { EXCEPT_REF, EXCEPT_REFBits, 21, 1, sizeof(EXCEPT_REFBits), WebAssembly::EXCEPT_REFRegClassID, 1, true },
205 : { I32, I32Bits, 4, 3, sizeof(I32Bits), WebAssembly::I32RegClassID, 1, true },
206 : { F32, F32Bits, 0, 1, sizeof(F32Bits), WebAssembly::F32RegClassID, 1, true },
207 : { I64, I64Bits, 12, 3, sizeof(I64Bits), WebAssembly::I64RegClassID, 1, true },
208 : { F64, F64Bits, 8, 1, sizeof(F64Bits), WebAssembly::F64RegClassID, 1, true },
209 : { V128, V128Bits, 16, 1, sizeof(V128Bits), WebAssembly::V128RegClassID, 1, true },
210 : };
211 :
212 : extern const uint16_t WebAssemblyRegEncodingTable[] = {
213 : 0,
214 : 0,
215 : 0,
216 : 0,
217 : 0,
218 : 0,
219 : 0,
220 : 0,
221 : 0,
222 : 0,
223 : 0,
224 : 0,
225 : 0,
226 : };
227 0 : static inline void InitWebAssemblyMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
228 : RI->InitMCRegisterInfo(WebAssemblyRegDesc, 13, RA, PC, WebAssemblyMCRegisterClasses, 6, WebAssemblyRegUnitRoots, 12, WebAssemblyRegDiffLists, WebAssemblyLaneMaskLists, WebAssemblyRegStrings, WebAssemblyRegClassStrings, WebAssemblySubRegIdxLists, 1,
229 : WebAssemblySubRegIdxRanges, WebAssemblyRegEncodingTable);
230 :
231 0 : }
232 :
233 : } // end namespace llvm
234 :
235 : #endif // GET_REGINFO_MC_DESC
236 :
237 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
238 : |* *|
239 : |* Register Information Header Fragment *|
240 : |* *|
241 : |* Automatically generated file, do not edit! *|
242 : |* *|
243 : \*===----------------------------------------------------------------------===*/
244 :
245 :
246 : #ifdef GET_REGINFO_HEADER
247 : #undef GET_REGINFO_HEADER
248 :
249 : #include "llvm/CodeGen/TargetRegisterInfo.h"
250 :
251 : namespace llvm {
252 :
253 : class WebAssemblyFrameLowering;
254 :
255 : struct WebAssemblyGenRegisterInfo : public TargetRegisterInfo {
256 : explicit WebAssemblyGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0,
257 : unsigned PC = 0, unsigned HwMode = 0);
258 : const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
259 : unsigned getRegUnitWeight(unsigned RegUnit) const override;
260 : unsigned getNumRegPressureSets() const override;
261 : const char *getRegPressureSetName(unsigned Idx) const override;
262 : unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
263 : const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
264 : const int *getRegUnitPressureSets(unsigned RegUnit) const override;
265 : ArrayRef<const char *> getRegMaskNames() const override;
266 : ArrayRef<const uint32_t *> getRegMasks() const override;
267 : /// Devirtualized TargetFrameLowering.
268 : static const WebAssemblyFrameLowering *getFrameLowering(
269 : const MachineFunction &MF);
270 : };
271 :
272 : namespace WebAssembly { // Register classes
273 : extern const TargetRegisterClass EXCEPT_REFRegClass;
274 : extern const TargetRegisterClass I32RegClass;
275 : extern const TargetRegisterClass F32RegClass;
276 : extern const TargetRegisterClass I64RegClass;
277 : extern const TargetRegisterClass F64RegClass;
278 : extern const TargetRegisterClass V128RegClass;
279 : } // end namespace WebAssembly
280 :
281 : } // end namespace llvm
282 :
283 : #endif // GET_REGINFO_HEADER
284 :
285 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
286 : |* *|
287 : |* Target Register and Register Classes Information *|
288 : |* *|
289 : |* Automatically generated file, do not edit! *|
290 : |* *|
291 : \*===----------------------------------------------------------------------===*/
292 :
293 :
294 : #ifdef GET_REGINFO_TARGET_DESC
295 : #undef GET_REGINFO_TARGET_DESC
296 :
297 : namespace llvm {
298 :
299 : extern const MCRegisterClass WebAssemblyMCRegisterClasses[];
300 :
301 : static const MVT::SimpleValueType VTLists[] = {
302 : /* 0 */ MVT::i32, MVT::Other,
303 : /* 2 */ MVT::i64, MVT::Other,
304 : /* 4 */ MVT::f32, MVT::Other,
305 : /* 6 */ MVT::f64, MVT::Other,
306 : /* 8 */ MVT::v4f32, MVT::v2f64, MVT::v2i64, MVT::v4i32, MVT::v16i8, MVT::v8i16, MVT::Other,
307 : /* 15 */ MVT::ExceptRef, MVT::Other,
308 : };
309 :
310 : static const char *const SubRegIndexNameTable[] = { "" };
311 :
312 :
313 : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
314 : LaneBitmask::getAll(),
315 : };
316 :
317 :
318 :
319 : static const TargetRegisterInfo::RegClassInfo RegClassInfos[] = {
320 : // Mode = 0 (Default)
321 : { 0, 0, 0, VTLists+15 }, // EXCEPT_REF
322 : { 32, 32, 32, VTLists+0 }, // I32
323 : { 32, 32, 32, VTLists+4 }, // F32
324 : { 64, 64, 64, VTLists+2 }, // I64
325 : { 64, 64, 64, VTLists+6 }, // F64
326 : { 128, 128, 128, VTLists+8 }, // V128
327 : };
328 :
329 : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
330 :
331 : static const uint32_t EXCEPT_REFSubClassMask[] = {
332 : 0x00000001,
333 : };
334 :
335 : static const uint32_t I32SubClassMask[] = {
336 : 0x00000002,
337 : };
338 :
339 : static const uint32_t F32SubClassMask[] = {
340 : 0x00000004,
341 : };
342 :
343 : static const uint32_t I64SubClassMask[] = {
344 : 0x00000008,
345 : };
346 :
347 : static const uint32_t F64SubClassMask[] = {
348 : 0x00000010,
349 : };
350 :
351 : static const uint32_t V128SubClassMask[] = {
352 : 0x00000020,
353 : };
354 :
355 : static const uint16_t SuperRegIdxSeqs[] = {
356 : /* 0 */ 0,
357 : };
358 :
359 :
360 : namespace WebAssembly { // Register class instances
361 : extern const TargetRegisterClass EXCEPT_REFRegClass = {
362 : &WebAssemblyMCRegisterClasses[EXCEPT_REFRegClassID],
363 : EXCEPT_REFSubClassMask,
364 : SuperRegIdxSeqs + 0,
365 : LaneBitmask(0x00000001),
366 : 0,
367 : false, /* HasDisjunctSubRegs */
368 : false, /* CoveredBySubRegs */
369 : NullRegClasses,
370 : nullptr
371 : };
372 :
373 : extern const TargetRegisterClass I32RegClass = {
374 : &WebAssemblyMCRegisterClasses[I32RegClassID],
375 : I32SubClassMask,
376 : SuperRegIdxSeqs + 0,
377 : LaneBitmask(0x00000001),
378 : 0,
379 : false, /* HasDisjunctSubRegs */
380 : false, /* CoveredBySubRegs */
381 : NullRegClasses,
382 : nullptr
383 : };
384 :
385 : extern const TargetRegisterClass F32RegClass = {
386 : &WebAssemblyMCRegisterClasses[F32RegClassID],
387 : F32SubClassMask,
388 : SuperRegIdxSeqs + 0,
389 : LaneBitmask(0x00000001),
390 : 0,
391 : false, /* HasDisjunctSubRegs */
392 : false, /* CoveredBySubRegs */
393 : NullRegClasses,
394 : nullptr
395 : };
396 :
397 : extern const TargetRegisterClass I64RegClass = {
398 : &WebAssemblyMCRegisterClasses[I64RegClassID],
399 : I64SubClassMask,
400 : SuperRegIdxSeqs + 0,
401 : LaneBitmask(0x00000001),
402 : 0,
403 : false, /* HasDisjunctSubRegs */
404 : false, /* CoveredBySubRegs */
405 : NullRegClasses,
406 : nullptr
407 : };
408 :
409 : extern const TargetRegisterClass F64RegClass = {
410 : &WebAssemblyMCRegisterClasses[F64RegClassID],
411 : F64SubClassMask,
412 : SuperRegIdxSeqs + 0,
413 : LaneBitmask(0x00000001),
414 : 0,
415 : false, /* HasDisjunctSubRegs */
416 : false, /* CoveredBySubRegs */
417 : NullRegClasses,
418 : nullptr
419 : };
420 :
421 : extern const TargetRegisterClass V128RegClass = {
422 : &WebAssemblyMCRegisterClasses[V128RegClassID],
423 : V128SubClassMask,
424 : SuperRegIdxSeqs + 0,
425 : LaneBitmask(0x00000001),
426 : 0,
427 : false, /* HasDisjunctSubRegs */
428 : false, /* CoveredBySubRegs */
429 : NullRegClasses,
430 : nullptr
431 : };
432 :
433 : } // end namespace WebAssembly
434 :
435 : namespace {
436 : const TargetRegisterClass* const RegisterClasses[] = {
437 : &WebAssembly::EXCEPT_REFRegClass,
438 : &WebAssembly::I32RegClass,
439 : &WebAssembly::F32RegClass,
440 : &WebAssembly::I64RegClass,
441 : &WebAssembly::F64RegClass,
442 : &WebAssembly::V128RegClass,
443 : };
444 : } // end anonymous namespace
445 :
446 : static const TargetRegisterInfoDesc WebAssemblyRegInfoDesc[] = { // Extra Descriptors
447 : { 0, false },
448 : { 0, false },
449 : { 0, false },
450 : { 0, true },
451 : { 0, true },
452 : { 0, true },
453 : { 0, true },
454 : { 0, true },
455 : { 0, true },
456 : { 0, true },
457 : { 0, true },
458 : { 0, true },
459 : { 0, true },
460 : };
461 : /// Get the weight in units of pressure for this register class.
462 1488 : const RegClassWeight &WebAssemblyGenRegisterInfo::
463 : getRegClassWeight(const TargetRegisterClass *RC) const {
464 : static const RegClassWeight RCWeightTable[] = {
465 : {1, 1}, // EXCEPT_REF
466 : {1, 3}, // I32
467 : {1, 1}, // F32
468 : {1, 3}, // I64
469 : {1, 1}, // F64
470 : {1, 1}, // V128
471 : };
472 2976 : return RCWeightTable[RC->getID()];
473 : }
474 :
475 : /// Get the weight in units of pressure for this register unit.
476 0 : unsigned WebAssemblyGenRegisterInfo::
477 : getRegUnitWeight(unsigned RegUnit) const {
478 : assert(RegUnit < 12 && "invalid register unit");
479 : // All register units have unit weight.
480 0 : return 1;
481 : }
482 :
483 :
484 : // Get the number of dimensions of register pressure.
485 3140 : unsigned WebAssemblyGenRegisterInfo::getNumRegPressureSets() const {
486 3140 : return 6;
487 : }
488 :
489 : // Get the name of this register unit pressure set.
490 0 : const char *WebAssemblyGenRegisterInfo::
491 : getRegPressureSetName(unsigned Idx) const {
492 : static const char *const PressureNameTable[] = {
493 : "EXCEPT_REF",
494 : "F32",
495 : "F64",
496 : "V128",
497 : "I32",
498 : "I64",
499 : };
500 0 : return PressureNameTable[Idx];
501 : }
502 :
503 : // Get the register unit pressure limit for this dimension.
504 : // This limit must be adjusted dynamically for reserved registers.
505 17220 : unsigned WebAssemblyGenRegisterInfo::
506 : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
507 : static const uint8_t PressureLimitTable[] = {
508 : 1, // 0: EXCEPT_REF
509 : 1, // 1: F32
510 : 1, // 2: F64
511 : 1, // 3: V128
512 : 3, // 4: I32
513 : 3, // 5: I64
514 : };
515 17220 : return PressureLimitTable[Idx];
516 : }
517 :
518 : /// Table of pressure sets per register class or unit.
519 : static const int RCSetsTable[] = {
520 : /* 0 */ 0, -1,
521 : /* 2 */ 1, -1,
522 : /* 4 */ 2, -1,
523 : /* 6 */ 3, -1,
524 : /* 8 */ 4, -1,
525 : /* 10 */ 5, -1,
526 : };
527 :
528 : /// Get the dimensions of register pressure impacted by this register class.
529 : /// Returns a -1 terminated array of pressure set IDs
530 954 : const int* WebAssemblyGenRegisterInfo::
531 : getRegClassPressureSets(const TargetRegisterClass *RC) const {
532 : static const uint8_t RCSetStartTable[] = {
533 : 0,8,2,10,4,6,};
534 1908 : return &RCSetsTable[RCSetStartTable[RC->getID()]];
535 : }
536 :
537 : /// Get the dimensions of register pressure impacted by this register unit.
538 : /// Returns a -1 terminated array of pressure set IDs
539 0 : const int* WebAssemblyGenRegisterInfo::
540 : getRegUnitPressureSets(unsigned RegUnit) const {
541 : assert(RegUnit < 12 && "invalid register unit");
542 : static const uint8_t RUSetStartTable[] = {
543 : 1,1,0,8,10,8,10,2,4,8,10,6,};
544 0 : return &RCSetsTable[RUSetStartTable[RegUnit]];
545 : }
546 :
547 : extern const MCRegisterDesc WebAssemblyRegDesc[];
548 : extern const MCPhysReg WebAssemblyRegDiffLists[];
549 : extern const LaneBitmask WebAssemblyLaneMaskLists[];
550 : extern const char WebAssemblyRegStrings[];
551 : extern const char WebAssemblyRegClassStrings[];
552 : extern const MCPhysReg WebAssemblyRegUnitRoots[][2];
553 : extern const uint16_t WebAssemblySubRegIdxLists[];
554 : extern const MCRegisterInfo::SubRegCoveredBits WebAssemblySubRegIdxRanges[];
555 : extern const uint16_t WebAssemblyRegEncodingTable[];
556 293 : WebAssemblyGenRegisterInfo::
557 : WebAssemblyGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
558 293 : unsigned PC, unsigned HwMode)
559 : : TargetRegisterInfo(WebAssemblyRegInfoDesc, RegisterClasses, RegisterClasses+6,
560 : SubRegIndexNameTable, SubRegIndexLaneMaskTable,
561 586 : LaneBitmask(0xFFFFFFFF), RegClassInfos, HwMode) {
562 : InitMCRegisterInfo(WebAssemblyRegDesc, 13, RA, PC,
563 : WebAssemblyMCRegisterClasses, 6,
564 : WebAssemblyRegUnitRoots,
565 : 12,
566 : WebAssemblyRegDiffLists,
567 : WebAssemblyLaneMaskLists,
568 : WebAssemblyRegStrings,
569 : WebAssemblyRegClassStrings,
570 : WebAssemblySubRegIdxLists,
571 : 1,
572 : WebAssemblySubRegIdxRanges,
573 : WebAssemblyRegEncodingTable);
574 :
575 293 : }
576 :
577 :
578 :
579 9 : ArrayRef<const uint32_t *> WebAssemblyGenRegisterInfo::getRegMasks() const {
580 9 : return None;
581 : }
582 :
583 2 : ArrayRef<const char *> WebAssemblyGenRegisterInfo::getRegMaskNames() const {
584 2 : return None;
585 : }
586 :
587 : const WebAssemblyFrameLowering *
588 468 : WebAssemblyGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
589 : return static_cast<const WebAssemblyFrameLowering *>(
590 468 : MF.getSubtarget().getFrameLowering());
591 : }
592 :
593 : } // end namespace llvm
594 :
595 : #endif // GET_REGINFO_TARGET_DESC
596 :
|
