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 MCRegisterClass HexagonMCRegisterClasses[];
12
13static const MVT::SimpleValueType VTLists[] = {
14 /* 0 */ MVT::i1, MVT::Other,
15 /* 2 */ MVT::i1, MVT::v2i1, MVT::v4i1, MVT::v8i1, MVT::v4i8, MVT::v2i16, MVT::i32, MVT::Other,
16 /* 10 */ MVT::i64, MVT::Other,
17 /* 12 */ MVT::v64i1, MVT::v64i1, MVT::v32i1, MVT::v16i1, MVT::Other,
18 /* 17 */ MVT::v128i1, MVT::v128i1, MVT::v64i1, MVT::v32i1, MVT::Other,
19 /* 22 */ MVT::i32, MVT::f32, MVT::v4i8, MVT::v2i16, MVT::Other,
20 /* 27 */ MVT::i64, MVT::f64, MVT::v8i8, MVT::v4i16, MVT::v2i32, MVT::Other,
21 /* 33 */ MVT::v64i8, MVT::v32i16, MVT::v16i32, MVT::v32f16, MVT::v32bf16, MVT::v16f32, MVT::Other,
22 /* 40 */ MVT::v128i8, MVT::v64i16, MVT::v32i32, MVT::v64f16, MVT::v64bf16, MVT::v32f32, MVT::Other,
23 /* 47 */ MVT::v256i8, MVT::v128i16, MVT::v64i32, MVT::v128f16, MVT::v128bf16, MVT::v64f32, MVT::Other,
24 /* 54 */ MVT::Untyped, MVT::Other,
25};
26
27#ifdef __GNUC__
28#pragma GCC diagnostic push
29#pragma GCC diagnostic ignored "-Woverlength-strings"
30#endif
31static constexpr char HexagonSubRegIndexStrings[] = {
32 /* 0 */ "wsub_hi_then_vsub_fake\000"
33 /* 23 */ "isub_hi\000"
34 /* 31 */ "wsub_hi_then_vsub_hi\000"
35 /* 52 */ "wsub_hi\000"
36 /* 60 */ "isub_lo\000"
37 /* 68 */ "wsub_hi_then_vsub_lo\000"
38 /* 89 */ "wsub_lo\000"
39 /* 97 */ "subreg_overflow\000"
40};
41#ifdef __GNUC__
42#pragma GCC diagnostic pop
43#endif
44
45
46static constexpr uint32_t HexagonSubRegIndexNameOffsets[] = {
47 23,
48 60,
49 97,
50 13,
51 44,
52 81,
53 52,
54 89,
55 0,
56 31,
57 68,
58};
59
60static const TargetRegisterInfo::SubRegCoveredBits SubRegIdxRangeTable[] = {
61 { .Offset: 65535, .Size: 65535 },
62 { .Offset: 32, .Size: 32 }, // isub_hi
63 { .Offset: 0, .Size: 32 }, // isub_lo
64 { .Offset: 0, .Size: 1 }, // subreg_overflow
65 { .Offset: 65535, .Size: 65535 }, // vsub_fake
66 { .Offset: 65535, .Size: 65535 }, // vsub_hi
67 { .Offset: 65535, .Size: 65535 }, // vsub_lo
68 { .Offset: 65535, .Size: 65535 }, // wsub_hi
69 { .Offset: 65535, .Size: 65535 }, // wsub_lo
70 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_fake
71 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_hi
72 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_lo
73 { .Offset: 65535, .Size: 65535 },
74 { .Offset: 32, .Size: 32 }, // isub_hi
75 { .Offset: 0, .Size: 32 }, // isub_lo
76 { .Offset: 0, .Size: 1 }, // subreg_overflow
77 { .Offset: 65535, .Size: 65535 }, // vsub_fake
78 { .Offset: 65535, .Size: 65535 }, // vsub_hi
79 { .Offset: 65535, .Size: 65535 }, // vsub_lo
80 { .Offset: 65535, .Size: 65535 }, // wsub_hi
81 { .Offset: 65535, .Size: 65535 }, // wsub_lo
82 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_fake
83 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_hi
84 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_lo
85 { .Offset: 65535, .Size: 65535 },
86 { .Offset: 32, .Size: 32 }, // isub_hi
87 { .Offset: 0, .Size: 32 }, // isub_lo
88 { .Offset: 0, .Size: 1 }, // subreg_overflow
89 { .Offset: 65535, .Size: 65535 }, // vsub_fake
90 { .Offset: 65535, .Size: 65535 }, // vsub_hi
91 { .Offset: 65535, .Size: 65535 }, // vsub_lo
92 { .Offset: 65535, .Size: 65535 }, // wsub_hi
93 { .Offset: 65535, .Size: 65535 }, // wsub_lo
94 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_fake
95 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_hi
96 { .Offset: 65535, .Size: 65535 }, // wsub_hi_then_vsub_lo
97};
98
99
100static const LaneBitmask SubRegIndexLaneMaskTable[] = {
101 LaneBitmask::getAll(),
102 LaneBitmask(0x0000000000000001), // isub_hi
103 LaneBitmask(0x0000000000000002), // isub_lo
104 LaneBitmask(0x0000000000000004), // subreg_overflow
105 LaneBitmask(0x0000000000000008), // vsub_fake
106 LaneBitmask(0x0000000000000010), // vsub_hi
107 LaneBitmask(0x0000000000000020), // vsub_lo
108 LaneBitmask(0x00000000000001C0), // wsub_hi
109 LaneBitmask(0x0000000000000038), // wsub_lo
110 LaneBitmask(0x0000000000000040), // wsub_hi_then_vsub_fake
111 LaneBitmask(0x0000000000000080), // wsub_hi_then_vsub_hi
112 LaneBitmask(0x0000000000000100), // wsub_hi_then_vsub_lo
113 };
114
115
116
117static const TargetRegisterInfo::RegClassInfo RegClassInfos[] = {
118 // Mode = 0 (DefaultMode)
119 { .RegSize: 1, .SpillSize: 1, .SpillAlignment: 0, /*VTLists+*/.VTListOffset: 0 }, // UsrBits
120 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // SysRegs
121 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // GuestRegs
122 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 22 }, // IntRegs
123 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs
124 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // GeneralSubRegs
125 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V62Regs
126 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // IntRegsLow8
127 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs_and_V62Regs
128 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 2 }, // PredRegs
129 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V62Regs_with_isub_hi
130 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // ModRegs
131 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs_with_subreg_overflow
132 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V65Regs
133 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // SysRegs64
134 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 27 }, // DoubleRegs
135 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // GuestRegs64
136 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // VectRegRev
137 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64
138 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // GeneralDoubleLow8Regs
139 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // DoubleRegs_with_isub_hi_in_IntRegsLow8
140 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64_and_V62Regs
141 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64_with_isub_hi_in_ModRegs
142 { .RegSize: 64, .SpillSize: 512, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 12 }, // HvxQR
143 { .RegSize: 512, .SpillSize: 512, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 33 }, // HvxVR
144 { .RegSize: 512, .SpillSize: 512, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 33 }, // HvxVR_and_V65Regs
145 { .RegSize: 1024, .SpillSize: 1024, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 40 }, // HvxWR
146 { .RegSize: 1024, .SpillSize: 1024, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 40 }, // HvxWR_and_VectRegRev
147 { .RegSize: 2048, .SpillSize: 2048, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 54 }, // HvxVQR
148 // Mode = 1 (Hvx64)
149 { .RegSize: 1, .SpillSize: 1, .SpillAlignment: 0, /*VTLists+*/.VTListOffset: 0 }, // UsrBits
150 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // SysRegs
151 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // GuestRegs
152 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 22 }, // IntRegs
153 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs
154 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // GeneralSubRegs
155 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V62Regs
156 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // IntRegsLow8
157 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs_and_V62Regs
158 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 2 }, // PredRegs
159 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V62Regs_with_isub_hi
160 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // ModRegs
161 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs_with_subreg_overflow
162 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V65Regs
163 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // SysRegs64
164 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 27 }, // DoubleRegs
165 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // GuestRegs64
166 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // VectRegRev
167 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64
168 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // GeneralDoubleLow8Regs
169 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // DoubleRegs_with_isub_hi_in_IntRegsLow8
170 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64_and_V62Regs
171 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64_with_isub_hi_in_ModRegs
172 { .RegSize: 64, .SpillSize: 512, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 12 }, // HvxQR
173 { .RegSize: 512, .SpillSize: 512, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 33 }, // HvxVR
174 { .RegSize: 512, .SpillSize: 512, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 33 }, // HvxVR_and_V65Regs
175 { .RegSize: 1024, .SpillSize: 1024, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 40 }, // HvxWR
176 { .RegSize: 1024, .SpillSize: 1024, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 40 }, // HvxWR_and_VectRegRev
177 { .RegSize: 2048, .SpillSize: 2048, .SpillAlignment: 512, /*VTLists+*/.VTListOffset: 54 }, // HvxVQR
178 // Mode = 2 (Hvx128)
179 { .RegSize: 1, .SpillSize: 1, .SpillAlignment: 0, /*VTLists+*/.VTListOffset: 0 }, // UsrBits
180 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // SysRegs
181 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // GuestRegs
182 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 22 }, // IntRegs
183 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs
184 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // GeneralSubRegs
185 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V62Regs
186 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // IntRegsLow8
187 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs_and_V62Regs
188 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 2 }, // PredRegs
189 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V62Regs_with_isub_hi
190 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // ModRegs
191 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // CtrRegs_with_subreg_overflow
192 { .RegSize: 32, .SpillSize: 32, .SpillAlignment: 32, /*VTLists+*/.VTListOffset: 8 }, // V65Regs
193 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // SysRegs64
194 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 27 }, // DoubleRegs
195 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // GuestRegs64
196 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // VectRegRev
197 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64
198 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // GeneralDoubleLow8Regs
199 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // DoubleRegs_with_isub_hi_in_IntRegsLow8
200 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64_and_V62Regs
201 { .RegSize: 64, .SpillSize: 64, .SpillAlignment: 64, /*VTLists+*/.VTListOffset: 10 }, // CtrRegs64_with_isub_hi_in_ModRegs
202 { .RegSize: 128, .SpillSize: 1024, .SpillAlignment: 1024, /*VTLists+*/.VTListOffset: 17 }, // HvxQR
203 { .RegSize: 1024, .SpillSize: 1024, .SpillAlignment: 1024, /*VTLists+*/.VTListOffset: 40 }, // HvxVR
204 { .RegSize: 1024, .SpillSize: 1024, .SpillAlignment: 1024, /*VTLists+*/.VTListOffset: 40 }, // HvxVR_and_V65Regs
205 { .RegSize: 2048, .SpillSize: 2048, .SpillAlignment: 1024, /*VTLists+*/.VTListOffset: 47 }, // HvxWR
206 { .RegSize: 2048, .SpillSize: 2048, .SpillAlignment: 1024, /*VTLists+*/.VTListOffset: 47 }, // HvxWR_and_VectRegRev
207 { .RegSize: 4096, .SpillSize: 4096, .SpillAlignment: 1024, /*VTLists+*/.VTListOffset: 54 }, // HvxVQR
208};
209static const uint32_t UsrBitsSubClassMask[] = {
210 0x00000001,
211 0x00001000, // subreg_overflow
212};
213
214static const uint32_t SysRegsSubClassMask[] = {
215 0x00000002,
216 0x00004000, // isub_hi
217 0x00004000, // isub_lo
218};
219
220static const uint32_t GuestRegsSubClassMask[] = {
221 0x00000004,
222 0x00010000, // isub_hi
223 0x00010000, // isub_lo
224};
225
226static const uint32_t IntRegsSubClassMask[] = {
227 0x000000a8,
228 0x00188000, // isub_hi
229 0x00188000, // isub_lo
230};
231
232static const uint32_t CtrRegsSubClassMask[] = {
233 0x00001910,
234 0x00640400, // isub_hi
235 0x00640400, // isub_lo
236};
237
238static const uint32_t GeneralSubRegsSubClassMask[] = {
239 0x000000a0,
240 0x00180000, // isub_hi
241 0x00180000, // isub_lo
242};
243
244static const uint32_t V62RegsSubClassMask[] = {
245 0x00200540,
246 0x00200400, // isub_hi
247 0x00200400, // isub_lo
248};
249
250static const uint32_t IntRegsLow8SubClassMask[] = {
251 0x00000080,
252 0x00100000, // isub_hi
253 0x00100000, // isub_lo
254};
255
256static const uint32_t CtrRegs_and_V62RegsSubClassMask[] = {
257 0x00000100,
258 0x00200400, // isub_hi
259 0x00200400, // isub_lo
260};
261
262static const uint32_t PredRegsSubClassMask[] = {
263 0x00000200,
264};
265
266static const uint32_t V62Regs_with_isub_hiSubClassMask[] = {
267 0x00200400,
268};
269
270static const uint32_t ModRegsSubClassMask[] = {
271 0x00000800,
272 0x00400000, // isub_hi
273 0x00400000, // isub_lo
274};
275
276static const uint32_t CtrRegs_with_subreg_overflowSubClassMask[] = {
277 0x00001000,
278};
279
280static const uint32_t V65RegsSubClassMask[] = {
281 0x02002000,
282};
283
284static const uint32_t SysRegs64SubClassMask[] = {
285 0x00004000,
286};
287
288static const uint32_t DoubleRegsSubClassMask[] = {
289 0x00188000,
290};
291
292static const uint32_t GuestRegs64SubClassMask[] = {
293 0x00010000,
294};
295
296static const uint32_t VectRegRevSubClassMask[] = {
297 0x08020000,
298};
299
300static const uint32_t CtrRegs64SubClassMask[] = {
301 0x00640000,
302};
303
304static const uint32_t GeneralDoubleLow8RegsSubClassMask[] = {
305 0x00180000,
306};
307
308static const uint32_t DoubleRegs_with_isub_hi_in_IntRegsLow8SubClassMask[] = {
309 0x00100000,
310};
311
312static const uint32_t CtrRegs64_and_V62RegsSubClassMask[] = {
313 0x00200000,
314};
315
316static const uint32_t CtrRegs64_with_isub_hi_in_ModRegsSubClassMask[] = {
317 0x00400000,
318};
319
320static const uint32_t HvxQRSubClassMask[] = {
321 0x00800000,
322};
323
324static const uint32_t HvxVRSubClassMask[] = {
325 0x03000000,
326 0x1c020000, // vsub_hi
327 0x1c020000, // vsub_lo
328 0x10000000, // wsub_hi_then_vsub_hi
329 0x10000000, // wsub_hi_then_vsub_lo
330};
331
332static const uint32_t HvxVR_and_V65RegsSubClassMask[] = {
333 0x02000000,
334};
335
336static const uint32_t HvxWRSubClassMask[] = {
337 0x0c000000,
338 0x10000000, // wsub_hi
339 0x10000000, // wsub_lo
340};
341
342static const uint32_t HvxWR_and_VectRegRevSubClassMask[] = {
343 0x08000000,
344};
345
346static const uint32_t HvxVQRSubClassMask[] = {
347 0x10000000,
348};
349
350static const uint16_t SuperRegIdxSeqs[] = {
351 /* 0 */ 1, 2, 0,
352 /* 3 */ 3, 0,
353 /* 5 */ 7, 8, 0,
354 /* 8 */ 5, 6, 10, 11, 0,
355};
356
357static unsigned const GeneralSubRegsSuperclasses[] = {
358 Hexagon::IntRegsRegClassID,
359};
360
361static unsigned const IntRegsLow8Superclasses[] = {
362 Hexagon::IntRegsRegClassID,
363 Hexagon::GeneralSubRegsRegClassID,
364};
365
366static unsigned const CtrRegs_and_V62RegsSuperclasses[] = {
367 Hexagon::CtrRegsRegClassID,
368 Hexagon::V62RegsRegClassID,
369};
370
371static unsigned const V62Regs_with_isub_hiSuperclasses[] = {
372 Hexagon::V62RegsRegClassID,
373};
374
375static unsigned const ModRegsSuperclasses[] = {
376 Hexagon::CtrRegsRegClassID,
377};
378
379static unsigned const CtrRegs_with_subreg_overflowSuperclasses[] = {
380 Hexagon::CtrRegsRegClassID,
381};
382
383static unsigned const GeneralDoubleLow8RegsSuperclasses[] = {
384 Hexagon::DoubleRegsRegClassID,
385};
386
387static unsigned const DoubleRegs_with_isub_hi_in_IntRegsLow8Superclasses[] = {
388 Hexagon::DoubleRegsRegClassID,
389 Hexagon::GeneralDoubleLow8RegsRegClassID,
390};
391
392static unsigned const CtrRegs64_and_V62RegsSuperclasses[] = {
393 Hexagon::V62RegsRegClassID,
394 Hexagon::V62Regs_with_isub_hiRegClassID,
395 Hexagon::CtrRegs64RegClassID,
396};
397
398static unsigned const CtrRegs64_with_isub_hi_in_ModRegsSuperclasses[] = {
399 Hexagon::CtrRegs64RegClassID,
400};
401
402static unsigned const HvxVR_and_V65RegsSuperclasses[] = {
403 Hexagon::V65RegsRegClassID,
404 Hexagon::HvxVRRegClassID,
405};
406
407static unsigned const HvxWR_and_VectRegRevSuperclasses[] = {
408 Hexagon::VectRegRevRegClassID,
409 Hexagon::HvxWRRegClassID,
410};
411
412namespace Hexagon {
413
414// Register class instances
415 extern const TargetRegisterClass UsrBitsRegClass = {
416 .MC: &HexagonMCRegisterClasses[UsrBitsRegClassID],
417 .SubClassMask: UsrBitsSubClassMask,
418 .SuperRegIndices: SuperRegIdxSeqs + 3,
419 .LaneMask: LaneBitmask(0x0000000000000001),
420 .AllocationPriority: 0,
421 .GlobalPriority: false,
422 .TSFlags: 0x00, /* TSFlags */
423 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
424 .CoveredBySubRegs: false, /* CoveredBySubRegs */
425 .SuperClasses: nullptr, .SuperClassesSize: 0,
426 .OrderFunc: nullptr
427 };
428
429 extern const TargetRegisterClass SysRegsRegClass = {
430 .MC: &HexagonMCRegisterClasses[SysRegsRegClassID],
431 .SubClassMask: SysRegsSubClassMask,
432 .SuperRegIndices: SuperRegIdxSeqs + 0,
433 .LaneMask: LaneBitmask(0x0000000000000001),
434 .AllocationPriority: 0,
435 .GlobalPriority: false,
436 .TSFlags: 0x00, /* TSFlags */
437 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
438 .CoveredBySubRegs: false, /* CoveredBySubRegs */
439 .SuperClasses: nullptr, .SuperClassesSize: 0,
440 .OrderFunc: nullptr
441 };
442
443 extern const TargetRegisterClass GuestRegsRegClass = {
444 .MC: &HexagonMCRegisterClasses[GuestRegsRegClassID],
445 .SubClassMask: GuestRegsSubClassMask,
446 .SuperRegIndices: SuperRegIdxSeqs + 0,
447 .LaneMask: LaneBitmask(0x0000000000000001),
448 .AllocationPriority: 0,
449 .GlobalPriority: false,
450 .TSFlags: 0x00, /* TSFlags */
451 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
452 .CoveredBySubRegs: false, /* CoveredBySubRegs */
453 .SuperClasses: nullptr, .SuperClassesSize: 0,
454 .OrderFunc: nullptr
455 };
456
457 extern const TargetRegisterClass IntRegsRegClass = {
458 .MC: &HexagonMCRegisterClasses[IntRegsRegClassID],
459 .SubClassMask: IntRegsSubClassMask,
460 .SuperRegIndices: SuperRegIdxSeqs + 0,
461 .LaneMask: LaneBitmask(0x0000000000000001),
462 .AllocationPriority: 0,
463 .GlobalPriority: false,
464 .TSFlags: 0x00, /* TSFlags */
465 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
466 .CoveredBySubRegs: false, /* CoveredBySubRegs */
467 .SuperClasses: nullptr, .SuperClassesSize: 0,
468 .OrderFunc: nullptr
469 };
470
471 extern const TargetRegisterClass CtrRegsRegClass = {
472 .MC: &HexagonMCRegisterClasses[CtrRegsRegClassID],
473 .SubClassMask: CtrRegsSubClassMask,
474 .SuperRegIndices: SuperRegIdxSeqs + 0,
475 .LaneMask: LaneBitmask(0x0000000000000004),
476 .AllocationPriority: 0,
477 .GlobalPriority: false,
478 .TSFlags: 0x00, /* TSFlags */
479 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
480 .CoveredBySubRegs: false, /* CoveredBySubRegs */
481 .SuperClasses: nullptr, .SuperClassesSize: 0,
482 .OrderFunc: nullptr
483 };
484
485 extern const TargetRegisterClass GeneralSubRegsRegClass = {
486 .MC: &HexagonMCRegisterClasses[GeneralSubRegsRegClassID],
487 .SubClassMask: GeneralSubRegsSubClassMask,
488 .SuperRegIndices: SuperRegIdxSeqs + 0,
489 .LaneMask: LaneBitmask(0x0000000000000001),
490 .AllocationPriority: 0,
491 .GlobalPriority: false,
492 .TSFlags: 0x00, /* TSFlags */
493 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
494 .CoveredBySubRegs: false, /* CoveredBySubRegs */
495 .SuperClasses: GeneralSubRegsSuperclasses, .SuperClassesSize: 1,
496 .OrderFunc: nullptr
497 };
498
499 extern const TargetRegisterClass V62RegsRegClass = {
500 .MC: &HexagonMCRegisterClasses[V62RegsRegClassID],
501 .SubClassMask: V62RegsSubClassMask,
502 .SuperRegIndices: SuperRegIdxSeqs + 0,
503 .LaneMask: LaneBitmask(0x0000000000000003),
504 .AllocationPriority: 0,
505 .GlobalPriority: false,
506 .TSFlags: 0x00, /* TSFlags */
507 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
508 .CoveredBySubRegs: false, /* CoveredBySubRegs */
509 .SuperClasses: nullptr, .SuperClassesSize: 0,
510 .OrderFunc: nullptr
511 };
512
513 extern const TargetRegisterClass IntRegsLow8RegClass = {
514 .MC: &HexagonMCRegisterClasses[IntRegsLow8RegClassID],
515 .SubClassMask: IntRegsLow8SubClassMask,
516 .SuperRegIndices: SuperRegIdxSeqs + 0,
517 .LaneMask: LaneBitmask(0x0000000000000001),
518 .AllocationPriority: 0,
519 .GlobalPriority: false,
520 .TSFlags: 0x00, /* TSFlags */
521 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
522 .CoveredBySubRegs: false, /* CoveredBySubRegs */
523 .SuperClasses: IntRegsLow8Superclasses, .SuperClassesSize: 2,
524 .OrderFunc: nullptr
525 };
526
527 extern const TargetRegisterClass CtrRegs_and_V62RegsRegClass = {
528 .MC: &HexagonMCRegisterClasses[CtrRegs_and_V62RegsRegClassID],
529 .SubClassMask: CtrRegs_and_V62RegsSubClassMask,
530 .SuperRegIndices: SuperRegIdxSeqs + 0,
531 .LaneMask: LaneBitmask(0x0000000000000001),
532 .AllocationPriority: 0,
533 .GlobalPriority: false,
534 .TSFlags: 0x00, /* TSFlags */
535 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
536 .CoveredBySubRegs: false, /* CoveredBySubRegs */
537 .SuperClasses: CtrRegs_and_V62RegsSuperclasses, .SuperClassesSize: 2,
538 .OrderFunc: nullptr
539 };
540
541 extern const TargetRegisterClass PredRegsRegClass = {
542 .MC: &HexagonMCRegisterClasses[PredRegsRegClassID],
543 .SubClassMask: PredRegsSubClassMask,
544 .SuperRegIndices: SuperRegIdxSeqs + 2,
545 .LaneMask: LaneBitmask(0x0000000000000001),
546 .AllocationPriority: 0,
547 .GlobalPriority: false,
548 .TSFlags: 0x00, /* TSFlags */
549 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
550 .CoveredBySubRegs: false, /* CoveredBySubRegs */
551 .SuperClasses: nullptr, .SuperClassesSize: 0,
552 .OrderFunc: nullptr
553 };
554
555 extern const TargetRegisterClass V62Regs_with_isub_hiRegClass = {
556 .MC: &HexagonMCRegisterClasses[V62Regs_with_isub_hiRegClassID],
557 .SubClassMask: V62Regs_with_isub_hiSubClassMask,
558 .SuperRegIndices: SuperRegIdxSeqs + 2,
559 .LaneMask: LaneBitmask(0x0000000000000003),
560 .AllocationPriority: 0,
561 .GlobalPriority: false,
562 .TSFlags: 0x00, /* TSFlags */
563 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
564 .CoveredBySubRegs: true, /* CoveredBySubRegs */
565 .SuperClasses: V62Regs_with_isub_hiSuperclasses, .SuperClassesSize: 1,
566 .OrderFunc: nullptr
567 };
568
569 extern const TargetRegisterClass ModRegsRegClass = {
570 .MC: &HexagonMCRegisterClasses[ModRegsRegClassID],
571 .SubClassMask: ModRegsSubClassMask,
572 .SuperRegIndices: SuperRegIdxSeqs + 0,
573 .LaneMask: LaneBitmask(0x0000000000000001),
574 .AllocationPriority: 0,
575 .GlobalPriority: false,
576 .TSFlags: 0x00, /* TSFlags */
577 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
578 .CoveredBySubRegs: false, /* CoveredBySubRegs */
579 .SuperClasses: ModRegsSuperclasses, .SuperClassesSize: 1,
580 .OrderFunc: nullptr
581 };
582
583 extern const TargetRegisterClass CtrRegs_with_subreg_overflowRegClass = {
584 .MC: &HexagonMCRegisterClasses[CtrRegs_with_subreg_overflowRegClassID],
585 .SubClassMask: CtrRegs_with_subreg_overflowSubClassMask,
586 .SuperRegIndices: SuperRegIdxSeqs + 2,
587 .LaneMask: LaneBitmask(0x0000000000000004),
588 .AllocationPriority: 0,
589 .GlobalPriority: false,
590 .TSFlags: 0x00, /* TSFlags */
591 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
592 .CoveredBySubRegs: false, /* CoveredBySubRegs */
593 .SuperClasses: CtrRegs_with_subreg_overflowSuperclasses, .SuperClassesSize: 1,
594 .OrderFunc: nullptr
595 };
596
597 extern const TargetRegisterClass V65RegsRegClass = {
598 .MC: &HexagonMCRegisterClasses[V65RegsRegClassID],
599 .SubClassMask: V65RegsSubClassMask,
600 .SuperRegIndices: SuperRegIdxSeqs + 2,
601 .LaneMask: LaneBitmask(0x0000000000000001),
602 .AllocationPriority: 0,
603 .GlobalPriority: false,
604 .TSFlags: 0x00, /* TSFlags */
605 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
606 .CoveredBySubRegs: false, /* CoveredBySubRegs */
607 .SuperClasses: nullptr, .SuperClassesSize: 0,
608 .OrderFunc: nullptr
609 };
610
611 extern const TargetRegisterClass SysRegs64RegClass = {
612 .MC: &HexagonMCRegisterClasses[SysRegs64RegClassID],
613 .SubClassMask: SysRegs64SubClassMask,
614 .SuperRegIndices: SuperRegIdxSeqs + 2,
615 .LaneMask: LaneBitmask(0x0000000000000003),
616 .AllocationPriority: 0,
617 .GlobalPriority: false,
618 .TSFlags: 0x00, /* TSFlags */
619 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
620 .CoveredBySubRegs: true, /* CoveredBySubRegs */
621 .SuperClasses: nullptr, .SuperClassesSize: 0,
622 .OrderFunc: nullptr
623 };
624
625 extern const TargetRegisterClass DoubleRegsRegClass = {
626 .MC: &HexagonMCRegisterClasses[DoubleRegsRegClassID],
627 .SubClassMask: DoubleRegsSubClassMask,
628 .SuperRegIndices: SuperRegIdxSeqs + 2,
629 .LaneMask: LaneBitmask(0x0000000000000003),
630 .AllocationPriority: 0,
631 .GlobalPriority: false,
632 .TSFlags: 0x00, /* TSFlags */
633 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
634 .CoveredBySubRegs: true, /* CoveredBySubRegs */
635 .SuperClasses: nullptr, .SuperClassesSize: 0,
636 .OrderFunc: nullptr
637 };
638
639 extern const TargetRegisterClass GuestRegs64RegClass = {
640 .MC: &HexagonMCRegisterClasses[GuestRegs64RegClassID],
641 .SubClassMask: GuestRegs64SubClassMask,
642 .SuperRegIndices: SuperRegIdxSeqs + 2,
643 .LaneMask: LaneBitmask(0x0000000000000003),
644 .AllocationPriority: 0,
645 .GlobalPriority: false,
646 .TSFlags: 0x00, /* TSFlags */
647 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
648 .CoveredBySubRegs: true, /* CoveredBySubRegs */
649 .SuperClasses: nullptr, .SuperClassesSize: 0,
650 .OrderFunc: nullptr
651 };
652
653 extern const TargetRegisterClass VectRegRevRegClass = {
654 .MC: &HexagonMCRegisterClasses[VectRegRevRegClassID],
655 .SubClassMask: VectRegRevSubClassMask,
656 .SuperRegIndices: SuperRegIdxSeqs + 2,
657 .LaneMask: LaneBitmask(0x0000000000000038),
658 .AllocationPriority: 0,
659 .GlobalPriority: false,
660 .TSFlags: 0x00, /* TSFlags */
661 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
662 .CoveredBySubRegs: true, /* CoveredBySubRegs */
663 .SuperClasses: nullptr, .SuperClassesSize: 0,
664 .OrderFunc: nullptr
665 };
666
667 extern const TargetRegisterClass CtrRegs64RegClass = {
668 .MC: &HexagonMCRegisterClasses[CtrRegs64RegClassID],
669 .SubClassMask: CtrRegs64SubClassMask,
670 .SuperRegIndices: SuperRegIdxSeqs + 2,
671 .LaneMask: LaneBitmask(0x0000000000000003),
672 .AllocationPriority: 0,
673 .GlobalPriority: false,
674 .TSFlags: 0x00, /* TSFlags */
675 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
676 .CoveredBySubRegs: true, /* CoveredBySubRegs */
677 .SuperClasses: nullptr, .SuperClassesSize: 0,
678 .OrderFunc: nullptr
679 };
680
681 extern const TargetRegisterClass GeneralDoubleLow8RegsRegClass = {
682 .MC: &HexagonMCRegisterClasses[GeneralDoubleLow8RegsRegClassID],
683 .SubClassMask: GeneralDoubleLow8RegsSubClassMask,
684 .SuperRegIndices: SuperRegIdxSeqs + 2,
685 .LaneMask: LaneBitmask(0x0000000000000003),
686 .AllocationPriority: 0,
687 .GlobalPriority: false,
688 .TSFlags: 0x00, /* TSFlags */
689 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
690 .CoveredBySubRegs: true, /* CoveredBySubRegs */
691 .SuperClasses: GeneralDoubleLow8RegsSuperclasses, .SuperClassesSize: 1,
692 .OrderFunc: nullptr
693 };
694
695 extern const TargetRegisterClass DoubleRegs_with_isub_hi_in_IntRegsLow8RegClass = {
696 .MC: &HexagonMCRegisterClasses[DoubleRegs_with_isub_hi_in_IntRegsLow8RegClassID],
697 .SubClassMask: DoubleRegs_with_isub_hi_in_IntRegsLow8SubClassMask,
698 .SuperRegIndices: SuperRegIdxSeqs + 2,
699 .LaneMask: LaneBitmask(0x0000000000000003),
700 .AllocationPriority: 0,
701 .GlobalPriority: false,
702 .TSFlags: 0x00, /* TSFlags */
703 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
704 .CoveredBySubRegs: true, /* CoveredBySubRegs */
705 .SuperClasses: DoubleRegs_with_isub_hi_in_IntRegsLow8Superclasses, .SuperClassesSize: 2,
706 .OrderFunc: nullptr
707 };
708
709 extern const TargetRegisterClass CtrRegs64_and_V62RegsRegClass = {
710 .MC: &HexagonMCRegisterClasses[CtrRegs64_and_V62RegsRegClassID],
711 .SubClassMask: CtrRegs64_and_V62RegsSubClassMask,
712 .SuperRegIndices: SuperRegIdxSeqs + 2,
713 .LaneMask: LaneBitmask(0x0000000000000003),
714 .AllocationPriority: 0,
715 .GlobalPriority: false,
716 .TSFlags: 0x00, /* TSFlags */
717 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
718 .CoveredBySubRegs: true, /* CoveredBySubRegs */
719 .SuperClasses: CtrRegs64_and_V62RegsSuperclasses, .SuperClassesSize: 3,
720 .OrderFunc: nullptr
721 };
722
723 extern const TargetRegisterClass CtrRegs64_with_isub_hi_in_ModRegsRegClass = {
724 .MC: &HexagonMCRegisterClasses[CtrRegs64_with_isub_hi_in_ModRegsRegClassID],
725 .SubClassMask: CtrRegs64_with_isub_hi_in_ModRegsSubClassMask,
726 .SuperRegIndices: SuperRegIdxSeqs + 2,
727 .LaneMask: LaneBitmask(0x0000000000000003),
728 .AllocationPriority: 0,
729 .GlobalPriority: false,
730 .TSFlags: 0x00, /* TSFlags */
731 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
732 .CoveredBySubRegs: true, /* CoveredBySubRegs */
733 .SuperClasses: CtrRegs64_with_isub_hi_in_ModRegsSuperclasses, .SuperClassesSize: 1,
734 .OrderFunc: nullptr
735 };
736
737 extern const TargetRegisterClass HvxQRRegClass = {
738 .MC: &HexagonMCRegisterClasses[HvxQRRegClassID],
739 .SubClassMask: HvxQRSubClassMask,
740 .SuperRegIndices: SuperRegIdxSeqs + 2,
741 .LaneMask: LaneBitmask(0x0000000000000001),
742 .AllocationPriority: 0,
743 .GlobalPriority: false,
744 .TSFlags: 0x00, /* TSFlags */
745 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
746 .CoveredBySubRegs: false, /* CoveredBySubRegs */
747 .SuperClasses: nullptr, .SuperClassesSize: 0,
748 .OrderFunc: nullptr
749 };
750
751 extern const TargetRegisterClass HvxVRRegClass = {
752 .MC: &HexagonMCRegisterClasses[HvxVRRegClassID],
753 .SubClassMask: HvxVRSubClassMask,
754 .SuperRegIndices: SuperRegIdxSeqs + 8,
755 .LaneMask: LaneBitmask(0x0000000000000001),
756 .AllocationPriority: 0,
757 .GlobalPriority: false,
758 .TSFlags: 0x00, /* TSFlags */
759 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
760 .CoveredBySubRegs: false, /* CoveredBySubRegs */
761 .SuperClasses: nullptr, .SuperClassesSize: 0,
762 .OrderFunc: nullptr
763 };
764
765 extern const TargetRegisterClass HvxVR_and_V65RegsRegClass = {
766 .MC: &HexagonMCRegisterClasses[HvxVR_and_V65RegsRegClassID],
767 .SubClassMask: HvxVR_and_V65RegsSubClassMask,
768 .SuperRegIndices: SuperRegIdxSeqs + 2,
769 .LaneMask: LaneBitmask(0x0000000000000001),
770 .AllocationPriority: 0,
771 .GlobalPriority: false,
772 .TSFlags: 0x00, /* TSFlags */
773 .HasDisjunctSubRegs: false, /* HasDisjunctSubRegs */
774 .CoveredBySubRegs: false, /* CoveredBySubRegs */
775 .SuperClasses: HvxVR_and_V65RegsSuperclasses, .SuperClassesSize: 2,
776 .OrderFunc: nullptr
777 };
778
779 extern const TargetRegisterClass HvxWRRegClass = {
780 .MC: &HexagonMCRegisterClasses[HvxWRRegClassID],
781 .SubClassMask: HvxWRSubClassMask,
782 .SuperRegIndices: SuperRegIdxSeqs + 5,
783 .LaneMask: LaneBitmask(0x0000000000000038),
784 .AllocationPriority: 0,
785 .GlobalPriority: false,
786 .TSFlags: 0x00, /* TSFlags */
787 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
788 .CoveredBySubRegs: true, /* CoveredBySubRegs */
789 .SuperClasses: nullptr, .SuperClassesSize: 0,
790 .OrderFunc: nullptr
791 };
792
793 extern const TargetRegisterClass HvxWR_and_VectRegRevRegClass = {
794 .MC: &HexagonMCRegisterClasses[HvxWR_and_VectRegRevRegClassID],
795 .SubClassMask: HvxWR_and_VectRegRevSubClassMask,
796 .SuperRegIndices: SuperRegIdxSeqs + 2,
797 .LaneMask: LaneBitmask(0x0000000000000038),
798 .AllocationPriority: 0,
799 .GlobalPriority: false,
800 .TSFlags: 0x00, /* TSFlags */
801 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
802 .CoveredBySubRegs: true, /* CoveredBySubRegs */
803 .SuperClasses: HvxWR_and_VectRegRevSuperclasses, .SuperClassesSize: 2,
804 .OrderFunc: nullptr
805 };
806
807 extern const TargetRegisterClass HvxVQRRegClass = {
808 .MC: &HexagonMCRegisterClasses[HvxVQRRegClassID],
809 .SubClassMask: HvxVQRSubClassMask,
810 .SuperRegIndices: SuperRegIdxSeqs + 2,
811 .LaneMask: LaneBitmask(0x00000000000001F8),
812 .AllocationPriority: 0,
813 .GlobalPriority: false,
814 .TSFlags: 0x00, /* TSFlags */
815 .HasDisjunctSubRegs: true, /* HasDisjunctSubRegs */
816 .CoveredBySubRegs: true, /* CoveredBySubRegs */
817 .SuperClasses: nullptr, .SuperClassesSize: 0,
818 .OrderFunc: nullptr
819 };
820
821
822} // namespace Hexagon
823namespace {
824
825 const TargetRegisterClass *const RegisterClasses[] = {
826 &Hexagon::UsrBitsRegClass,
827 &Hexagon::SysRegsRegClass,
828 &Hexagon::GuestRegsRegClass,
829 &Hexagon::IntRegsRegClass,
830 &Hexagon::CtrRegsRegClass,
831 &Hexagon::GeneralSubRegsRegClass,
832 &Hexagon::V62RegsRegClass,
833 &Hexagon::IntRegsLow8RegClass,
834 &Hexagon::CtrRegs_and_V62RegsRegClass,
835 &Hexagon::PredRegsRegClass,
836 &Hexagon::V62Regs_with_isub_hiRegClass,
837 &Hexagon::ModRegsRegClass,
838 &Hexagon::CtrRegs_with_subreg_overflowRegClass,
839 &Hexagon::V65RegsRegClass,
840 &Hexagon::SysRegs64RegClass,
841 &Hexagon::DoubleRegsRegClass,
842 &Hexagon::GuestRegs64RegClass,
843 &Hexagon::VectRegRevRegClass,
844 &Hexagon::CtrRegs64RegClass,
845 &Hexagon::GeneralDoubleLow8RegsRegClass,
846 &Hexagon::DoubleRegs_with_isub_hi_in_IntRegsLow8RegClass,
847 &Hexagon::CtrRegs64_and_V62RegsRegClass,
848 &Hexagon::CtrRegs64_with_isub_hi_in_ModRegsRegClass,
849 &Hexagon::HvxQRRegClass,
850 &Hexagon::HvxVRRegClass,
851 &Hexagon::HvxVR_and_V65RegsRegClass,
852 &Hexagon::HvxWRRegClass,
853 &Hexagon::HvxWR_and_VectRegRevRegClass,
854 &Hexagon::HvxVQRRegClass,
855 };
856} // namespace
857
858static const uint8_t CostPerUseTable[] = {
8590, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, };
860
861
862static const bool InAllocatableClassTable[] = {
863false, 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, 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, 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, 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, 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, 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, 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, };
864
865
866static const TargetRegisterInfoDesc HexagonRegInfoDesc = { // Extra Descriptors
867.CostPerUse: CostPerUseTable, .NumCosts: 1, .InAllocatableClass: InAllocatableClassTable};
868
869unsigned HexagonGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
870 static const uint8_t RowMap[11] = {
871 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0,
872 };
873 static const uint8_t Rows[2][11] = {
874 { 0, 0, 0, Hexagon::wsub_hi_then_vsub_fake, Hexagon::wsub_hi_then_vsub_hi, Hexagon::wsub_hi_then_vsub_lo, 0, 0, 0, 0, 0, },
875 { 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, 0, 0, 0, 0, 0, },
876 };
877
878 --IdxA; assert(IdxA < 11); (void) IdxA;
879 --IdxB; assert(IdxB < 11);
880 return Rows[RowMap[IdxA]][IdxB];
881}
882
883unsigned HexagonGenRegisterInfo::reverseComposeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
884 static const uint8_t Table[11][11] = {
885 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
886 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
887 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
888 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
889 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
890 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
891 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
892 { 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, 0, 0, 0, 0, 0, },
893 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
894 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
895 { 0, 0, 0, 0, 0, 0, 0, 0, Hexagon::vsub_fake, Hexagon::vsub_hi, Hexagon::vsub_lo, },
896 };
897
898 --IdxA; assert(IdxA < 11);
899 --IdxB; assert(IdxB < 11);
900 return Table[IdxA][IdxB];
901 }
902
903 struct MaskRolOp {
904 LaneBitmask Mask;
905 uint8_t RotateLeft;
906 };
907 static const MaskRolOp LaneMaskComposeSequences[] = {
908 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 0 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 0
909 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 1 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 2
910 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 2 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 4
911 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 3 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 6
912 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 4 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 8
913 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 5 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 10
914 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 6 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 12
915 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 7 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 }, // Sequence 14
916 { .Mask: LaneBitmask(0xFFFFFFFFFFFFFFFF), .RotateLeft: 8 }, { .Mask: LaneBitmask::getNone(), .RotateLeft: 0 } // Sequence 16
917 };
918 static const uint8_t CompositeSequences[] = {
919 0, // to isub_hi
920 2, // to isub_lo
921 4, // to subreg_overflow
922 6, // to vsub_fake
923 8, // to vsub_hi
924 10, // to vsub_lo
925 6, // to wsub_hi
926 0, // to wsub_lo
927 12, // to wsub_hi_then_vsub_fake
928 14, // to wsub_hi_then_vsub_hi
929 16 // to wsub_hi_then_vsub_lo
930 };
931
932LaneBitmask HexagonGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
933 --IdxA; assert(IdxA < 11 && "Subregister index out of bounds");
934 LaneBitmask Result;
935 for (const MaskRolOp *Ops =
936 &LaneMaskComposeSequences[CompositeSequences[IdxA]];
937 Ops->Mask.any(); ++Ops) {
938 LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
939 if (unsigned S = Ops->RotateLeft)
940 Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
941 else
942 Result |= LaneBitmask(M);
943 }
944 return Result;
945}
946
947LaneBitmask HexagonGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
948 LaneMask &= getSubRegIndexLaneMask(SubIdx: IdxA);
949 --IdxA; assert(IdxA < 11 && "Subregister index out of bounds");
950 LaneBitmask Result;
951 for (const MaskRolOp *Ops =
952 &LaneMaskComposeSequences[CompositeSequences[IdxA]];
953 Ops->Mask.any(); ++Ops) {
954 LaneBitmask::Type M = LaneMask.getAsInteger();
955 if (unsigned S = Ops->RotateLeft)
956 Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
957 else
958 Result |= LaneBitmask(M);
959 }
960 return Result;
961}
962
963const TargetRegisterClass *HexagonGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
964 static constexpr uint8_t Table[29][11] = {
965 { // UsrBits
966 0, // isub_hi
967 0, // isub_lo
968 0, // subreg_overflow
969 0, // vsub_fake
970 0, // vsub_hi
971 0, // vsub_lo
972 0, // wsub_hi
973 0, // wsub_lo
974 0, // wsub_hi_then_vsub_fake
975 0, // wsub_hi_then_vsub_hi
976 0, // wsub_hi_then_vsub_lo
977 },
978 { // SysRegs
979 0, // isub_hi
980 0, // isub_lo
981 0, // subreg_overflow
982 0, // vsub_fake
983 0, // vsub_hi
984 0, // vsub_lo
985 0, // wsub_hi
986 0, // wsub_lo
987 0, // wsub_hi_then_vsub_fake
988 0, // wsub_hi_then_vsub_hi
989 0, // wsub_hi_then_vsub_lo
990 },
991 { // GuestRegs
992 0, // isub_hi
993 0, // isub_lo
994 0, // subreg_overflow
995 0, // vsub_fake
996 0, // vsub_hi
997 0, // vsub_lo
998 0, // wsub_hi
999 0, // wsub_lo
1000 0, // wsub_hi_then_vsub_fake
1001 0, // wsub_hi_then_vsub_hi
1002 0, // wsub_hi_then_vsub_lo
1003 },
1004 { // IntRegs
1005 0, // isub_hi
1006 0, // isub_lo
1007 0, // subreg_overflow
1008 0, // vsub_fake
1009 0, // vsub_hi
1010 0, // vsub_lo
1011 0, // wsub_hi
1012 0, // wsub_lo
1013 0, // wsub_hi_then_vsub_fake
1014 0, // wsub_hi_then_vsub_hi
1015 0, // wsub_hi_then_vsub_lo
1016 },
1017 { // CtrRegs
1018 0, // isub_hi
1019 0, // isub_lo
1020 13, // subreg_overflow -> CtrRegs_with_subreg_overflow
1021 0, // vsub_fake
1022 0, // vsub_hi
1023 0, // vsub_lo
1024 0, // wsub_hi
1025 0, // wsub_lo
1026 0, // wsub_hi_then_vsub_fake
1027 0, // wsub_hi_then_vsub_hi
1028 0, // wsub_hi_then_vsub_lo
1029 },
1030 { // GeneralSubRegs
1031 0, // isub_hi
1032 0, // isub_lo
1033 0, // subreg_overflow
1034 0, // vsub_fake
1035 0, // vsub_hi
1036 0, // vsub_lo
1037 0, // wsub_hi
1038 0, // wsub_lo
1039 0, // wsub_hi_then_vsub_fake
1040 0, // wsub_hi_then_vsub_hi
1041 0, // wsub_hi_then_vsub_lo
1042 },
1043 { // V62Regs
1044 11, // isub_hi -> V62Regs_with_isub_hi
1045 11, // isub_lo -> V62Regs_with_isub_hi
1046 0, // subreg_overflow
1047 0, // vsub_fake
1048 0, // vsub_hi
1049 0, // vsub_lo
1050 0, // wsub_hi
1051 0, // wsub_lo
1052 0, // wsub_hi_then_vsub_fake
1053 0, // wsub_hi_then_vsub_hi
1054 0, // wsub_hi_then_vsub_lo
1055 },
1056 { // IntRegsLow8
1057 0, // isub_hi
1058 0, // isub_lo
1059 0, // subreg_overflow
1060 0, // vsub_fake
1061 0, // vsub_hi
1062 0, // vsub_lo
1063 0, // wsub_hi
1064 0, // wsub_lo
1065 0, // wsub_hi_then_vsub_fake
1066 0, // wsub_hi_then_vsub_hi
1067 0, // wsub_hi_then_vsub_lo
1068 },
1069 { // CtrRegs_and_V62Regs
1070 0, // isub_hi
1071 0, // isub_lo
1072 0, // subreg_overflow
1073 0, // vsub_fake
1074 0, // vsub_hi
1075 0, // vsub_lo
1076 0, // wsub_hi
1077 0, // wsub_lo
1078 0, // wsub_hi_then_vsub_fake
1079 0, // wsub_hi_then_vsub_hi
1080 0, // wsub_hi_then_vsub_lo
1081 },
1082 { // PredRegs
1083 0, // isub_hi
1084 0, // isub_lo
1085 0, // subreg_overflow
1086 0, // vsub_fake
1087 0, // vsub_hi
1088 0, // vsub_lo
1089 0, // wsub_hi
1090 0, // wsub_lo
1091 0, // wsub_hi_then_vsub_fake
1092 0, // wsub_hi_then_vsub_hi
1093 0, // wsub_hi_then_vsub_lo
1094 },
1095 { // V62Regs_with_isub_hi
1096 11, // isub_hi -> V62Regs_with_isub_hi
1097 11, // isub_lo -> V62Regs_with_isub_hi
1098 0, // subreg_overflow
1099 0, // vsub_fake
1100 0, // vsub_hi
1101 0, // vsub_lo
1102 0, // wsub_hi
1103 0, // wsub_lo
1104 0, // wsub_hi_then_vsub_fake
1105 0, // wsub_hi_then_vsub_hi
1106 0, // wsub_hi_then_vsub_lo
1107 },
1108 { // ModRegs
1109 0, // isub_hi
1110 0, // isub_lo
1111 0, // subreg_overflow
1112 0, // vsub_fake
1113 0, // vsub_hi
1114 0, // vsub_lo
1115 0, // wsub_hi
1116 0, // wsub_lo
1117 0, // wsub_hi_then_vsub_fake
1118 0, // wsub_hi_then_vsub_hi
1119 0, // wsub_hi_then_vsub_lo
1120 },
1121 { // CtrRegs_with_subreg_overflow
1122 0, // isub_hi
1123 0, // isub_lo
1124 13, // subreg_overflow -> CtrRegs_with_subreg_overflow
1125 0, // vsub_fake
1126 0, // vsub_hi
1127 0, // vsub_lo
1128 0, // wsub_hi
1129 0, // wsub_lo
1130 0, // wsub_hi_then_vsub_fake
1131 0, // wsub_hi_then_vsub_hi
1132 0, // wsub_hi_then_vsub_lo
1133 },
1134 { // V65Regs
1135 0, // isub_hi
1136 0, // isub_lo
1137 0, // subreg_overflow
1138 0, // vsub_fake
1139 0, // vsub_hi
1140 0, // vsub_lo
1141 0, // wsub_hi
1142 0, // wsub_lo
1143 0, // wsub_hi_then_vsub_fake
1144 0, // wsub_hi_then_vsub_hi
1145 0, // wsub_hi_then_vsub_lo
1146 },
1147 { // SysRegs64
1148 15, // isub_hi -> SysRegs64
1149 15, // isub_lo -> SysRegs64
1150 0, // subreg_overflow
1151 0, // vsub_fake
1152 0, // vsub_hi
1153 0, // vsub_lo
1154 0, // wsub_hi
1155 0, // wsub_lo
1156 0, // wsub_hi_then_vsub_fake
1157 0, // wsub_hi_then_vsub_hi
1158 0, // wsub_hi_then_vsub_lo
1159 },
1160 { // DoubleRegs
1161 16, // isub_hi -> DoubleRegs
1162 16, // isub_lo -> DoubleRegs
1163 0, // subreg_overflow
1164 0, // vsub_fake
1165 0, // vsub_hi
1166 0, // vsub_lo
1167 0, // wsub_hi
1168 0, // wsub_lo
1169 0, // wsub_hi_then_vsub_fake
1170 0, // wsub_hi_then_vsub_hi
1171 0, // wsub_hi_then_vsub_lo
1172 },
1173 { // GuestRegs64
1174 17, // isub_hi -> GuestRegs64
1175 17, // isub_lo -> GuestRegs64
1176 0, // subreg_overflow
1177 0, // vsub_fake
1178 0, // vsub_hi
1179 0, // vsub_lo
1180 0, // wsub_hi
1181 0, // wsub_lo
1182 0, // wsub_hi_then_vsub_fake
1183 0, // wsub_hi_then_vsub_hi
1184 0, // wsub_hi_then_vsub_lo
1185 },
1186 { // VectRegRev
1187 0, // isub_hi
1188 0, // isub_lo
1189 0, // subreg_overflow
1190 18, // vsub_fake -> VectRegRev
1191 18, // vsub_hi -> VectRegRev
1192 18, // vsub_lo -> VectRegRev
1193 0, // wsub_hi
1194 0, // wsub_lo
1195 0, // wsub_hi_then_vsub_fake
1196 0, // wsub_hi_then_vsub_hi
1197 0, // wsub_hi_then_vsub_lo
1198 },
1199 { // CtrRegs64
1200 19, // isub_hi -> CtrRegs64
1201 19, // isub_lo -> CtrRegs64
1202 0, // subreg_overflow
1203 0, // vsub_fake
1204 0, // vsub_hi
1205 0, // vsub_lo
1206 0, // wsub_hi
1207 0, // wsub_lo
1208 0, // wsub_hi_then_vsub_fake
1209 0, // wsub_hi_then_vsub_hi
1210 0, // wsub_hi_then_vsub_lo
1211 },
1212 { // GeneralDoubleLow8Regs
1213 20, // isub_hi -> GeneralDoubleLow8Regs
1214 20, // isub_lo -> GeneralDoubleLow8Regs
1215 0, // subreg_overflow
1216 0, // vsub_fake
1217 0, // vsub_hi
1218 0, // vsub_lo
1219 0, // wsub_hi
1220 0, // wsub_lo
1221 0, // wsub_hi_then_vsub_fake
1222 0, // wsub_hi_then_vsub_hi
1223 0, // wsub_hi_then_vsub_lo
1224 },
1225 { // DoubleRegs_with_isub_hi_in_IntRegsLow8
1226 21, // isub_hi -> DoubleRegs_with_isub_hi_in_IntRegsLow8
1227 21, // isub_lo -> DoubleRegs_with_isub_hi_in_IntRegsLow8
1228 0, // subreg_overflow
1229 0, // vsub_fake
1230 0, // vsub_hi
1231 0, // vsub_lo
1232 0, // wsub_hi
1233 0, // wsub_lo
1234 0, // wsub_hi_then_vsub_fake
1235 0, // wsub_hi_then_vsub_hi
1236 0, // wsub_hi_then_vsub_lo
1237 },
1238 { // CtrRegs64_and_V62Regs
1239 22, // isub_hi -> CtrRegs64_and_V62Regs
1240 22, // isub_lo -> CtrRegs64_and_V62Regs
1241 0, // subreg_overflow
1242 0, // vsub_fake
1243 0, // vsub_hi
1244 0, // vsub_lo
1245 0, // wsub_hi
1246 0, // wsub_lo
1247 0, // wsub_hi_then_vsub_fake
1248 0, // wsub_hi_then_vsub_hi
1249 0, // wsub_hi_then_vsub_lo
1250 },
1251 { // CtrRegs64_with_isub_hi_in_ModRegs
1252 23, // isub_hi -> CtrRegs64_with_isub_hi_in_ModRegs
1253 23, // isub_lo -> CtrRegs64_with_isub_hi_in_ModRegs
1254 0, // subreg_overflow
1255 0, // vsub_fake
1256 0, // vsub_hi
1257 0, // vsub_lo
1258 0, // wsub_hi
1259 0, // wsub_lo
1260 0, // wsub_hi_then_vsub_fake
1261 0, // wsub_hi_then_vsub_hi
1262 0, // wsub_hi_then_vsub_lo
1263 },
1264 { // HvxQR
1265 0, // isub_hi
1266 0, // isub_lo
1267 0, // subreg_overflow
1268 0, // vsub_fake
1269 0, // vsub_hi
1270 0, // vsub_lo
1271 0, // wsub_hi
1272 0, // wsub_lo
1273 0, // wsub_hi_then_vsub_fake
1274 0, // wsub_hi_then_vsub_hi
1275 0, // wsub_hi_then_vsub_lo
1276 },
1277 { // HvxVR
1278 0, // isub_hi
1279 0, // isub_lo
1280 0, // subreg_overflow
1281 0, // vsub_fake
1282 0, // vsub_hi
1283 0, // vsub_lo
1284 0, // wsub_hi
1285 0, // wsub_lo
1286 0, // wsub_hi_then_vsub_fake
1287 0, // wsub_hi_then_vsub_hi
1288 0, // wsub_hi_then_vsub_lo
1289 },
1290 { // HvxVR_and_V65Regs
1291 0, // isub_hi
1292 0, // isub_lo
1293 0, // subreg_overflow
1294 0, // vsub_fake
1295 0, // vsub_hi
1296 0, // vsub_lo
1297 0, // wsub_hi
1298 0, // wsub_lo
1299 0, // wsub_hi_then_vsub_fake
1300 0, // wsub_hi_then_vsub_hi
1301 0, // wsub_hi_then_vsub_lo
1302 },
1303 { // HvxWR
1304 0, // isub_hi
1305 0, // isub_lo
1306 0, // subreg_overflow
1307 27, // vsub_fake -> HvxWR
1308 27, // vsub_hi -> HvxWR
1309 27, // vsub_lo -> HvxWR
1310 0, // wsub_hi
1311 0, // wsub_lo
1312 0, // wsub_hi_then_vsub_fake
1313 0, // wsub_hi_then_vsub_hi
1314 0, // wsub_hi_then_vsub_lo
1315 },
1316 { // HvxWR_and_VectRegRev
1317 0, // isub_hi
1318 0, // isub_lo
1319 0, // subreg_overflow
1320 28, // vsub_fake -> HvxWR_and_VectRegRev
1321 28, // vsub_hi -> HvxWR_and_VectRegRev
1322 28, // vsub_lo -> HvxWR_and_VectRegRev
1323 0, // wsub_hi
1324 0, // wsub_lo
1325 0, // wsub_hi_then_vsub_fake
1326 0, // wsub_hi_then_vsub_hi
1327 0, // wsub_hi_then_vsub_lo
1328 },
1329 { // HvxVQR
1330 0, // isub_hi
1331 0, // isub_lo
1332 0, // subreg_overflow
1333 29, // vsub_fake -> HvxVQR
1334 29, // vsub_hi -> HvxVQR
1335 29, // vsub_lo -> HvxVQR
1336 29, // wsub_hi -> HvxVQR
1337 29, // wsub_lo -> HvxVQR
1338 29, // wsub_hi_then_vsub_fake -> HvxVQR
1339 29, // wsub_hi_then_vsub_hi -> HvxVQR
1340 29, // wsub_hi_then_vsub_lo -> HvxVQR
1341 },
1342
1343 };
1344 assert(RC && "Missing regclass");
1345 if (!Idx) return RC;
1346 --Idx;
1347 assert(Idx < 11 && "Bad subreg");
1348 unsigned TV = Table[RC->getID()][Idx];
1349 return TV ? getRegClass(i: TV - 1) : nullptr;
1350}const TargetRegisterClass *HexagonGenRegisterInfo::getSubRegisterClass(const TargetRegisterClass *RC, unsigned Idx) const {
1351 static constexpr uint8_t Table[29][11] = {
1352 { // UsrBits
1353 0, // UsrBits:isub_hi
1354 0, // UsrBits:isub_lo
1355 0, // UsrBits:subreg_overflow
1356 0, // UsrBits:vsub_fake
1357 0, // UsrBits:vsub_hi
1358 0, // UsrBits:vsub_lo
1359 0, // UsrBits:wsub_hi
1360 0, // UsrBits:wsub_lo
1361 0, // UsrBits:wsub_hi_then_vsub_fake
1362 0, // UsrBits:wsub_hi_then_vsub_hi
1363 0, // UsrBits:wsub_hi_then_vsub_lo
1364 },
1365 { // SysRegs
1366 0, // SysRegs:isub_hi
1367 0, // SysRegs:isub_lo
1368 0, // SysRegs:subreg_overflow
1369 0, // SysRegs:vsub_fake
1370 0, // SysRegs:vsub_hi
1371 0, // SysRegs:vsub_lo
1372 0, // SysRegs:wsub_hi
1373 0, // SysRegs:wsub_lo
1374 0, // SysRegs:wsub_hi_then_vsub_fake
1375 0, // SysRegs:wsub_hi_then_vsub_hi
1376 0, // SysRegs:wsub_hi_then_vsub_lo
1377 },
1378 { // GuestRegs
1379 0, // GuestRegs:isub_hi
1380 0, // GuestRegs:isub_lo
1381 0, // GuestRegs:subreg_overflow
1382 0, // GuestRegs:vsub_fake
1383 0, // GuestRegs:vsub_hi
1384 0, // GuestRegs:vsub_lo
1385 0, // GuestRegs:wsub_hi
1386 0, // GuestRegs:wsub_lo
1387 0, // GuestRegs:wsub_hi_then_vsub_fake
1388 0, // GuestRegs:wsub_hi_then_vsub_hi
1389 0, // GuestRegs:wsub_hi_then_vsub_lo
1390 },
1391 { // IntRegs
1392 0, // IntRegs:isub_hi
1393 0, // IntRegs:isub_lo
1394 0, // IntRegs:subreg_overflow
1395 0, // IntRegs:vsub_fake
1396 0, // IntRegs:vsub_hi
1397 0, // IntRegs:vsub_lo
1398 0, // IntRegs:wsub_hi
1399 0, // IntRegs:wsub_lo
1400 0, // IntRegs:wsub_hi_then_vsub_fake
1401 0, // IntRegs:wsub_hi_then_vsub_hi
1402 0, // IntRegs:wsub_hi_then_vsub_lo
1403 },
1404 { // CtrRegs
1405 0, // CtrRegs:isub_hi
1406 0, // CtrRegs:isub_lo
1407 1, // CtrRegs:subreg_overflow -> UsrBits
1408 0, // CtrRegs:vsub_fake
1409 0, // CtrRegs:vsub_hi
1410 0, // CtrRegs:vsub_lo
1411 0, // CtrRegs:wsub_hi
1412 0, // CtrRegs:wsub_lo
1413 0, // CtrRegs:wsub_hi_then_vsub_fake
1414 0, // CtrRegs:wsub_hi_then_vsub_hi
1415 0, // CtrRegs:wsub_hi_then_vsub_lo
1416 },
1417 { // GeneralSubRegs
1418 0, // GeneralSubRegs:isub_hi
1419 0, // GeneralSubRegs:isub_lo
1420 0, // GeneralSubRegs:subreg_overflow
1421 0, // GeneralSubRegs:vsub_fake
1422 0, // GeneralSubRegs:vsub_hi
1423 0, // GeneralSubRegs:vsub_lo
1424 0, // GeneralSubRegs:wsub_hi
1425 0, // GeneralSubRegs:wsub_lo
1426 0, // GeneralSubRegs:wsub_hi_then_vsub_fake
1427 0, // GeneralSubRegs:wsub_hi_then_vsub_hi
1428 0, // GeneralSubRegs:wsub_hi_then_vsub_lo
1429 },
1430 { // V62Regs
1431 9, // V62Regs:isub_hi -> CtrRegs_and_V62Regs
1432 9, // V62Regs:isub_lo -> CtrRegs_and_V62Regs
1433 0, // V62Regs:subreg_overflow
1434 0, // V62Regs:vsub_fake
1435 0, // V62Regs:vsub_hi
1436 0, // V62Regs:vsub_lo
1437 0, // V62Regs:wsub_hi
1438 0, // V62Regs:wsub_lo
1439 0, // V62Regs:wsub_hi_then_vsub_fake
1440 0, // V62Regs:wsub_hi_then_vsub_hi
1441 0, // V62Regs:wsub_hi_then_vsub_lo
1442 },
1443 { // IntRegsLow8
1444 0, // IntRegsLow8:isub_hi
1445 0, // IntRegsLow8:isub_lo
1446 0, // IntRegsLow8:subreg_overflow
1447 0, // IntRegsLow8:vsub_fake
1448 0, // IntRegsLow8:vsub_hi
1449 0, // IntRegsLow8:vsub_lo
1450 0, // IntRegsLow8:wsub_hi
1451 0, // IntRegsLow8:wsub_lo
1452 0, // IntRegsLow8:wsub_hi_then_vsub_fake
1453 0, // IntRegsLow8:wsub_hi_then_vsub_hi
1454 0, // IntRegsLow8:wsub_hi_then_vsub_lo
1455 },
1456 { // CtrRegs_and_V62Regs
1457 0, // CtrRegs_and_V62Regs:isub_hi
1458 0, // CtrRegs_and_V62Regs:isub_lo
1459 0, // CtrRegs_and_V62Regs:subreg_overflow
1460 0, // CtrRegs_and_V62Regs:vsub_fake
1461 0, // CtrRegs_and_V62Regs:vsub_hi
1462 0, // CtrRegs_and_V62Regs:vsub_lo
1463 0, // CtrRegs_and_V62Regs:wsub_hi
1464 0, // CtrRegs_and_V62Regs:wsub_lo
1465 0, // CtrRegs_and_V62Regs:wsub_hi_then_vsub_fake
1466 0, // CtrRegs_and_V62Regs:wsub_hi_then_vsub_hi
1467 0, // CtrRegs_and_V62Regs:wsub_hi_then_vsub_lo
1468 },
1469 { // PredRegs
1470 0, // PredRegs:isub_hi
1471 0, // PredRegs:isub_lo
1472 0, // PredRegs:subreg_overflow
1473 0, // PredRegs:vsub_fake
1474 0, // PredRegs:vsub_hi
1475 0, // PredRegs:vsub_lo
1476 0, // PredRegs:wsub_hi
1477 0, // PredRegs:wsub_lo
1478 0, // PredRegs:wsub_hi_then_vsub_fake
1479 0, // PredRegs:wsub_hi_then_vsub_hi
1480 0, // PredRegs:wsub_hi_then_vsub_lo
1481 },
1482 { // V62Regs_with_isub_hi
1483 9, // V62Regs_with_isub_hi:isub_hi -> CtrRegs_and_V62Regs
1484 9, // V62Regs_with_isub_hi:isub_lo -> CtrRegs_and_V62Regs
1485 0, // V62Regs_with_isub_hi:subreg_overflow
1486 0, // V62Regs_with_isub_hi:vsub_fake
1487 0, // V62Regs_with_isub_hi:vsub_hi
1488 0, // V62Regs_with_isub_hi:vsub_lo
1489 0, // V62Regs_with_isub_hi:wsub_hi
1490 0, // V62Regs_with_isub_hi:wsub_lo
1491 0, // V62Regs_with_isub_hi:wsub_hi_then_vsub_fake
1492 0, // V62Regs_with_isub_hi:wsub_hi_then_vsub_hi
1493 0, // V62Regs_with_isub_hi:wsub_hi_then_vsub_lo
1494 },
1495 { // ModRegs
1496 0, // ModRegs:isub_hi
1497 0, // ModRegs:isub_lo
1498 0, // ModRegs:subreg_overflow
1499 0, // ModRegs:vsub_fake
1500 0, // ModRegs:vsub_hi
1501 0, // ModRegs:vsub_lo
1502 0, // ModRegs:wsub_hi
1503 0, // ModRegs:wsub_lo
1504 0, // ModRegs:wsub_hi_then_vsub_fake
1505 0, // ModRegs:wsub_hi_then_vsub_hi
1506 0, // ModRegs:wsub_hi_then_vsub_lo
1507 },
1508 { // CtrRegs_with_subreg_overflow
1509 0, // CtrRegs_with_subreg_overflow:isub_hi
1510 0, // CtrRegs_with_subreg_overflow:isub_lo
1511 1, // CtrRegs_with_subreg_overflow:subreg_overflow -> UsrBits
1512 0, // CtrRegs_with_subreg_overflow:vsub_fake
1513 0, // CtrRegs_with_subreg_overflow:vsub_hi
1514 0, // CtrRegs_with_subreg_overflow:vsub_lo
1515 0, // CtrRegs_with_subreg_overflow:wsub_hi
1516 0, // CtrRegs_with_subreg_overflow:wsub_lo
1517 0, // CtrRegs_with_subreg_overflow:wsub_hi_then_vsub_fake
1518 0, // CtrRegs_with_subreg_overflow:wsub_hi_then_vsub_hi
1519 0, // CtrRegs_with_subreg_overflow:wsub_hi_then_vsub_lo
1520 },
1521 { // V65Regs
1522 0, // V65Regs:isub_hi
1523 0, // V65Regs:isub_lo
1524 0, // V65Regs:subreg_overflow
1525 0, // V65Regs:vsub_fake
1526 0, // V65Regs:vsub_hi
1527 0, // V65Regs:vsub_lo
1528 0, // V65Regs:wsub_hi
1529 0, // V65Regs:wsub_lo
1530 0, // V65Regs:wsub_hi_then_vsub_fake
1531 0, // V65Regs:wsub_hi_then_vsub_hi
1532 0, // V65Regs:wsub_hi_then_vsub_lo
1533 },
1534 { // SysRegs64
1535 2, // SysRegs64:isub_hi -> SysRegs
1536 2, // SysRegs64:isub_lo -> SysRegs
1537 0, // SysRegs64:subreg_overflow
1538 0, // SysRegs64:vsub_fake
1539 0, // SysRegs64:vsub_hi
1540 0, // SysRegs64:vsub_lo
1541 0, // SysRegs64:wsub_hi
1542 0, // SysRegs64:wsub_lo
1543 0, // SysRegs64:wsub_hi_then_vsub_fake
1544 0, // SysRegs64:wsub_hi_then_vsub_hi
1545 0, // SysRegs64:wsub_hi_then_vsub_lo
1546 },
1547 { // DoubleRegs
1548 4, // DoubleRegs:isub_hi -> IntRegs
1549 4, // DoubleRegs:isub_lo -> IntRegs
1550 0, // DoubleRegs:subreg_overflow
1551 0, // DoubleRegs:vsub_fake
1552 0, // DoubleRegs:vsub_hi
1553 0, // DoubleRegs:vsub_lo
1554 0, // DoubleRegs:wsub_hi
1555 0, // DoubleRegs:wsub_lo
1556 0, // DoubleRegs:wsub_hi_then_vsub_fake
1557 0, // DoubleRegs:wsub_hi_then_vsub_hi
1558 0, // DoubleRegs:wsub_hi_then_vsub_lo
1559 },
1560 { // GuestRegs64
1561 3, // GuestRegs64:isub_hi -> GuestRegs
1562 3, // GuestRegs64:isub_lo -> GuestRegs
1563 0, // GuestRegs64:subreg_overflow
1564 0, // GuestRegs64:vsub_fake
1565 0, // GuestRegs64:vsub_hi
1566 0, // GuestRegs64:vsub_lo
1567 0, // GuestRegs64:wsub_hi
1568 0, // GuestRegs64:wsub_lo
1569 0, // GuestRegs64:wsub_hi_then_vsub_fake
1570 0, // GuestRegs64:wsub_hi_then_vsub_hi
1571 0, // GuestRegs64:wsub_hi_then_vsub_lo
1572 },
1573 { // VectRegRev
1574 0, // VectRegRev:isub_hi
1575 0, // VectRegRev:isub_lo
1576 0, // VectRegRev:subreg_overflow
1577 0, // VectRegRev:vsub_fake
1578 25, // VectRegRev:vsub_hi -> HvxVR
1579 25, // VectRegRev:vsub_lo -> HvxVR
1580 0, // VectRegRev:wsub_hi
1581 0, // VectRegRev:wsub_lo
1582 0, // VectRegRev:wsub_hi_then_vsub_fake
1583 0, // VectRegRev:wsub_hi_then_vsub_hi
1584 0, // VectRegRev:wsub_hi_then_vsub_lo
1585 },
1586 { // CtrRegs64
1587 5, // CtrRegs64:isub_hi -> CtrRegs
1588 5, // CtrRegs64:isub_lo -> CtrRegs
1589 0, // CtrRegs64:subreg_overflow
1590 0, // CtrRegs64:vsub_fake
1591 0, // CtrRegs64:vsub_hi
1592 0, // CtrRegs64:vsub_lo
1593 0, // CtrRegs64:wsub_hi
1594 0, // CtrRegs64:wsub_lo
1595 0, // CtrRegs64:wsub_hi_then_vsub_fake
1596 0, // CtrRegs64:wsub_hi_then_vsub_hi
1597 0, // CtrRegs64:wsub_hi_then_vsub_lo
1598 },
1599 { // GeneralDoubleLow8Regs
1600 6, // GeneralDoubleLow8Regs:isub_hi -> GeneralSubRegs
1601 6, // GeneralDoubleLow8Regs:isub_lo -> GeneralSubRegs
1602 0, // GeneralDoubleLow8Regs:subreg_overflow
1603 0, // GeneralDoubleLow8Regs:vsub_fake
1604 0, // GeneralDoubleLow8Regs:vsub_hi
1605 0, // GeneralDoubleLow8Regs:vsub_lo
1606 0, // GeneralDoubleLow8Regs:wsub_hi
1607 0, // GeneralDoubleLow8Regs:wsub_lo
1608 0, // GeneralDoubleLow8Regs:wsub_hi_then_vsub_fake
1609 0, // GeneralDoubleLow8Regs:wsub_hi_then_vsub_hi
1610 0, // GeneralDoubleLow8Regs:wsub_hi_then_vsub_lo
1611 },
1612 { // DoubleRegs_with_isub_hi_in_IntRegsLow8
1613 8, // DoubleRegs_with_isub_hi_in_IntRegsLow8:isub_hi -> IntRegsLow8
1614 8, // DoubleRegs_with_isub_hi_in_IntRegsLow8:isub_lo -> IntRegsLow8
1615 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:subreg_overflow
1616 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:vsub_fake
1617 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:vsub_hi
1618 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:vsub_lo
1619 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:wsub_hi
1620 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:wsub_lo
1621 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:wsub_hi_then_vsub_fake
1622 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:wsub_hi_then_vsub_hi
1623 0, // DoubleRegs_with_isub_hi_in_IntRegsLow8:wsub_hi_then_vsub_lo
1624 },
1625 { // CtrRegs64_and_V62Regs
1626 9, // CtrRegs64_and_V62Regs:isub_hi -> CtrRegs_and_V62Regs
1627 9, // CtrRegs64_and_V62Regs:isub_lo -> CtrRegs_and_V62Regs
1628 0, // CtrRegs64_and_V62Regs:subreg_overflow
1629 0, // CtrRegs64_and_V62Regs:vsub_fake
1630 0, // CtrRegs64_and_V62Regs:vsub_hi
1631 0, // CtrRegs64_and_V62Regs:vsub_lo
1632 0, // CtrRegs64_and_V62Regs:wsub_hi
1633 0, // CtrRegs64_and_V62Regs:wsub_lo
1634 0, // CtrRegs64_and_V62Regs:wsub_hi_then_vsub_fake
1635 0, // CtrRegs64_and_V62Regs:wsub_hi_then_vsub_hi
1636 0, // CtrRegs64_and_V62Regs:wsub_hi_then_vsub_lo
1637 },
1638 { // CtrRegs64_with_isub_hi_in_ModRegs
1639 12, // CtrRegs64_with_isub_hi_in_ModRegs:isub_hi -> ModRegs
1640 12, // CtrRegs64_with_isub_hi_in_ModRegs:isub_lo -> ModRegs
1641 0, // CtrRegs64_with_isub_hi_in_ModRegs:subreg_overflow
1642 0, // CtrRegs64_with_isub_hi_in_ModRegs:vsub_fake
1643 0, // CtrRegs64_with_isub_hi_in_ModRegs:vsub_hi
1644 0, // CtrRegs64_with_isub_hi_in_ModRegs:vsub_lo
1645 0, // CtrRegs64_with_isub_hi_in_ModRegs:wsub_hi
1646 0, // CtrRegs64_with_isub_hi_in_ModRegs:wsub_lo
1647 0, // CtrRegs64_with_isub_hi_in_ModRegs:wsub_hi_then_vsub_fake
1648 0, // CtrRegs64_with_isub_hi_in_ModRegs:wsub_hi_then_vsub_hi
1649 0, // CtrRegs64_with_isub_hi_in_ModRegs:wsub_hi_then_vsub_lo
1650 },
1651 { // HvxQR
1652 0, // HvxQR:isub_hi
1653 0, // HvxQR:isub_lo
1654 0, // HvxQR:subreg_overflow
1655 0, // HvxQR:vsub_fake
1656 0, // HvxQR:vsub_hi
1657 0, // HvxQR:vsub_lo
1658 0, // HvxQR:wsub_hi
1659 0, // HvxQR:wsub_lo
1660 0, // HvxQR:wsub_hi_then_vsub_fake
1661 0, // HvxQR:wsub_hi_then_vsub_hi
1662 0, // HvxQR:wsub_hi_then_vsub_lo
1663 },
1664 { // HvxVR
1665 0, // HvxVR:isub_hi
1666 0, // HvxVR:isub_lo
1667 0, // HvxVR:subreg_overflow
1668 0, // HvxVR:vsub_fake
1669 0, // HvxVR:vsub_hi
1670 0, // HvxVR:vsub_lo
1671 0, // HvxVR:wsub_hi
1672 0, // HvxVR:wsub_lo
1673 0, // HvxVR:wsub_hi_then_vsub_fake
1674 0, // HvxVR:wsub_hi_then_vsub_hi
1675 0, // HvxVR:wsub_hi_then_vsub_lo
1676 },
1677 { // HvxVR_and_V65Regs
1678 0, // HvxVR_and_V65Regs:isub_hi
1679 0, // HvxVR_and_V65Regs:isub_lo
1680 0, // HvxVR_and_V65Regs:subreg_overflow
1681 0, // HvxVR_and_V65Regs:vsub_fake
1682 0, // HvxVR_and_V65Regs:vsub_hi
1683 0, // HvxVR_and_V65Regs:vsub_lo
1684 0, // HvxVR_and_V65Regs:wsub_hi
1685 0, // HvxVR_and_V65Regs:wsub_lo
1686 0, // HvxVR_and_V65Regs:wsub_hi_then_vsub_fake
1687 0, // HvxVR_and_V65Regs:wsub_hi_then_vsub_hi
1688 0, // HvxVR_and_V65Regs:wsub_hi_then_vsub_lo
1689 },
1690 { // HvxWR
1691 0, // HvxWR:isub_hi
1692 0, // HvxWR:isub_lo
1693 0, // HvxWR:subreg_overflow
1694 0, // HvxWR:vsub_fake
1695 25, // HvxWR:vsub_hi -> HvxVR
1696 25, // HvxWR:vsub_lo -> HvxVR
1697 0, // HvxWR:wsub_hi
1698 0, // HvxWR:wsub_lo
1699 0, // HvxWR:wsub_hi_then_vsub_fake
1700 0, // HvxWR:wsub_hi_then_vsub_hi
1701 0, // HvxWR:wsub_hi_then_vsub_lo
1702 },
1703 { // HvxWR_and_VectRegRev
1704 0, // HvxWR_and_VectRegRev:isub_hi
1705 0, // HvxWR_and_VectRegRev:isub_lo
1706 0, // HvxWR_and_VectRegRev:subreg_overflow
1707 0, // HvxWR_and_VectRegRev:vsub_fake
1708 25, // HvxWR_and_VectRegRev:vsub_hi -> HvxVR
1709 25, // HvxWR_and_VectRegRev:vsub_lo -> HvxVR
1710 0, // HvxWR_and_VectRegRev:wsub_hi
1711 0, // HvxWR_and_VectRegRev:wsub_lo
1712 0, // HvxWR_and_VectRegRev:wsub_hi_then_vsub_fake
1713 0, // HvxWR_and_VectRegRev:wsub_hi_then_vsub_hi
1714 0, // HvxWR_and_VectRegRev:wsub_hi_then_vsub_lo
1715 },
1716 { // HvxVQR
1717 0, // HvxVQR:isub_hi
1718 0, // HvxVQR:isub_lo
1719 0, // HvxVQR:subreg_overflow
1720 0, // HvxVQR:vsub_fake
1721 25, // HvxVQR:vsub_hi -> HvxVR
1722 25, // HvxVQR:vsub_lo -> HvxVR
1723 27, // HvxVQR:wsub_hi -> HvxWR
1724 27, // HvxVQR:wsub_lo -> HvxWR
1725 0, // HvxVQR:wsub_hi_then_vsub_fake
1726 25, // HvxVQR:wsub_hi_then_vsub_hi -> HvxVR
1727 25, // HvxVQR:wsub_hi_then_vsub_lo -> HvxVR
1728 },
1729
1730 };
1731 assert(RC && "Missing regclass");
1732 if (!Idx) return RC;
1733 --Idx;
1734 assert(Idx < 11 && "Bad subreg");
1735 unsigned TV = Table[RC->getID()][Idx];
1736 return TV ? getRegClass(i: TV - 1) : nullptr;
1737}/// Get the weight in units of pressure for this register class.
1738const RegClassWeight &HexagonGenRegisterInfo::
1739getRegClassWeight(const TargetRegisterClass *RC) const {
1740 static const RegClassWeight RCWeightTable[] = {
1741 {.RegWeight: 0, .WeightLimit: 0}, // UsrBits
1742 {.RegWeight: 0, .WeightLimit: 0}, // SysRegs
1743 {.RegWeight: 0, .WeightLimit: 0}, // GuestRegs
1744 {.RegWeight: 1, .WeightLimit: 32}, // IntRegs
1745 {.RegWeight: 0, .WeightLimit: 6}, // CtrRegs
1746 {.RegWeight: 1, .WeightLimit: 16}, // GeneralSubRegs
1747 {.RegWeight: 0, .WeightLimit: 0}, // V62Regs
1748 {.RegWeight: 1, .WeightLimit: 8}, // IntRegsLow8
1749 {.RegWeight: 0, .WeightLimit: 0}, // CtrRegs_and_V62Regs
1750 {.RegWeight: 2, .WeightLimit: 8}, // PredRegs
1751 {.RegWeight: 0, .WeightLimit: 0}, // V62Regs_with_isub_hi
1752 {.RegWeight: 1, .WeightLimit: 2}, // ModRegs
1753 {.RegWeight: 0, .WeightLimit: 0}, // CtrRegs_with_subreg_overflow
1754 {.RegWeight: 1, .WeightLimit: 1}, // V65Regs
1755 {.RegWeight: 0, .WeightLimit: 0}, // SysRegs64
1756 {.RegWeight: 2, .WeightLimit: 32}, // DoubleRegs
1757 {.RegWeight: 0, .WeightLimit: 0}, // GuestRegs64
1758 {.RegWeight: 2, .WeightLimit: 32}, // VectRegRev
1759 {.RegWeight: 0, .WeightLimit: 6}, // CtrRegs64
1760 {.RegWeight: 2, .WeightLimit: 16}, // GeneralDoubleLow8Regs
1761 {.RegWeight: 2, .WeightLimit: 8}, // DoubleRegs_with_isub_hi_in_IntRegsLow8
1762 {.RegWeight: 0, .WeightLimit: 0}, // CtrRegs64_and_V62Regs
1763 {.RegWeight: 2, .WeightLimit: 2}, // CtrRegs64_with_isub_hi_in_ModRegs
1764 {.RegWeight: 1, .WeightLimit: 4}, // HvxQR
1765 {.RegWeight: 1, .WeightLimit: 33}, // HvxVR
1766 {.RegWeight: 1, .WeightLimit: 1}, // HvxVR_and_V65Regs
1767 {.RegWeight: 2, .WeightLimit: 32}, // HvxWR
1768 {.RegWeight: 2, .WeightLimit: 32}, // HvxWR_and_VectRegRev
1769 {.RegWeight: 4, .WeightLimit: 32}, // HvxVQR
1770 };
1771 return RCWeightTable[RC->getID()];
1772}
1773
1774/// Get the weight in units of pressure for this register unit.
1775unsigned HexagonGenRegisterInfo::
1776getRegUnitWeight(MCRegUnit RegUnit) const {
1777 assert(static_cast<unsigned>(RegUnit) < 278 && "invalid register unit");
1778 // All register units have unit weight.
1779 return 1;
1780}
1781
1782
1783// Get the number of dimensions of register pressure.
1784unsigned HexagonGenRegisterInfo::getNumRegPressureSets() const {
1785 return 8;
1786}
1787
1788// Get the name of this register unit pressure set.
1789const char *HexagonGenRegisterInfo::
1790getRegPressureSetName(unsigned Idx) const {
1791 static const char *PressureNameTable[] = {
1792 "HvxVR_and_V65Regs",
1793 "ModRegs",
1794 "HvxQR",
1795 "IntRegsLow8",
1796 "PredRegs",
1797 "GeneralSubRegs",
1798 "IntRegs",
1799 "HvxVR",
1800 };
1801 return PressureNameTable[Idx];
1802}
1803
1804// Get the register unit pressure limit for this dimension.
1805// This limit must be adjusted dynamically for reserved registers.
1806unsigned HexagonGenRegisterInfo::
1807getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
1808 static const uint8_t PressureLimitTable[] = {
1809 1, // 0: HvxVR_and_V65Regs
1810 2, // 1: ModRegs
1811 4, // 2: HvxQR
1812 8, // 3: IntRegsLow8
1813 8, // 4: PredRegs
1814 16, // 5: GeneralSubRegs
1815 32, // 6: IntRegs
1816 33, // 7: HvxVR
1817 };
1818 return PressureLimitTable[Idx];
1819}
1820
1821/// Table of pressure sets per register class or unit.
1822static const int RCSetsTable[] = {
1823 /* 0 */ 1, -1,
1824 /* 2 */ 2, -1,
1825 /* 4 */ 4, -1,
1826 /* 6 */ 3, 5, 6, -1,
1827 /* 10 */ 0, 7, -1,
1828};
1829
1830/// Get the dimensions of register pressure impacted by this register class.
1831/// Returns a -1 terminated array of pressure set IDs
1832const int *HexagonGenRegisterInfo::
1833getRegClassPressureSets(const TargetRegisterClass *RC) const {
1834 static const uint8_t RCSetStartTable[] = {
1835 1,1,1,8,1,7,1,6,1,4,1,0,1,1,1,8,1,11,1,7,6,1,1,2,11,10,11,11,11,};
1836 return &RCSetsTable[RCSetStartTable[RC->getID()]];
1837}
1838
1839/// Get the dimensions of register pressure impacted by this register unit.
1840/// Returns a -1 terminated array of pressure set IDs
1841const int *HexagonGenRegisterInfo::
1842getRegUnitPressureSets(MCRegUnit RegUnit) const {
1843 assert(static_cast<unsigned>(RegUnit) < 278 && "invalid register unit");
1844 static const uint8_t RUSetStartTable[] = {
1845 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,10,1,1,1,1,1,1,1,1,6,6,6,6,6,6,6,6,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,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,0,0,4,4,4,4,4,4,4,4,1,1,1,1,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,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,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,1,};
1846 return &RCSetsTable[RUSetStartTable[static_cast<unsigned>(RegUnit)]];
1847}
1848
1849extern const MCRegisterDesc HexagonRegDesc[];
1850extern const int16_t HexagonRegDiffLists[];
1851extern const LaneBitmask HexagonLaneMaskLists[];
1852extern const char HexagonRegStrings[];
1853extern const char HexagonRegClassStrings[];
1854extern const MCPhysReg HexagonRegUnitRoots[][2];
1855extern const uint16_t HexagonSubRegIdxLists[];
1856extern const uint16_t HexagonRegEncodingTable[];
1857// Hexagon Dwarf<->LLVM register mappings.
1858extern const MCRegisterInfo::DwarfLLVMRegPair HexagonDwarfFlavour0Dwarf2L[];
1859extern const unsigned HexagonDwarfFlavour0Dwarf2LSize;
1860
1861extern const MCRegisterInfo::DwarfLLVMRegPair HexagonEHFlavour0Dwarf2L[];
1862extern const unsigned HexagonEHFlavour0Dwarf2LSize;
1863
1864extern const MCRegisterInfo::DwarfLLVMRegPair HexagonDwarfFlavour0L2Dwarf[];
1865extern const unsigned HexagonDwarfFlavour0L2DwarfSize;
1866
1867extern const MCRegisterInfo::DwarfLLVMRegPair HexagonEHFlavour0L2Dwarf[];
1868extern const unsigned HexagonEHFlavour0L2DwarfSize;
1869
1870
1871HexagonGenRegisterInfo::
1872HexagonGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour,
1873 unsigned PC, unsigned HwMode)
1874 : TargetRegisterInfo(&HexagonRegInfoDesc, RegisterClasses, RegisterClasses+29,
1875 HexagonSubRegIndexStrings, HexagonSubRegIndexNameOffsets,
1876 SubRegIdxRangeTable, SubRegIndexLaneMaskTable,
1877
1878 LaneBitmask(0xFFFFFFFFFFFFFFFB), RegClassInfos, VTLists, HwMode) {
1879 InitMCRegisterInfo(D: HexagonRegDesc, NR: 398, RA, PC,
1880 C: HexagonMCRegisterClasses, NC: 29,
1881 RURoots: HexagonRegUnitRoots,
1882 NRU: 278,
1883 DL: HexagonRegDiffLists,
1884 RUMS: HexagonLaneMaskLists,
1885 Strings: HexagonRegStrings,
1886 ClassStrings: HexagonRegClassStrings,
1887 SubIndices: HexagonSubRegIdxLists,
1888 NumIndices: 12,
1889 RET: HexagonRegEncodingTable,
1890 RUI: nullptr);
1891
1892 switch (DwarfFlavour) {
1893 default:
1894 llvm_unreachable("Unknown DWARF flavour");
1895 case 0:
1896 mapDwarfRegsToLLVMRegs(Map: HexagonDwarfFlavour0Dwarf2L, Size: HexagonDwarfFlavour0Dwarf2LSize, isEH: false);
1897 break;
1898 }
1899 switch (EHFlavour) {
1900 default:
1901 llvm_unreachable("Unknown DWARF flavour");
1902 case 0:
1903 mapDwarfRegsToLLVMRegs(Map: HexagonEHFlavour0Dwarf2L, Size: HexagonEHFlavour0Dwarf2LSize, isEH: true);
1904 break;
1905 }
1906 switch (DwarfFlavour) {
1907 default:
1908 llvm_unreachable("Unknown DWARF flavour");
1909 case 0:
1910 mapLLVMRegsToDwarfRegs(Map: HexagonDwarfFlavour0L2Dwarf, Size: HexagonDwarfFlavour0L2DwarfSize, isEH: false);
1911 break;
1912 }
1913 switch (EHFlavour) {
1914 default:
1915 llvm_unreachable("Unknown DWARF flavour");
1916 case 0:
1917 mapLLVMRegsToDwarfRegs(Map: HexagonEHFlavour0L2Dwarf, Size: HexagonEHFlavour0L2DwarfSize, isEH: true);
1918 break;
1919 }
1920}
1921
1922static const MCPhysReg HexagonCSR_SaveList[] = { Hexagon::R16, Hexagon::R17, Hexagon::R18, Hexagon::R19, Hexagon::R20, Hexagon::R21, Hexagon::R22, Hexagon::R23, Hexagon::R24, Hexagon::R25, Hexagon::R26, Hexagon::R27, 0 };
1923static const uint32_t HexagonCSR_RegMask[] = { 0x00000000, 0x00000000, 0x0000007e, 0x00000000, 0x0003ffc0, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, };
1924
1925
1926ArrayRef<const uint32_t *> HexagonGenRegisterInfo::getRegMasks() const {
1927 static const uint32_t *const Masks[] = {
1928 HexagonCSR_RegMask,
1929 };
1930 return ArrayRef(Masks);
1931}
1932
1933bool HexagonGenRegisterInfo::
1934isGeneralPurposeRegister(const MachineFunction &MF, MCRegister PhysReg) const {
1935 return
1936 false;
1937}
1938
1939bool HexagonGenRegisterInfo::
1940isGeneralPurposeRegisterClass(const TargetRegisterClass *RC) const {
1941 return
1942 false;
1943}
1944
1945bool HexagonGenRegisterInfo::
1946isFixedRegister(const MachineFunction &MF, MCRegister PhysReg) const {
1947 return
1948 false;
1949}
1950
1951bool HexagonGenRegisterInfo::
1952isArgumentRegister(const MachineFunction &MF, MCRegister PhysReg) const {
1953 return
1954 false;
1955}
1956
1957bool HexagonGenRegisterInfo::
1958isConstantPhysReg(MCRegister PhysReg) const {
1959 return
1960 false;
1961}
1962
1963ArrayRef<const char *> HexagonGenRegisterInfo::getRegMaskNames() const {
1964 static const char *Names[] = {
1965 "HexagonCSR",
1966 };
1967 return ArrayRef(Names);
1968}
1969
1970const HexagonFrameLowering *
1971HexagonGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
1972 return static_cast<const HexagonFrameLowering *>(
1973 MF.getSubtarget().getFrameLowering());
1974}
1975
1976
1977} // namespace llvm
1978