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<21, 318, 48, 28, 22, 11, 15> SparcMCRegisterClassStorage;
12
13static const MVT::SimpleValueType SparcVTLists[] = {
14 /* 0 */ MVT::i1, MVT::Other,
15 /* 2 */ MVT::i32, MVT::Other,
16 /* 4 */ MVT::i32, MVT::i64, MVT::Other,
17 /* 7 */ MVT::f32, MVT::Other,
18 /* 9 */ MVT::f64, MVT::Other,
19 /* 11 */ MVT::f128, MVT::Other,
20 /* 13 */ MVT::v2i32, MVT::Other,
21};
22
23#ifdef __GNUC__
24#pragma GCC diagnostic push
25#pragma GCC diagnostic ignored "-Woverlength-strings"
26#endif
27static constexpr char SparcSubRegIndexStrings[] = {
28 /* 0 */ "sub_odd64\000"
29 /* 10 */ "sub_even64\000"
30 /* 21 */ "sub_odd64_then_sub_odd\000"
31 /* 44 */ "sub_odd64_then_sub_even\000"
32};
33#ifdef __GNUC__
34#pragma GCC diagnostic pop
35#endif
36
37
38static constexpr uint32_t SparcSubRegIndexNameOffsets[] = {
39 59,
40 10,
41 36,
42 0,
43 44,
44 21,
45};
46
47static const TargetRegisterInfo::SubRegCoveredBits SparcSubRegIdxRangeTable[] = {
48 { .Offset: 4294967295, .Size: 4294967295 },
49 { .Offset: 0, .Size: 32 }, // sub_even
50 { .Offset: 0, .Size: 64 }, // sub_even64
51 { .Offset: 32, .Size: 32 }, // sub_odd
52 { .Offset: 64, .Size: 64 }, // sub_odd64
53 { .Offset: 64, .Size: 32 }, // sub_odd64_then_sub_even
54 { .Offset: 96, .Size: 32 }, // sub_odd64_then_sub_odd
55 { .Offset: 4294967295, .Size: 4294967295 },
56 { .Offset: 0, .Size: 32 }, // sub_even
57 { .Offset: 0, .Size: 64 }, // sub_even64
58 { .Offset: 32, .Size: 32 }, // sub_odd
59 { .Offset: 64, .Size: 64 }, // sub_odd64
60 { .Offset: 64, .Size: 32 }, // sub_odd64_then_sub_even
61 { .Offset: 96, .Size: 32 }, // sub_odd64_then_sub_odd
62};
63
64
65static const LaneBitmask SparcSubRegIndexLaneMaskTable[] = {
66 LaneBitmask::getAll(),
67 LaneBitmask(0x0000000000000001), // sub_even
68 LaneBitmask(0x0000000000000003), // sub_even64
69 LaneBitmask(0x0000000000000002), // sub_odd
70 LaneBitmask(0x000000000000000C), // sub_odd64
71 LaneBitmask(0x0000000000000004), // sub_odd64_then_sub_even
72 LaneBitmask(0x0000000000000008), // sub_odd64_then_sub_odd
73 };
74
75
76
77static const TargetRegisterInfo::RegClassInfo SparcRegClassInfos[] = {
78 // Mode = 0 (DefaultMode)
79 { .RegSize: 1, .SpillSize: 1, .SpillAlignment: 1, /*SparcVTLists+*/.VTListOffset: 0 }, // FCCRegs
80 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 2 }, // ASRRegs
81 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 2 }, // CoprocRegs
82 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 7 }, // FPRegs
83 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 4 }, // IntRegs
84 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 4 }, // GPRIncomingArg
85 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 4 }, // GPROutgoingArg
86 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 2 }, // ICCRegs
87 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 9 }, // DFPRegs
88 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // I64Regs
89 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // PRRegs
90 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // CoprocPair
91 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // IntPair
92 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 9 }, // LowDFPRegs
93 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // I64Regs_and_GPRIncomingArg
94 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // I64Regs_and_GPROutgoingArg
95 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // IntPair_with_sub_even_in_GPRIncomingArg
96 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // IntPair_with_sub_even_in_GPROutgoingArg
97 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // PRRegs_and_ASRRegs
98 { .RegSize: 128, .SpillSize: 128, .SpillAlignment: 128, /*SparcVTLists+*/.VTListOffset: 11 }, // QFPRegs
99 { .RegSize: 128, .SpillSize: 128, .SpillAlignment: 128, /*SparcVTLists+*/.VTListOffset: 11 }, // LowQFPRegs
100 // Mode = 1 (SPARC64)
101 { .RegSize: 1, .SpillSize: 1, .SpillAlignment: 1, /*SparcVTLists+*/.VTListOffset: 0 }, // FCCRegs
102 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 2 }, // ASRRegs
103 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 2 }, // CoprocRegs
104 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 7 }, // FPRegs
105 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 4 }, // IntRegs
106 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 4 }, // GPRIncomingArg
107 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 4 }, // GPROutgoingArg
108 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*SparcVTLists+*/.VTListOffset: 2 }, // ICCRegs
109 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 9 }, // DFPRegs
110 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // I64Regs
111 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // PRRegs
112 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // CoprocPair
113 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // IntPair
114 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 9 }, // LowDFPRegs
115 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // I64Regs_and_GPRIncomingArg
116 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // I64Regs_and_GPROutgoingArg
117 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // IntPair_with_sub_even_in_GPRIncomingArg
118 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 13 }, // IntPair_with_sub_even_in_GPROutgoingArg
119 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*SparcVTLists+*/.VTListOffset: 5 }, // PRRegs_and_ASRRegs
120 { .RegSize: 128, .SpillSize: 128, .SpillAlignment: 128, /*SparcVTLists+*/.VTListOffset: 11 }, // QFPRegs
121 { .RegSize: 128, .SpillSize: 128, .SpillAlignment: 128, /*SparcVTLists+*/.VTListOffset: 11 }, // LowQFPRegs
122};
123
124static const uint8_t SparcCostPerUseTable[] = {
1250, 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, 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, 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, 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, 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, 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, };
126
127
128static const bool SparcInAllocatableClassTable[] = {
129false, true, true, true, false, false, true, false, false, true, false, true, true, false, true, true, false, true, true, true, true, true, true, true, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, 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, 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, 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, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, };
130
131
132static const TargetRegisterInfoDesc SparcRegInfoDesc = { // Extra Descriptors
133.CostPerUse: SparcCostPerUseTable, .NumCosts: 1, .InAllocatableClass: SparcInAllocatableClassTable};
134
135unsigned SparcGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
136 static const uint8_t RowMap[6] = {
137 0, 0, 0, 1, 0, 0,
138 };
139 static const uint8_t Rows[2][6] = {
140 { SP::sub_even, 0, SP::sub_odd, 0, 0, 0, },
141 { SP::sub_odd64_then_sub_even, 0, SP::sub_odd64_then_sub_odd, 0, 0, 0, },
142 };
143
144 --IdxA; assert(IdxA < 6); (void) IdxA;
145 --IdxB; assert(IdxB < 6);
146 return Rows[RowMap[IdxA]][IdxB];
147}
148
149unsigned SparcGenRegisterInfo::reverseComposeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
150 static const uint8_t Table[6][6] = {
151 { SP::sub_even, 0, SP::sub_odd, 0, 0, 0, },
152 { SP::sub_even, 0, SP::sub_odd, 0, 0, 0, },
153 { SP::sub_even, 0, SP::sub_odd, 0, 0, 0, },
154 { 0, 0, 0, 0, SP::sub_even, SP::sub_odd, },
155 { SP::sub_even, 0, SP::sub_odd, 0, 0, 0, },
156 { SP::sub_even, 0, SP::sub_odd, 0, 0, 0, },
157 };
158
159 --IdxA; assert(IdxA < 6);
160 --IdxB; assert(IdxB < 6);
161 return Table[IdxA][IdxB];
162 }
163
164 struct MaskRolOp {
165 LaneBitmask Mask;
166 uint8_t RotateLeft;
167 };
168 static const MaskRolOp LaneMaskComposeSequences[] = {
169 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 0 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 0
170 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 1 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 2
171 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 2 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 4
172 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 3 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 } // Sequence 6
173 };
174 static const uint8_t CompositeSequences[] = {
175 0, // to sub_even
176 0, // to sub_even64
177 2, // to sub_odd
178 4, // to sub_odd64
179 4, // to sub_odd64_then_sub_even
180 6 // to sub_odd64_then_sub_odd
181 };
182
183LaneBitmask SparcGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
184 --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
185 LaneBitmask Result;
186 for (const MaskRolOp *Ops =
187 &LaneMaskComposeSequences[CompositeSequences[IdxA]];
188 Ops->Mask.any(); ++Ops) {
189 LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
190 if (unsigned S = Ops->RotateLeft)
191 Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
192 else
193 Result |= LaneBitmask(M);
194 }
195 return Result;
196}
197
198LaneBitmask SparcGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
199 LaneMask &= getSubRegIndexLaneMask(SubIdx: IdxA);
200 --IdxA; assert(IdxA < 6 && "Subregister index out of bounds");
201 LaneBitmask Result;
202 for (const MaskRolOp *Ops =
203 &LaneMaskComposeSequences[CompositeSequences[IdxA]];
204 Ops->Mask.any(); ++Ops) {
205 LaneBitmask::Type M = LaneMask.getAsInteger();
206 if (unsigned S = Ops->RotateLeft)
207 Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
208 else
209 Result |= LaneBitmask(M);
210 }
211 return Result;
212}
213
214const TargetRegisterClass *SparcGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
215 static constexpr uint8_t Table[21][6] = {
216 { // FCCRegs
217 0, // sub_even
218 0, // sub_even64
219 0, // sub_odd
220 0, // sub_odd64
221 0, // sub_odd64_then_sub_even
222 0, // sub_odd64_then_sub_odd
223 },
224 { // ASRRegs
225 0, // sub_even
226 0, // sub_even64
227 0, // sub_odd
228 0, // sub_odd64
229 0, // sub_odd64_then_sub_even
230 0, // sub_odd64_then_sub_odd
231 },
232 { // CoprocRegs
233 0, // sub_even
234 0, // sub_even64
235 0, // sub_odd
236 0, // sub_odd64
237 0, // sub_odd64_then_sub_even
238 0, // sub_odd64_then_sub_odd
239 },
240 { // FPRegs
241 0, // sub_even
242 0, // sub_even64
243 0, // sub_odd
244 0, // sub_odd64
245 0, // sub_odd64_then_sub_even
246 0, // sub_odd64_then_sub_odd
247 },
248 { // IntRegs
249 0, // sub_even
250 0, // sub_even64
251 0, // sub_odd
252 0, // sub_odd64
253 0, // sub_odd64_then_sub_even
254 0, // sub_odd64_then_sub_odd
255 },
256 { // GPRIncomingArg
257 0, // sub_even
258 0, // sub_even64
259 0, // sub_odd
260 0, // sub_odd64
261 0, // sub_odd64_then_sub_even
262 0, // sub_odd64_then_sub_odd
263 },
264 { // GPROutgoingArg
265 0, // sub_even
266 0, // sub_even64
267 0, // sub_odd
268 0, // sub_odd64
269 0, // sub_odd64_then_sub_even
270 0, // sub_odd64_then_sub_odd
271 },
272 { // ICCRegs
273 0, // sub_even
274 0, // sub_even64
275 0, // sub_odd
276 0, // sub_odd64
277 0, // sub_odd64_then_sub_even
278 0, // sub_odd64_then_sub_odd
279 },
280 { // DFPRegs
281 14, // sub_even -> LowDFPRegs
282 0, // sub_even64
283 14, // sub_odd -> LowDFPRegs
284 0, // sub_odd64
285 0, // sub_odd64_then_sub_even
286 0, // sub_odd64_then_sub_odd
287 },
288 { // I64Regs
289 0, // sub_even
290 0, // sub_even64
291 0, // sub_odd
292 0, // sub_odd64
293 0, // sub_odd64_then_sub_even
294 0, // sub_odd64_then_sub_odd
295 },
296 { // PRRegs
297 0, // sub_even
298 0, // sub_even64
299 0, // sub_odd
300 0, // sub_odd64
301 0, // sub_odd64_then_sub_even
302 0, // sub_odd64_then_sub_odd
303 },
304 { // CoprocPair
305 12, // sub_even -> CoprocPair
306 0, // sub_even64
307 12, // sub_odd -> CoprocPair
308 0, // sub_odd64
309 0, // sub_odd64_then_sub_even
310 0, // sub_odd64_then_sub_odd
311 },
312 { // IntPair
313 13, // sub_even -> IntPair
314 0, // sub_even64
315 13, // sub_odd -> IntPair
316 0, // sub_odd64
317 0, // sub_odd64_then_sub_even
318 0, // sub_odd64_then_sub_odd
319 },
320 { // LowDFPRegs
321 14, // sub_even -> LowDFPRegs
322 0, // sub_even64
323 14, // sub_odd -> LowDFPRegs
324 0, // sub_odd64
325 0, // sub_odd64_then_sub_even
326 0, // sub_odd64_then_sub_odd
327 },
328 { // I64Regs_and_GPRIncomingArg
329 0, // sub_even
330 0, // sub_even64
331 0, // sub_odd
332 0, // sub_odd64
333 0, // sub_odd64_then_sub_even
334 0, // sub_odd64_then_sub_odd
335 },
336 { // I64Regs_and_GPROutgoingArg
337 0, // sub_even
338 0, // sub_even64
339 0, // sub_odd
340 0, // sub_odd64
341 0, // sub_odd64_then_sub_even
342 0, // sub_odd64_then_sub_odd
343 },
344 { // IntPair_with_sub_even_in_GPRIncomingArg
345 17, // sub_even -> IntPair_with_sub_even_in_GPRIncomingArg
346 0, // sub_even64
347 17, // sub_odd -> IntPair_with_sub_even_in_GPRIncomingArg
348 0, // sub_odd64
349 0, // sub_odd64_then_sub_even
350 0, // sub_odd64_then_sub_odd
351 },
352 { // IntPair_with_sub_even_in_GPROutgoingArg
353 18, // sub_even -> IntPair_with_sub_even_in_GPROutgoingArg
354 0, // sub_even64
355 18, // sub_odd -> IntPair_with_sub_even_in_GPROutgoingArg
356 0, // sub_odd64
357 0, // sub_odd64_then_sub_even
358 0, // sub_odd64_then_sub_odd
359 },
360 { // PRRegs_and_ASRRegs
361 0, // sub_even
362 0, // sub_even64
363 0, // sub_odd
364 0, // sub_odd64
365 0, // sub_odd64_then_sub_even
366 0, // sub_odd64_then_sub_odd
367 },
368 { // QFPRegs
369 21, // sub_even -> LowQFPRegs
370 20, // sub_even64 -> QFPRegs
371 21, // sub_odd -> LowQFPRegs
372 20, // sub_odd64 -> QFPRegs
373 21, // sub_odd64_then_sub_even -> LowQFPRegs
374 21, // sub_odd64_then_sub_odd -> LowQFPRegs
375 },
376 { // LowQFPRegs
377 21, // sub_even -> LowQFPRegs
378 21, // sub_even64 -> LowQFPRegs
379 21, // sub_odd -> LowQFPRegs
380 21, // sub_odd64 -> LowQFPRegs
381 21, // sub_odd64_then_sub_even -> LowQFPRegs
382 21, // sub_odd64_then_sub_odd -> LowQFPRegs
383 },
384
385 };
386 assert(RC && "Missing regclass");
387 if (!Idx) return RC;
388 --Idx;
389 assert(Idx < 6 && "Bad subreg");
390 unsigned TV = Table[RC->getID()][Idx];
391 return TV ? getRegClass(i: TV - 1) : nullptr;
392}const TargetRegisterClass *SparcGenRegisterInfo::getSubRegisterClass(const TargetRegisterClass *RC, unsigned Idx) const {
393 static constexpr uint8_t Table[21][6] = {
394 { // FCCRegs
395 0, // FCCRegs:sub_even
396 0, // FCCRegs:sub_even64
397 0, // FCCRegs:sub_odd
398 0, // FCCRegs:sub_odd64
399 0, // FCCRegs:sub_odd64_then_sub_even
400 0, // FCCRegs:sub_odd64_then_sub_odd
401 },
402 { // ASRRegs
403 0, // ASRRegs:sub_even
404 0, // ASRRegs:sub_even64
405 0, // ASRRegs:sub_odd
406 0, // ASRRegs:sub_odd64
407 0, // ASRRegs:sub_odd64_then_sub_even
408 0, // ASRRegs:sub_odd64_then_sub_odd
409 },
410 { // CoprocRegs
411 0, // CoprocRegs:sub_even
412 0, // CoprocRegs:sub_even64
413 0, // CoprocRegs:sub_odd
414 0, // CoprocRegs:sub_odd64
415 0, // CoprocRegs:sub_odd64_then_sub_even
416 0, // CoprocRegs:sub_odd64_then_sub_odd
417 },
418 { // FPRegs
419 0, // FPRegs:sub_even
420 0, // FPRegs:sub_even64
421 0, // FPRegs:sub_odd
422 0, // FPRegs:sub_odd64
423 0, // FPRegs:sub_odd64_then_sub_even
424 0, // FPRegs:sub_odd64_then_sub_odd
425 },
426 { // IntRegs
427 0, // IntRegs:sub_even
428 0, // IntRegs:sub_even64
429 0, // IntRegs:sub_odd
430 0, // IntRegs:sub_odd64
431 0, // IntRegs:sub_odd64_then_sub_even
432 0, // IntRegs:sub_odd64_then_sub_odd
433 },
434 { // GPRIncomingArg
435 0, // GPRIncomingArg:sub_even
436 0, // GPRIncomingArg:sub_even64
437 0, // GPRIncomingArg:sub_odd
438 0, // GPRIncomingArg:sub_odd64
439 0, // GPRIncomingArg:sub_odd64_then_sub_even
440 0, // GPRIncomingArg:sub_odd64_then_sub_odd
441 },
442 { // GPROutgoingArg
443 0, // GPROutgoingArg:sub_even
444 0, // GPROutgoingArg:sub_even64
445 0, // GPROutgoingArg:sub_odd
446 0, // GPROutgoingArg:sub_odd64
447 0, // GPROutgoingArg:sub_odd64_then_sub_even
448 0, // GPROutgoingArg:sub_odd64_then_sub_odd
449 },
450 { // ICCRegs
451 0, // ICCRegs:sub_even
452 0, // ICCRegs:sub_even64
453 0, // ICCRegs:sub_odd
454 0, // ICCRegs:sub_odd64
455 0, // ICCRegs:sub_odd64_then_sub_even
456 0, // ICCRegs:sub_odd64_then_sub_odd
457 },
458 { // DFPRegs
459 4, // DFPRegs:sub_even -> FPRegs
460 0, // DFPRegs:sub_even64
461 4, // DFPRegs:sub_odd -> FPRegs
462 0, // DFPRegs:sub_odd64
463 0, // DFPRegs:sub_odd64_then_sub_even
464 0, // DFPRegs:sub_odd64_then_sub_odd
465 },
466 { // I64Regs
467 0, // I64Regs:sub_even
468 0, // I64Regs:sub_even64
469 0, // I64Regs:sub_odd
470 0, // I64Regs:sub_odd64
471 0, // I64Regs:sub_odd64_then_sub_even
472 0, // I64Regs:sub_odd64_then_sub_odd
473 },
474 { // PRRegs
475 0, // PRRegs:sub_even
476 0, // PRRegs:sub_even64
477 0, // PRRegs:sub_odd
478 0, // PRRegs:sub_odd64
479 0, // PRRegs:sub_odd64_then_sub_even
480 0, // PRRegs:sub_odd64_then_sub_odd
481 },
482 { // CoprocPair
483 3, // CoprocPair:sub_even -> CoprocRegs
484 0, // CoprocPair:sub_even64
485 3, // CoprocPair:sub_odd -> CoprocRegs
486 0, // CoprocPair:sub_odd64
487 0, // CoprocPair:sub_odd64_then_sub_even
488 0, // CoprocPair:sub_odd64_then_sub_odd
489 },
490 { // IntPair
491 10, // IntPair:sub_even -> I64Regs
492 0, // IntPair:sub_even64
493 10, // IntPair:sub_odd -> I64Regs
494 0, // IntPair:sub_odd64
495 0, // IntPair:sub_odd64_then_sub_even
496 0, // IntPair:sub_odd64_then_sub_odd
497 },
498 { // LowDFPRegs
499 4, // LowDFPRegs:sub_even -> FPRegs
500 0, // LowDFPRegs:sub_even64
501 4, // LowDFPRegs:sub_odd -> FPRegs
502 0, // LowDFPRegs:sub_odd64
503 0, // LowDFPRegs:sub_odd64_then_sub_even
504 0, // LowDFPRegs:sub_odd64_then_sub_odd
505 },
506 { // I64Regs_and_GPRIncomingArg
507 0, // I64Regs_and_GPRIncomingArg:sub_even
508 0, // I64Regs_and_GPRIncomingArg:sub_even64
509 0, // I64Regs_and_GPRIncomingArg:sub_odd
510 0, // I64Regs_and_GPRIncomingArg:sub_odd64
511 0, // I64Regs_and_GPRIncomingArg:sub_odd64_then_sub_even
512 0, // I64Regs_and_GPRIncomingArg:sub_odd64_then_sub_odd
513 },
514 { // I64Regs_and_GPROutgoingArg
515 0, // I64Regs_and_GPROutgoingArg:sub_even
516 0, // I64Regs_and_GPROutgoingArg:sub_even64
517 0, // I64Regs_and_GPROutgoingArg:sub_odd
518 0, // I64Regs_and_GPROutgoingArg:sub_odd64
519 0, // I64Regs_and_GPROutgoingArg:sub_odd64_then_sub_even
520 0, // I64Regs_and_GPROutgoingArg:sub_odd64_then_sub_odd
521 },
522 { // IntPair_with_sub_even_in_GPRIncomingArg
523 15, // IntPair_with_sub_even_in_GPRIncomingArg:sub_even -> I64Regs_and_GPRIncomingArg
524 0, // IntPair_with_sub_even_in_GPRIncomingArg:sub_even64
525 15, // IntPair_with_sub_even_in_GPRIncomingArg:sub_odd -> I64Regs_and_GPRIncomingArg
526 0, // IntPair_with_sub_even_in_GPRIncomingArg:sub_odd64
527 0, // IntPair_with_sub_even_in_GPRIncomingArg:sub_odd64_then_sub_even
528 0, // IntPair_with_sub_even_in_GPRIncomingArg:sub_odd64_then_sub_odd
529 },
530 { // IntPair_with_sub_even_in_GPROutgoingArg
531 16, // IntPair_with_sub_even_in_GPROutgoingArg:sub_even -> I64Regs_and_GPROutgoingArg
532 0, // IntPair_with_sub_even_in_GPROutgoingArg:sub_even64
533 16, // IntPair_with_sub_even_in_GPROutgoingArg:sub_odd -> I64Regs_and_GPROutgoingArg
534 0, // IntPair_with_sub_even_in_GPROutgoingArg:sub_odd64
535 0, // IntPair_with_sub_even_in_GPROutgoingArg:sub_odd64_then_sub_even
536 0, // IntPair_with_sub_even_in_GPROutgoingArg:sub_odd64_then_sub_odd
537 },
538 { // PRRegs_and_ASRRegs
539 0, // PRRegs_and_ASRRegs:sub_even
540 0, // PRRegs_and_ASRRegs:sub_even64
541 0, // PRRegs_and_ASRRegs:sub_odd
542 0, // PRRegs_and_ASRRegs:sub_odd64
543 0, // PRRegs_and_ASRRegs:sub_odd64_then_sub_even
544 0, // PRRegs_and_ASRRegs:sub_odd64_then_sub_odd
545 },
546 { // QFPRegs
547 4, // QFPRegs:sub_even -> FPRegs
548 9, // QFPRegs:sub_even64 -> DFPRegs
549 4, // QFPRegs:sub_odd -> FPRegs
550 9, // QFPRegs:sub_odd64 -> DFPRegs
551 4, // QFPRegs:sub_odd64_then_sub_even -> FPRegs
552 4, // QFPRegs:sub_odd64_then_sub_odd -> FPRegs
553 },
554 { // LowQFPRegs
555 4, // LowQFPRegs:sub_even -> FPRegs
556 14, // LowQFPRegs:sub_even64 -> LowDFPRegs
557 4, // LowQFPRegs:sub_odd -> FPRegs
558 14, // LowQFPRegs:sub_odd64 -> LowDFPRegs
559 4, // LowQFPRegs:sub_odd64_then_sub_even -> FPRegs
560 4, // LowQFPRegs:sub_odd64_then_sub_odd -> FPRegs
561 },
562
563 };
564 assert(RC && "Missing regclass");
565 if (!Idx) return RC;
566 --Idx;
567 assert(Idx < 6 && "Bad subreg");
568 unsigned TV = Table[RC->getID()][Idx];
569 return TV ? getRegClass(i: TV - 1) : nullptr;
570}/// Get the weight in units of pressure for this register class.
571const RegClassWeight &SparcGenRegisterInfo::
572getRegClassWeight(const TargetRegisterClass *RC) const {
573 static const RegClassWeight RCWeightTable[] = {
574 {.RegWeight: 1, .WeightLimit: 4}, // FCCRegs
575 {.RegWeight: 1, .WeightLimit: 1}, // ASRRegs
576 {.RegWeight: 0, .WeightLimit: 0}, // CoprocRegs
577 {.RegWeight: 1, .WeightLimit: 32}, // FPRegs
578 {.RegWeight: 1, .WeightLimit: 32}, // IntRegs
579 {.RegWeight: 1, .WeightLimit: 6}, // GPRIncomingArg
580 {.RegWeight: 1, .WeightLimit: 6}, // GPROutgoingArg
581 {.RegWeight: 0, .WeightLimit: 0}, // ICCRegs
582 {.RegWeight: 2, .WeightLimit: 64}, // DFPRegs
583 {.RegWeight: 1, .WeightLimit: 32}, // I64Regs
584 {.RegWeight: 1, .WeightLimit: 17}, // PRRegs
585 {.RegWeight: 0, .WeightLimit: 0}, // CoprocPair
586 {.RegWeight: 2, .WeightLimit: 32}, // IntPair
587 {.RegWeight: 2, .WeightLimit: 32}, // LowDFPRegs
588 {.RegWeight: 1, .WeightLimit: 6}, // I64Regs_and_GPRIncomingArg
589 {.RegWeight: 1, .WeightLimit: 6}, // I64Regs_and_GPROutgoingArg
590 {.RegWeight: 2, .WeightLimit: 6}, // IntPair_with_sub_even_in_GPRIncomingArg
591 {.RegWeight: 2, .WeightLimit: 6}, // IntPair_with_sub_even_in_GPROutgoingArg
592 {.RegWeight: 1, .WeightLimit: 1}, // PRRegs_and_ASRRegs
593 {.RegWeight: 4, .WeightLimit: 64}, // QFPRegs
594 {.RegWeight: 4, .WeightLimit: 32}, // LowQFPRegs
595 };
596 return RCWeightTable[RC->getID()];
597}
598
599/// Get the weight in units of pressure for this register unit.
600unsigned SparcGenRegisterInfo::
601getRegUnitWeight(MCRegUnit RegUnit) const {
602 assert(static_cast<unsigned>(RegUnit) < 173 && "invalid register unit");
603 static const uint8_t RUWeightTable[] = {
604 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, };
605 return RUWeightTable[static_cast<unsigned>(RegUnit)];
606}
607
608
609// Get the number of dimensions of register pressure.
610unsigned SparcGenRegisterInfo::getNumRegPressureSets() const {
611 return 8;
612}
613
614// Get the name of this register unit pressure set.
615const char *SparcGenRegisterInfo::
616getRegPressureSetName(unsigned Idx) const {
617 static const char *PressureNameTable[] = {
618 "PRRegs_and_ASRRegs",
619 "FCCRegs",
620 "GPRIncomingArg",
621 "GPROutgoingArg",
622 "PRRegs",
623 "FPRegs",
624 "IntRegs",
625 "DFPRegs",
626 };
627 return PressureNameTable[Idx];
628}
629
630// Get the register unit pressure limit for this dimension.
631// This limit must be adjusted dynamically for reserved registers.
632unsigned SparcGenRegisterInfo::
633getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
634 static const uint8_t PressureLimitTable[] = {
635 1, // 0: PRRegs_and_ASRRegs
636 4, // 1: FCCRegs
637 6, // 2: GPRIncomingArg
638 6, // 3: GPROutgoingArg
639 17, // 4: PRRegs
640 32, // 5: FPRegs
641 32, // 6: IntRegs
642 64, // 7: DFPRegs
643 };
644 return PressureLimitTable[Idx];
645}
646
647/// Get the register class for this pressure set with the largest
648/// `RegClassWeight::WeightLimit`.
649const TargetRegisterClass *SparcGenRegisterInfo::
650getLargestRegClassForRegPressureSet(unsigned Idx) const {
651 static const uint8_t PSetRegClassTable[] = {
652 SP::PRRegs_and_ASRRegsRegClassID, // 0: PRRegs_and_ASRRegs
653 SP::FCCRegsRegClassID, // 1: FCCRegs
654 SP::GPRIncomingArgRegClassID, // 2: GPRIncomingArg
655 SP::GPROutgoingArgRegClassID, // 3: GPROutgoingArg
656 SP::PRRegsRegClassID, // 4: PRRegs
657 SP::FPRegsRegClassID, // 5: FPRegs
658 SP::IntRegsRegClassID, // 6: IntRegs
659 SP::DFPRegsRegClassID, // 7: DFPRegs
660 };
661 return getRegClass(i: PSetRegClassTable[Idx]);
662}
663
664/// Table of pressure sets per register class or unit.
665static const int RCSetsTable[] = {
666 /* 0 */ 1, -1,
667 /* 2 */ 0, 4, -1,
668 /* 5 */ 2, 6, -1,
669 /* 8 */ 3, 6, -1,
670 /* 11 */ 5, 7, -1,
671};
672
673/// Get the dimensions of register pressure impacted by this register class.
674/// Returns a -1 terminated array of pressure set IDs
675const int *SparcGenRegisterInfo::
676getRegClassPressureSets(const TargetRegisterClass *RC) const {
677 static const uint8_t RCSetStartTable[] = {
678 0,1,1,11,6,5,8,1,12,6,3,1,6,11,5,8,5,8,2,12,11,};
679 return &RCSetsTable[RCSetStartTable[RC->getID()]];
680}
681
682/// Get the dimensions of register pressure impacted by this register unit.
683/// Returns a -1 terminated array of pressure set IDs
684const int *SparcGenRegisterInfo::
685getRegUnitPressureSets(MCRegUnit RegUnit) const {
686 assert(static_cast<unsigned>(RegUnit) < 173 && "invalid register unit");
687 static const uint8_t RUSetStartTable[] = {
688 3,3,3,1,1,3,1,1,3,1,3,3,1,3,3,1,2,3,3,3,3,3,3,1,3,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,0,0,0,0,6,6,6,6,6,6,6,6,5,5,5,5,5,5,6,6,6,6,6,6,6,6,6,6,8,8,8,8,8,8,6,6,};
689 return &RCSetsTable[RUSetStartTable[static_cast<unsigned>(RegUnit)]];
690}
691
692
693// Register to minimal register class mapping
694
695const TargetRegisterClass *SparcGenRegisterInfo::getMinimalPhysRegClass(MCRegister Reg) const {
696 static const uint16_t InvalidRegClassID = UINT16_MAX;
697
698 static const uint16_t Mapping[238] = {
699 InvalidRegClassID, // NoRegister
700 SP::PRRegsRegClassID, // CANRESTORE
701 SP::PRRegsRegClassID, // CANSAVE
702 SP::PRRegsRegClassID, // CLEANWIN
703 InvalidRegClassID, // CPQ
704 InvalidRegClassID, // CPSR
705 SP::PRRegsRegClassID, // CWP
706 InvalidRegClassID, // FQ
707 InvalidRegClassID, // FSR
708 SP::PRRegsRegClassID, // GL
709 SP::ICCRegsRegClassID, // ICC
710 SP::PRRegsRegClassID, // OTHERWIN
711 SP::PRRegsRegClassID, // PIL
712 InvalidRegClassID, // PSR
713 SP::PRRegsRegClassID, // PSTATE
714 SP::PRRegsRegClassID, // TBA
715 InvalidRegClassID, // TBR
716 SP::PRRegs_and_ASRRegsRegClassID, // TICK
717 SP::PRRegsRegClassID, // TL
718 SP::PRRegsRegClassID, // TNPC
719 SP::PRRegsRegClassID, // TPC
720 SP::PRRegsRegClassID, // TSTATE
721 SP::PRRegsRegClassID, // TT
722 SP::PRRegsRegClassID, // VER
723 InvalidRegClassID, // WIM
724 SP::PRRegsRegClassID, // WSTATE
725 SP::ASRRegsRegClassID, // Y
726 SP::ASRRegsRegClassID, // ASR1
727 SP::ASRRegsRegClassID, // ASR2
728 SP::ASRRegsRegClassID, // ASR3
729 SP::ASRRegsRegClassID, // ASR4
730 SP::ASRRegsRegClassID, // ASR5
731 SP::ASRRegsRegClassID, // ASR6
732 SP::ASRRegsRegClassID, // ASR7
733 SP::ASRRegsRegClassID, // ASR8
734 SP::ASRRegsRegClassID, // ASR9
735 SP::ASRRegsRegClassID, // ASR10
736 SP::ASRRegsRegClassID, // ASR11
737 SP::ASRRegsRegClassID, // ASR12
738 SP::ASRRegsRegClassID, // ASR13
739 SP::ASRRegsRegClassID, // ASR14
740 SP::ASRRegsRegClassID, // ASR15
741 SP::ASRRegsRegClassID, // ASR16
742 SP::ASRRegsRegClassID, // ASR17
743 SP::ASRRegsRegClassID, // ASR18
744 SP::ASRRegsRegClassID, // ASR19
745 SP::ASRRegsRegClassID, // ASR20
746 SP::ASRRegsRegClassID, // ASR21
747 SP::ASRRegsRegClassID, // ASR22
748 SP::ASRRegsRegClassID, // ASR23
749 SP::ASRRegsRegClassID, // ASR24
750 SP::ASRRegsRegClassID, // ASR25
751 SP::ASRRegsRegClassID, // ASR26
752 SP::ASRRegsRegClassID, // ASR27
753 SP::ASRRegsRegClassID, // ASR28
754 SP::ASRRegsRegClassID, // ASR29
755 SP::ASRRegsRegClassID, // ASR30
756 SP::ASRRegsRegClassID, // ASR31
757 SP::CoprocRegsRegClassID, // C0
758 SP::CoprocRegsRegClassID, // C1
759 SP::CoprocRegsRegClassID, // C2
760 SP::CoprocRegsRegClassID, // C3
761 SP::CoprocRegsRegClassID, // C4
762 SP::CoprocRegsRegClassID, // C5
763 SP::CoprocRegsRegClassID, // C6
764 SP::CoprocRegsRegClassID, // C7
765 SP::CoprocRegsRegClassID, // C8
766 SP::CoprocRegsRegClassID, // C9
767 SP::CoprocRegsRegClassID, // C10
768 SP::CoprocRegsRegClassID, // C11
769 SP::CoprocRegsRegClassID, // C12
770 SP::CoprocRegsRegClassID, // C13
771 SP::CoprocRegsRegClassID, // C14
772 SP::CoprocRegsRegClassID, // C15
773 SP::CoprocRegsRegClassID, // C16
774 SP::CoprocRegsRegClassID, // C17
775 SP::CoprocRegsRegClassID, // C18
776 SP::CoprocRegsRegClassID, // C19
777 SP::CoprocRegsRegClassID, // C20
778 SP::CoprocRegsRegClassID, // C21
779 SP::CoprocRegsRegClassID, // C22
780 SP::CoprocRegsRegClassID, // C23
781 SP::CoprocRegsRegClassID, // C24
782 SP::CoprocRegsRegClassID, // C25
783 SP::CoprocRegsRegClassID, // C26
784 SP::CoprocRegsRegClassID, // C27
785 SP::CoprocRegsRegClassID, // C28
786 SP::CoprocRegsRegClassID, // C29
787 SP::CoprocRegsRegClassID, // C30
788 SP::CoprocRegsRegClassID, // C31
789 SP::LowDFPRegsRegClassID, // D0
790 SP::LowDFPRegsRegClassID, // D1
791 SP::LowDFPRegsRegClassID, // D2
792 SP::LowDFPRegsRegClassID, // D3
793 SP::LowDFPRegsRegClassID, // D4
794 SP::LowDFPRegsRegClassID, // D5
795 SP::LowDFPRegsRegClassID, // D6
796 SP::LowDFPRegsRegClassID, // D7
797 SP::LowDFPRegsRegClassID, // D8
798 SP::LowDFPRegsRegClassID, // D9
799 SP::LowDFPRegsRegClassID, // D10
800 SP::LowDFPRegsRegClassID, // D11
801 SP::LowDFPRegsRegClassID, // D12
802 SP::LowDFPRegsRegClassID, // D13
803 SP::LowDFPRegsRegClassID, // D14
804 SP::LowDFPRegsRegClassID, // D15
805 SP::DFPRegsRegClassID, // D16
806 SP::DFPRegsRegClassID, // D17
807 SP::DFPRegsRegClassID, // D18
808 SP::DFPRegsRegClassID, // D19
809 SP::DFPRegsRegClassID, // D20
810 SP::DFPRegsRegClassID, // D21
811 SP::DFPRegsRegClassID, // D22
812 SP::DFPRegsRegClassID, // D23
813 SP::DFPRegsRegClassID, // D24
814 SP::DFPRegsRegClassID, // D25
815 SP::DFPRegsRegClassID, // D26
816 SP::DFPRegsRegClassID, // D27
817 SP::DFPRegsRegClassID, // D28
818 SP::DFPRegsRegClassID, // D29
819 SP::DFPRegsRegClassID, // D30
820 SP::DFPRegsRegClassID, // D31
821 SP::FPRegsRegClassID, // F0
822 SP::FPRegsRegClassID, // F1
823 SP::FPRegsRegClassID, // F2
824 SP::FPRegsRegClassID, // F3
825 SP::FPRegsRegClassID, // F4
826 SP::FPRegsRegClassID, // F5
827 SP::FPRegsRegClassID, // F6
828 SP::FPRegsRegClassID, // F7
829 SP::FPRegsRegClassID, // F8
830 SP::FPRegsRegClassID, // F9
831 SP::FPRegsRegClassID, // F10
832 SP::FPRegsRegClassID, // F11
833 SP::FPRegsRegClassID, // F12
834 SP::FPRegsRegClassID, // F13
835 SP::FPRegsRegClassID, // F14
836 SP::FPRegsRegClassID, // F15
837 SP::FPRegsRegClassID, // F16
838 SP::FPRegsRegClassID, // F17
839 SP::FPRegsRegClassID, // F18
840 SP::FPRegsRegClassID, // F19
841 SP::FPRegsRegClassID, // F20
842 SP::FPRegsRegClassID, // F21
843 SP::FPRegsRegClassID, // F22
844 SP::FPRegsRegClassID, // F23
845 SP::FPRegsRegClassID, // F24
846 SP::FPRegsRegClassID, // F25
847 SP::FPRegsRegClassID, // F26
848 SP::FPRegsRegClassID, // F27
849 SP::FPRegsRegClassID, // F28
850 SP::FPRegsRegClassID, // F29
851 SP::FPRegsRegClassID, // F30
852 SP::FPRegsRegClassID, // F31
853 SP::FCCRegsRegClassID, // FCC0
854 SP::FCCRegsRegClassID, // FCC1
855 SP::FCCRegsRegClassID, // FCC2
856 SP::FCCRegsRegClassID, // FCC3
857 SP::I64RegsRegClassID, // G0
858 SP::I64RegsRegClassID, // G1
859 SP::I64RegsRegClassID, // G2
860 SP::I64RegsRegClassID, // G3
861 SP::I64RegsRegClassID, // G4
862 SP::I64RegsRegClassID, // G5
863 SP::I64RegsRegClassID, // G6
864 SP::I64RegsRegClassID, // G7
865 SP::I64Regs_and_GPRIncomingArgRegClassID, // I0
866 SP::I64Regs_and_GPRIncomingArgRegClassID, // I1
867 SP::I64Regs_and_GPRIncomingArgRegClassID, // I2
868 SP::I64Regs_and_GPRIncomingArgRegClassID, // I3
869 SP::I64Regs_and_GPRIncomingArgRegClassID, // I4
870 SP::I64Regs_and_GPRIncomingArgRegClassID, // I5
871 SP::I64RegsRegClassID, // I6
872 SP::I64RegsRegClassID, // I7
873 SP::I64RegsRegClassID, // L0
874 SP::I64RegsRegClassID, // L1
875 SP::I64RegsRegClassID, // L2
876 SP::I64RegsRegClassID, // L3
877 SP::I64RegsRegClassID, // L4
878 SP::I64RegsRegClassID, // L5
879 SP::I64RegsRegClassID, // L6
880 SP::I64RegsRegClassID, // L7
881 SP::I64Regs_and_GPROutgoingArgRegClassID, // O0
882 SP::I64Regs_and_GPROutgoingArgRegClassID, // O1
883 SP::I64Regs_and_GPROutgoingArgRegClassID, // O2
884 SP::I64Regs_and_GPROutgoingArgRegClassID, // O3
885 SP::I64Regs_and_GPROutgoingArgRegClassID, // O4
886 SP::I64Regs_and_GPROutgoingArgRegClassID, // O5
887 SP::I64RegsRegClassID, // O6
888 SP::I64RegsRegClassID, // O7
889 SP::LowQFPRegsRegClassID, // Q0
890 SP::LowQFPRegsRegClassID, // Q1
891 SP::LowQFPRegsRegClassID, // Q2
892 SP::LowQFPRegsRegClassID, // Q3
893 SP::LowQFPRegsRegClassID, // Q4
894 SP::LowQFPRegsRegClassID, // Q5
895 SP::LowQFPRegsRegClassID, // Q6
896 SP::LowQFPRegsRegClassID, // Q7
897 SP::QFPRegsRegClassID, // Q8
898 SP::QFPRegsRegClassID, // Q9
899 SP::QFPRegsRegClassID, // Q10
900 SP::QFPRegsRegClassID, // Q11
901 SP::QFPRegsRegClassID, // Q12
902 SP::QFPRegsRegClassID, // Q13
903 SP::QFPRegsRegClassID, // Q14
904 SP::QFPRegsRegClassID, // Q15
905 SP::CoprocPairRegClassID, // C0_C1
906 SP::CoprocPairRegClassID, // C2_C3
907 SP::CoprocPairRegClassID, // C4_C5
908 SP::CoprocPairRegClassID, // C6_C7
909 SP::CoprocPairRegClassID, // C8_C9
910 SP::CoprocPairRegClassID, // C10_C11
911 SP::CoprocPairRegClassID, // C12_C13
912 SP::CoprocPairRegClassID, // C14_C15
913 SP::CoprocPairRegClassID, // C16_C17
914 SP::CoprocPairRegClassID, // C18_C19
915 SP::CoprocPairRegClassID, // C20_C21
916 SP::CoprocPairRegClassID, // C22_C23
917 SP::CoprocPairRegClassID, // C24_C25
918 SP::CoprocPairRegClassID, // C26_C27
919 SP::CoprocPairRegClassID, // C28_C29
920 SP::CoprocPairRegClassID, // C30_C31
921 SP::IntPairRegClassID, // G0_G1
922 SP::IntPairRegClassID, // G2_G3
923 SP::IntPairRegClassID, // G4_G5
924 SP::IntPairRegClassID, // G6_G7
925 SP::IntPair_with_sub_even_in_GPRIncomingArgRegClassID, // I0_I1
926 SP::IntPair_with_sub_even_in_GPRIncomingArgRegClassID, // I2_I3
927 SP::IntPair_with_sub_even_in_GPRIncomingArgRegClassID, // I4_I5
928 SP::IntPairRegClassID, // I6_I7
929 SP::IntPairRegClassID, // L0_L1
930 SP::IntPairRegClassID, // L2_L3
931 SP::IntPairRegClassID, // L4_L5
932 SP::IntPairRegClassID, // L6_L7
933 SP::IntPair_with_sub_even_in_GPROutgoingArgRegClassID, // O0_O1
934 SP::IntPair_with_sub_even_in_GPROutgoingArgRegClassID, // O2_O3
935 SP::IntPair_with_sub_even_in_GPROutgoingArgRegClassID, // O4_O5
936 SP::IntPairRegClassID, // O6_O7
937 };
938
939 assert(Reg < ArrayRef(Mapping).size());
940 unsigned RCID = Mapping[Reg.id()];
941 if (RCID == InvalidRegClassID)
942 return nullptr;
943 return &SparcMCRegisterClassStorage.Classes[RCID];
944}
945extern const MCRegisterDesc SparcRegDesc[];
946extern const int16_t SparcRegDiffLists[];
947extern const LaneBitmask SparcLaneMaskLists[];
948extern const char SparcRegStrings[];
949extern const char SparcRegClassStrings[];
950extern const MCPhysReg SparcRegUnitRoots[][2];
951extern const uint16_t SparcSubRegIdxLists[];
952extern const uint16_t SparcRegEncodingTable[];
953// SP Dwarf<->LLVM register mappings.
954extern const MCRegisterInfo::DwarfLLVMRegPair SPDwarfFlavour0Dwarf2L[];
955extern const unsigned SPDwarfFlavour0Dwarf2LSize;
956
957extern const MCRegisterInfo::DwarfLLVMRegPair SPEHFlavour0Dwarf2L[];
958extern const unsigned SPEHFlavour0Dwarf2LSize;
959
960extern const MCRegisterInfo::DwarfLLVMRegPair SPDwarfFlavour0L2Dwarf[];
961extern const unsigned SPDwarfFlavour0L2DwarfSize;
962
963extern const MCRegisterInfo::DwarfLLVMRegPair SPEHFlavour0L2Dwarf[];
964extern const unsigned SPEHFlavour0L2DwarfSize;
965
966
967SparcGenRegisterInfo::
968SparcGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
969 unsigned PC, unsigned HwMode)
970 : TargetRegisterInfo(&SparcRegInfoDesc,
971 SparcSubRegIndexStrings, SparcSubRegIndexNameOffsets,
972 SparcSubRegIdxRangeTable, SparcSubRegIndexLaneMaskTable,
973
974 LaneBitmask(0xFFFFFFFFFFFFFFFF), SparcRegClassInfos, SparcVTLists, HwMode) {
975 InitMCRegisterInfo(D: SparcRegDesc, NR: 238, RA, PC,
976 C: &getSparcMCRegisterClass(RC: 0), NC: 21, RURoots: SparcRegUnitRoots, NRU: 173, DL: SparcRegDiffLists,
977 RUMS: SparcLaneMaskLists, Strings: SparcRegStrings, ClassStrings: SparcRegClassStrings, SubIndices: SparcSubRegIdxLists, NumIndices: 7,
978 RET: SparcRegEncodingTable, RUI: nullptr);
979
980 switch (DwarfFlavour) {
981 default:
982 llvm_unreachable("Unknown DWARF flavour");
983 case 0:
984 mapDwarfRegsToLLVMRegs(Map: SPDwarfFlavour0Dwarf2L, Size: SPDwarfFlavour0Dwarf2LSize, isEH: false);
985 break;
986 }
987 switch (EHFlavour) {
988 default:
989 llvm_unreachable("Unknown DWARF flavour");
990 case 0:
991 mapDwarfRegsToLLVMRegs(Map: SPEHFlavour0Dwarf2L, Size: SPEHFlavour0Dwarf2LSize, isEH: true);
992 break;
993 }
994 switch (DwarfFlavour) {
995 default:
996 llvm_unreachable("Unknown DWARF flavour");
997 case 0:
998 mapLLVMRegsToDwarfRegs(Map: SPDwarfFlavour0L2Dwarf, Size: SPDwarfFlavour0L2DwarfSize, isEH: false);
999 break;
1000 }
1001 switch (EHFlavour) {
1002 default:
1003 llvm_unreachable("Unknown DWARF flavour");
1004 case 0:
1005 mapLLVMRegsToDwarfRegs(Map: SPEHFlavour0L2Dwarf, Size: SPEHFlavour0L2DwarfSize, isEH: true);
1006 break;
1007 }
1008}
1009
1010static const MCPhysReg CSR_SaveList[] = { 0 };
1011static const uint32_t CSR_RegMask[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x40000000, 0x103fffc0, 0x00000000, 0x000003fc, };
1012static const MCPhysReg RTCSR_SaveList[] = { 0 };
1013static const uint32_t RTCSR_RegMask[] = { 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x40000000, 0x00003000, 0x00000000, 0x00000020, };
1014
1015
1016ArrayRef<const uint32_t *> SparcGenRegisterInfo::getRegMasks() const {
1017 static const uint32_t *const Masks[] = {
1018 CSR_RegMask,
1019 RTCSR_RegMask,
1020 };
1021 return ArrayRef(Masks);
1022}
1023
1024bool SparcGenRegisterInfo::
1025isGeneralPurposeRegister(const MachineFunction &MF, MCRegister PhysReg) const {
1026 return
1027 false;
1028}
1029
1030bool SparcGenRegisterInfo::
1031isGeneralPurposeRegisterClass(const TargetRegisterClass *RC) const {
1032 return
1033 false;
1034}
1035
1036bool SparcGenRegisterInfo::
1037isFixedRegister(const MachineFunction &MF, MCRegister PhysReg) const {
1038 return
1039 false;
1040}
1041
1042bool SparcGenRegisterInfo::
1043isArgumentRegister(const MachineFunction &MF, MCRegister PhysReg) const {
1044 return
1045 false;
1046}
1047
1048bool SparcGenRegisterInfo::
1049isConstantPhysReg(MCRegister PhysReg) const {
1050 return
1051 PhysReg == SP::G0 ||
1052 false;
1053}
1054
1055ArrayRef<const char *> SparcGenRegisterInfo::getRegMaskNames() const {
1056 static const char *Names[] = {
1057 "CSR",
1058 "RTCSR",
1059 };
1060 return ArrayRef(Names);
1061}
1062
1063const SparcFrameLowering *
1064SparcGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
1065 return static_cast<const SparcFrameLowering *>(
1066 MF.getSubtarget().getFrameLowering());
1067}
1068
1069
1070} // namespace llvm
1071