1/*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2|* *|
3|* Target Register and Register Classes Information *|
4|* *|
5|* Automatically generated file, do not edit! *|
6|* *|
7\*===----------------------------------------------------------------------===*/
8
9namespace llvm {
10
11extern const MCRegisterClassStorage<3, 47, 13, 4, 2, 1> LanaiMCRegisterClassStorage;
12
13static const MVT::SimpleValueType LanaiVTLists[] = {
14 /* 0 */ MVT::i32, MVT::Other,
15};
16
17#ifdef __GNUC__
18#pragma GCC diagnostic push
19#pragma GCC diagnostic ignored "-Woverlength-strings"
20#endif
21static constexpr char LanaiSubRegIndexStrings[] = {
22 /* 0 */ "sub_32\000"
23};
24#ifdef __GNUC__
25#pragma GCC diagnostic pop
26#endif
27
28
29static constexpr uint32_t LanaiSubRegIndexNameOffsets[] = {
30 0,
31};
32
33static const TargetRegisterInfo::SubRegCoveredBits LanaiSubRegIdxRangeTable[] = {
34 { .Offset: 4294967295, .Size: 4294967295 },
35 { .Offset: 0, .Size: 32 }, // sub_32
36};
37
38
39static const LaneBitmask LanaiSubRegIndexLaneMaskTable[] = {
40 LaneBitmask::getAll(),
41 LaneBitmask(0x0000000000000001), // sub_32
42 };
43
44
45
46static const TargetRegisterInfo::RegClassInfo LanaiRegClassInfos[] = {
47 // Mode = 0 (DefaultMode)
48 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*LanaiVTLists+*/.VTListOffset: 0 }, // GPR
49 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*LanaiVTLists+*/.VTListOffset: 0 }, // GPR_with_sub_32
50 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*LanaiVTLists+*/.VTListOffset: 0 }, // CCR
51};
52
53static const uint8_t LanaiCostPerUseTable[] = {
540, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
55
56
57static const bool LanaiInAllocatableClassTable[] = {
58false, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, };
59
60
61static const TargetRegisterInfoDesc LanaiRegInfoDesc = { // Extra Descriptors
62.CostPerUse: LanaiCostPerUseTable, .NumCosts: 1, .InAllocatableClass: LanaiInAllocatableClassTable};
63
64unsigned LanaiGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
65 static const uint8_t Rows[1][1] = {
66 { 0, },
67 };
68
69 --IdxA; assert(IdxA < 1); (void) IdxA;
70 --IdxB; assert(IdxB < 1);
71 return Rows[0][IdxB];
72}
73
74unsigned LanaiGenRegisterInfo::reverseComposeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
75 static const uint8_t Table[1][1] = {
76 { 0, },
77 };
78
79 --IdxA; assert(IdxA < 1);
80 --IdxB; assert(IdxB < 1);
81 return Table[IdxA][IdxB];
82 }
83
84 struct MaskRolOp {
85 LaneBitmask Mask;
86 uint8_t RotateLeft;
87 };
88 static const MaskRolOp LaneMaskComposeSequences[] = {
89 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 0 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 } // Sequence 0
90 };
91 static const uint8_t CompositeSequences[] = {
92 0 // to sub_32
93 };
94
95LaneBitmask LanaiGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
96 --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
97 LaneBitmask Result;
98 for (const MaskRolOp *Ops =
99 &LaneMaskComposeSequences[CompositeSequences[IdxA]];
100 Ops->Mask.any(); ++Ops) {
101 LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
102 if (unsigned S = Ops->RotateLeft)
103 Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
104 else
105 Result |= LaneBitmask(M);
106 }
107 return Result;
108}
109
110LaneBitmask LanaiGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
111 LaneMask &= getSubRegIndexLaneMask(SubIdx: IdxA);
112 --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
113 LaneBitmask Result;
114 for (const MaskRolOp *Ops =
115 &LaneMaskComposeSequences[CompositeSequences[IdxA]];
116 Ops->Mask.any(); ++Ops) {
117 LaneBitmask::Type M = LaneMask.getAsInteger();
118 if (unsigned S = Ops->RotateLeft)
119 Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
120 else
121 Result |= LaneBitmask(M);
122 }
123 return Result;
124}
125
126const TargetRegisterClass *LanaiGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
127 static constexpr uint8_t Table[3][1] = {
128 { // GPR
129 2, // sub_32 -> GPR_with_sub_32
130 },
131 { // GPR_with_sub_32
132 2, // sub_32 -> GPR_with_sub_32
133 },
134 { // CCR
135 0, // sub_32
136 },
137
138 };
139 assert(RC && "Missing regclass");
140 if (!Idx) return RC;
141 --Idx;
142 assert(Idx < 1 && "Bad subreg");
143 unsigned TV = Table[RC->getID()][Idx];
144 return TV ? getRegClass(i: TV - 1) : nullptr;
145}const TargetRegisterClass *LanaiGenRegisterInfo::getSubRegisterClass(const TargetRegisterClass *RC, unsigned Idx) const {
146 static constexpr uint8_t Table[3][1] = {
147 { // GPR
148 1, // GPR:sub_32 -> GPR
149 },
150 { // GPR_with_sub_32
151 1, // GPR_with_sub_32:sub_32 -> GPR
152 },
153 { // CCR
154 0, // CCR:sub_32
155 },
156
157 };
158 assert(RC && "Missing regclass");
159 if (!Idx) return RC;
160 --Idx;
161 assert(Idx < 1 && "Bad subreg");
162 unsigned TV = Table[RC->getID()][Idx];
163 return TV ? getRegClass(i: TV - 1) : nullptr;
164}/// Get the weight in units of pressure for this register class.
165const RegClassWeight &LanaiGenRegisterInfo::
166getRegClassWeight(const TargetRegisterClass *RC) const {
167 static const RegClassWeight RCWeightTable[] = {
168 {.RegWeight: 1, .WeightLimit: 32}, // GPR
169 {.RegWeight: 1, .WeightLimit: 7}, // GPR_with_sub_32
170 {.RegWeight: 0, .WeightLimit: 0}, // CCR
171 };
172 return RCWeightTable[RC->getID()];
173}
174
175/// Get the weight in units of pressure for this register unit.
176unsigned LanaiGenRegisterInfo::
177getRegUnitWeight(MCRegUnit RegUnit) const {
178 assert(static_cast<unsigned>(RegUnit) < 33 && "invalid register unit");
179 // All register units have unit weight.
180 return 1;
181}
182
183
184// Get the number of dimensions of register pressure.
185unsigned LanaiGenRegisterInfo::getNumRegPressureSets() const {
186 return 2;
187}
188
189// Get the name of this register unit pressure set.
190const char *LanaiGenRegisterInfo::
191getRegPressureSetName(unsigned Idx) const {
192 static const char *PressureNameTable[] = {
193 "GPR_with_sub_32",
194 "GPR",
195 };
196 return PressureNameTable[Idx];
197}
198
199// Get the register unit pressure limit for this dimension.
200// This limit must be adjusted dynamically for reserved registers.
201unsigned LanaiGenRegisterInfo::
202getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
203 static const uint8_t PressureLimitTable[] = {
204 7, // 0: GPR_with_sub_32
205 32, // 1: GPR
206 };
207 return PressureLimitTable[Idx];
208}
209
210/// Table of pressure sets per register class or unit.
211static const int RCSetsTable[] = {
212 /* 0 */ 0, 1, -1,
213};
214
215/// Get the dimensions of register pressure impacted by this register class.
216/// Returns a -1 terminated array of pressure set IDs
217const int *LanaiGenRegisterInfo::
218getRegClassPressureSets(const TargetRegisterClass *RC) const {
219 static const uint8_t RCSetStartTable[] = {
220 1,0,2,};
221 return &RCSetsTable[RCSetStartTable[RC->getID()]];
222}
223
224/// Get the dimensions of register pressure impacted by this register unit.
225/// Returns a -1 terminated array of pressure set IDs
226const int *LanaiGenRegisterInfo::
227getRegUnitPressureSets(MCRegUnit RegUnit) const {
228 assert(static_cast<unsigned>(RegUnit) < 33 && "invalid register unit");
229 static const uint8_t RUSetStartTable[] = {
230 0,0,0,0,0,2,1,1,1,1,1,1,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,};
231 return &RCSetsTable[RUSetStartTable[static_cast<unsigned>(RegUnit)]];
232}
233
234
235// Register to minimal register class mapping
236
237const TargetRegisterClass *LanaiGenRegisterInfo::getMinimalPhysRegClass(MCRegister Reg) const {
238 static const uint16_t InvalidRegClassID = UINT16_MAX;
239
240 static const uint16_t Mapping[41] = {
241 InvalidRegClassID, // NoRegister
242 Lanai::GPR_with_sub_32RegClassID, // FP
243 Lanai::GPR_with_sub_32RegClassID, // PC
244 Lanai::GPR_with_sub_32RegClassID, // RCA
245 Lanai::GPR_with_sub_32RegClassID, // RV
246 Lanai::GPR_with_sub_32RegClassID, // SP
247 Lanai::CCRRegClassID, // SR
248 Lanai::GPRRegClassID, // R0
249 Lanai::GPRRegClassID, // R1
250 Lanai::GPRRegClassID, // R2
251 Lanai::GPRRegClassID, // R3
252 Lanai::GPRRegClassID, // R4
253 Lanai::GPRRegClassID, // R5
254 Lanai::GPRRegClassID, // R6
255 Lanai::GPRRegClassID, // R7
256 Lanai::GPRRegClassID, // R8
257 Lanai::GPRRegClassID, // R9
258 Lanai::GPRRegClassID, // R10
259 Lanai::GPRRegClassID, // R11
260 Lanai::GPRRegClassID, // R12
261 Lanai::GPRRegClassID, // R13
262 Lanai::GPRRegClassID, // R14
263 Lanai::GPRRegClassID, // R15
264 Lanai::GPRRegClassID, // R16
265 Lanai::GPRRegClassID, // R17
266 Lanai::GPRRegClassID, // R18
267 Lanai::GPRRegClassID, // R19
268 Lanai::GPRRegClassID, // R20
269 Lanai::GPRRegClassID, // R21
270 Lanai::GPRRegClassID, // R22
271 Lanai::GPRRegClassID, // R23
272 Lanai::GPRRegClassID, // R24
273 Lanai::GPRRegClassID, // R25
274 Lanai::GPRRegClassID, // R26
275 Lanai::GPRRegClassID, // R27
276 Lanai::GPRRegClassID, // R28
277 Lanai::GPRRegClassID, // R29
278 Lanai::GPRRegClassID, // R30
279 Lanai::GPRRegClassID, // R31
280 Lanai::GPR_with_sub_32RegClassID, // RR1
281 Lanai::GPR_with_sub_32RegClassID, // RR2
282 };
283
284 assert(Reg < ArrayRef(Mapping).size());
285 unsigned RCID = Mapping[Reg.id()];
286 if (RCID == InvalidRegClassID)
287 return nullptr;
288 return &LanaiMCRegisterClassStorage.Classes[RCID];
289}
290extern const MCRegisterDesc LanaiRegDesc[];
291extern const int16_t LanaiRegDiffLists[];
292extern const LaneBitmask LanaiLaneMaskLists[];
293extern const char LanaiRegStrings[];
294extern const char LanaiRegClassStrings[];
295extern const MCPhysReg LanaiRegUnitRoots[][2];
296extern const uint16_t LanaiSubRegIdxLists[];
297extern const uint16_t LanaiRegEncodingTable[];
298// Lanai Dwarf<->LLVM register mappings.
299extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0Dwarf2L[];
300extern const unsigned LanaiDwarfFlavour0Dwarf2LSize;
301
302extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0Dwarf2L[];
303extern const unsigned LanaiEHFlavour0Dwarf2LSize;
304
305extern const MCRegisterInfo::DwarfLLVMRegPair LanaiDwarfFlavour0L2Dwarf[];
306extern const unsigned LanaiDwarfFlavour0L2DwarfSize;
307
308extern const MCRegisterInfo::DwarfLLVMRegPair LanaiEHFlavour0L2Dwarf[];
309extern const unsigned LanaiEHFlavour0L2DwarfSize;
310
311
312LanaiGenRegisterInfo::
313LanaiGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
314 unsigned PC, unsigned HwMode)
315 : TargetRegisterInfo(&LanaiRegInfoDesc,
316 LanaiSubRegIndexStrings, LanaiSubRegIndexNameOffsets,
317 LanaiSubRegIdxRangeTable, LanaiSubRegIndexLaneMaskTable,
318
319 LaneBitmask(0xFFFFFFFFFFFFFFFE), LanaiRegClassInfos, LanaiVTLists, HwMode) {
320 InitMCRegisterInfo(D: LanaiRegDesc, NR: 41, RA, PC,
321 C: &getLanaiMCRegisterClass(RC: 0), NC: 3, RURoots: LanaiRegUnitRoots, NRU: 33, DL: LanaiRegDiffLists,
322 RUMS: LanaiLaneMaskLists, Strings: LanaiRegStrings, ClassStrings: LanaiRegClassStrings, SubIndices: LanaiSubRegIdxLists, NumIndices: 2,
323 RET: LanaiRegEncodingTable, RUI: nullptr);
324
325 switch (DwarfFlavour) {
326 default:
327 llvm_unreachable("Unknown DWARF flavour");
328 case 0:
329 mapDwarfRegsToLLVMRegs(Map: LanaiDwarfFlavour0Dwarf2L, Size: LanaiDwarfFlavour0Dwarf2LSize, isEH: false);
330 break;
331 }
332 switch (EHFlavour) {
333 default:
334 llvm_unreachable("Unknown DWARF flavour");
335 case 0:
336 mapDwarfRegsToLLVMRegs(Map: LanaiEHFlavour0Dwarf2L, Size: LanaiEHFlavour0Dwarf2LSize, isEH: true);
337 break;
338 }
339 switch (DwarfFlavour) {
340 default:
341 llvm_unreachable("Unknown DWARF flavour");
342 case 0:
343 mapLLVMRegsToDwarfRegs(Map: LanaiDwarfFlavour0L2Dwarf, Size: LanaiDwarfFlavour0L2DwarfSize, isEH: false);
344 break;
345 }
346 switch (EHFlavour) {
347 default:
348 llvm_unreachable("Unknown DWARF flavour");
349 case 0:
350 mapLLVMRegsToDwarfRegs(Map: LanaiEHFlavour0L2Dwarf, Size: LanaiEHFlavour0L2DwarfSize, isEH: true);
351 break;
352 }
353}
354
355static const MCPhysReg CSR_SaveList[] = { 0 };
356static const uint32_t CSR_RegMask[] = { 0x00000000, 0x00000000, };
357
358
359ArrayRef<const uint32_t *> LanaiGenRegisterInfo::getRegMasks() const {
360 static const uint32_t *const Masks[] = {
361 CSR_RegMask,
362 };
363 return ArrayRef(Masks);
364}
365
366bool LanaiGenRegisterInfo::
367isGeneralPurposeRegister(const MachineFunction &MF, MCRegister PhysReg) const {
368 return
369 false;
370}
371
372bool LanaiGenRegisterInfo::
373isGeneralPurposeRegisterClass(const TargetRegisterClass *RC) const {
374 return
375 false;
376}
377
378bool LanaiGenRegisterInfo::
379isFixedRegister(const MachineFunction &MF, MCRegister PhysReg) const {
380 return
381 false;
382}
383
384bool LanaiGenRegisterInfo::
385isArgumentRegister(const MachineFunction &MF, MCRegister PhysReg) const {
386 return
387 false;
388}
389
390bool LanaiGenRegisterInfo::
391isConstantPhysReg(MCRegister PhysReg) const {
392 return
393 false;
394}
395
396ArrayRef<const char *> LanaiGenRegisterInfo::getRegMaskNames() const {
397 static const char *Names[] = {
398 "CSR",
399 };
400 return ArrayRef(Names);
401}
402
403const LanaiFrameLowering *
404LanaiGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
405 return static_cast<const LanaiFrameLowering *>(
406 MF.getSubtarget().getFrameLowering());
407}
408
409
410} // namespace llvm
411