Line data Source code
1 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
2 : |* *|
3 : |* Target Register Enum Values *|
4 : |* *|
5 : |* Automatically generated file, do not edit! *|
6 : |* *|
7 : \*===----------------------------------------------------------------------===*/
8 :
9 :
10 : #ifdef GET_REGINFO_ENUM
11 : #undef GET_REGINFO_ENUM
12 :
13 : namespace llvm {
14 :
15 : class MCRegisterClass;
16 : extern const MCRegisterClass RISCVMCRegisterClasses[];
17 :
18 : namespace RISCV {
19 : enum {
20 : NoRegister,
21 : X0_32 = 1,
22 : X0_64 = 2,
23 : X1_32 = 3,
24 : X1_64 = 4,
25 : X2_32 = 5,
26 : X2_64 = 6,
27 : X3_32 = 7,
28 : X3_64 = 8,
29 : X4_32 = 9,
30 : X4_64 = 10,
31 : X5_32 = 11,
32 : X5_64 = 12,
33 : X6_32 = 13,
34 : X6_64 = 14,
35 : X7_32 = 15,
36 : X7_64 = 16,
37 : X8_32 = 17,
38 : X8_64 = 18,
39 : X9_32 = 19,
40 : X9_64 = 20,
41 : X10_32 = 21,
42 : X10_64 = 22,
43 : X11_32 = 23,
44 : X11_64 = 24,
45 : X12_32 = 25,
46 : X12_64 = 26,
47 : X13_32 = 27,
48 : X13_64 = 28,
49 : X14_32 = 29,
50 : X14_64 = 30,
51 : X15_32 = 31,
52 : X15_64 = 32,
53 : X16_32 = 33,
54 : X16_64 = 34,
55 : X17_32 = 35,
56 : X17_64 = 36,
57 : X18_32 = 37,
58 : X18_64 = 38,
59 : X19_32 = 39,
60 : X19_64 = 40,
61 : X20_32 = 41,
62 : X20_64 = 42,
63 : X21_32 = 43,
64 : X21_64 = 44,
65 : X22_32 = 45,
66 : X22_64 = 46,
67 : X23_32 = 47,
68 : X23_64 = 48,
69 : X24_32 = 49,
70 : X24_64 = 50,
71 : X25_32 = 51,
72 : X25_64 = 52,
73 : X26_32 = 53,
74 : X26_64 = 54,
75 : X27_32 = 55,
76 : X27_64 = 56,
77 : X28_32 = 57,
78 : X28_64 = 58,
79 : X29_32 = 59,
80 : X29_64 = 60,
81 : X30_32 = 61,
82 : X30_64 = 62,
83 : X31_32 = 63,
84 : X31_64 = 64,
85 : NUM_TARGET_REGS // 65
86 : };
87 : } // end namespace RISCV
88 :
89 : // Register classes
90 :
91 : namespace RISCV {
92 : enum {
93 : GPRRegClassID = 0,
94 : GPR64RegClassID = 1,
95 :
96 : };
97 : } // end namespace RISCV
98 :
99 :
100 : // Register alternate name indices
101 :
102 : namespace RISCV {
103 : enum {
104 : ABIRegAltName, // 0
105 : NoRegAltName, // 1
106 : NUM_TARGET_REG_ALT_NAMES = 2
107 : };
108 : } // end namespace RISCV
109 :
110 :
111 : // Subregister indices
112 :
113 : namespace RISCV {
114 : enum {
115 : NoSubRegister,
116 : sub_32, // 1
117 : NUM_TARGET_SUBREGS
118 : };
119 : } // end namespace RISCV
120 :
121 : } // end namespace llvm
122 :
123 : #endif // GET_REGINFO_ENUM
124 :
125 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
126 : |* *|
127 : |* MC Register Information *|
128 : |* *|
129 : |* Automatically generated file, do not edit! *|
130 : |* *|
131 : \*===----------------------------------------------------------------------===*/
132 :
133 :
134 : #ifdef GET_REGINFO_MC_DESC
135 : #undef GET_REGINFO_MC_DESC
136 :
137 : namespace llvm {
138 :
139 : extern const MCPhysReg RISCVRegDiffLists[] = {
140 : /* 0 */ 0, 0,
141 : /* 2 */ 1, 0,
142 : /* 4 */ 2, 0,
143 : /* 6 */ 3, 0,
144 : /* 8 */ 4, 0,
145 : /* 10 */ 5, 0,
146 : /* 12 */ 6, 0,
147 : /* 14 */ 7, 0,
148 : /* 16 */ 8, 0,
149 : /* 18 */ 9, 0,
150 : /* 20 */ 10, 0,
151 : /* 22 */ 11, 0,
152 : /* 24 */ 12, 0,
153 : /* 26 */ 13, 0,
154 : /* 28 */ 14, 0,
155 : /* 30 */ 15, 0,
156 : /* 32 */ 16, 0,
157 : /* 34 */ 17, 0,
158 : /* 36 */ 18, 0,
159 : /* 38 */ 19, 0,
160 : /* 40 */ 20, 0,
161 : /* 42 */ 21, 0,
162 : /* 44 */ 22, 0,
163 : /* 46 */ 23, 0,
164 : /* 48 */ 24, 0,
165 : /* 50 */ 25, 0,
166 : /* 52 */ 26, 0,
167 : /* 54 */ 27, 0,
168 : /* 56 */ 28, 0,
169 : /* 58 */ 29, 0,
170 : /* 60 */ 30, 0,
171 : /* 62 */ 31, 0,
172 : /* 64 */ 65535, 0,
173 : };
174 :
175 : extern const LaneBitmask RISCVLaneMaskLists[] = {
176 : /* 0 */ LaneBitmask(0x00000000), LaneBitmask::getAll(),
177 : /* 2 */ LaneBitmask(0x00000001), LaneBitmask::getAll(),
178 70917 : };
179 :
180 : extern const uint16_t RISCVSubRegIdxLists[] = {
181 : /* 0 */ 1, 0,
182 : };
183 :
184 : extern const MCRegisterInfo::SubRegCoveredBits RISCVSubRegIdxRanges[] = {
185 : { 65535, 65535 },
186 : { 0, 32 }, // sub_32
187 : };
188 :
189 : extern const char RISCVRegStrings[] = {
190 : /* 0 */ 'X', '1', '0', '_', '3', '2', 0,
191 : /* 7 */ 'X', '2', '0', '_', '3', '2', 0,
192 : /* 14 */ 'X', '3', '0', '_', '3', '2', 0,
193 : /* 21 */ 'X', '0', '_', '3', '2', 0,
194 : /* 27 */ 'X', '1', '1', '_', '3', '2', 0,
195 : /* 34 */ 'X', '2', '1', '_', '3', '2', 0,
196 : /* 41 */ 'X', '3', '1', '_', '3', '2', 0,
197 : /* 48 */ 'X', '1', '_', '3', '2', 0,
198 : /* 54 */ 'X', '1', '2', '_', '3', '2', 0,
199 : /* 61 */ 'X', '2', '2', '_', '3', '2', 0,
200 : /* 68 */ 'X', '2', '_', '3', '2', 0,
201 : /* 74 */ 'X', '1', '3', '_', '3', '2', 0,
202 : /* 81 */ 'X', '2', '3', '_', '3', '2', 0,
203 : /* 88 */ 'X', '3', '_', '3', '2', 0,
204 : /* 94 */ 'X', '1', '4', '_', '3', '2', 0,
205 : /* 101 */ 'X', '2', '4', '_', '3', '2', 0,
206 : /* 108 */ 'X', '4', '_', '3', '2', 0,
207 : /* 114 */ 'X', '1', '5', '_', '3', '2', 0,
208 : /* 121 */ 'X', '2', '5', '_', '3', '2', 0,
209 : /* 128 */ 'X', '5', '_', '3', '2', 0,
210 : /* 134 */ 'X', '1', '6', '_', '3', '2', 0,
211 : /* 141 */ 'X', '2', '6', '_', '3', '2', 0,
212 : /* 148 */ 'X', '6', '_', '3', '2', 0,
213 : /* 154 */ 'X', '1', '7', '_', '3', '2', 0,
214 : /* 161 */ 'X', '2', '7', '_', '3', '2', 0,
215 : /* 168 */ 'X', '7', '_', '3', '2', 0,
216 : /* 174 */ 'X', '1', '8', '_', '3', '2', 0,
217 : /* 181 */ 'X', '2', '8', '_', '3', '2', 0,
218 : /* 188 */ 'X', '8', '_', '3', '2', 0,
219 : /* 194 */ 'X', '1', '9', '_', '3', '2', 0,
220 : /* 201 */ 'X', '2', '9', '_', '3', '2', 0,
221 : /* 208 */ 'X', '9', '_', '3', '2', 0,
222 : /* 214 */ 'X', '1', '0', '_', '6', '4', 0,
223 : /* 221 */ 'X', '2', '0', '_', '6', '4', 0,
224 : /* 228 */ 'X', '3', '0', '_', '6', '4', 0,
225 : /* 235 */ 'X', '0', '_', '6', '4', 0,
226 : /* 241 */ 'X', '1', '1', '_', '6', '4', 0,
227 : /* 248 */ 'X', '2', '1', '_', '6', '4', 0,
228 : /* 255 */ 'X', '3', '1', '_', '6', '4', 0,
229 : /* 262 */ 'X', '1', '_', '6', '4', 0,
230 : /* 268 */ 'X', '1', '2', '_', '6', '4', 0,
231 : /* 275 */ 'X', '2', '2', '_', '6', '4', 0,
232 : /* 282 */ 'X', '2', '_', '6', '4', 0,
233 : /* 288 */ 'X', '1', '3', '_', '6', '4', 0,
234 : /* 295 */ 'X', '2', '3', '_', '6', '4', 0,
235 : /* 302 */ 'X', '3', '_', '6', '4', 0,
236 : /* 308 */ 'X', '1', '4', '_', '6', '4', 0,
237 : /* 315 */ 'X', '2', '4', '_', '6', '4', 0,
238 : /* 322 */ 'X', '4', '_', '6', '4', 0,
239 : /* 328 */ 'X', '1', '5', '_', '6', '4', 0,
240 : /* 335 */ 'X', '2', '5', '_', '6', '4', 0,
241 : /* 342 */ 'X', '5', '_', '6', '4', 0,
242 : /* 348 */ 'X', '1', '6', '_', '6', '4', 0,
243 : /* 355 */ 'X', '2', '6', '_', '6', '4', 0,
244 : /* 362 */ 'X', '6', '_', '6', '4', 0,
245 : /* 368 */ 'X', '1', '7', '_', '6', '4', 0,
246 : /* 375 */ 'X', '2', '7', '_', '6', '4', 0,
247 : /* 382 */ 'X', '7', '_', '6', '4', 0,
248 : /* 388 */ 'X', '1', '8', '_', '6', '4', 0,
249 : /* 395 */ 'X', '2', '8', '_', '6', '4', 0,
250 : /* 402 */ 'X', '8', '_', '6', '4', 0,
251 : /* 408 */ 'X', '1', '9', '_', '6', '4', 0,
252 : /* 415 */ 'X', '2', '9', '_', '6', '4', 0,
253 : /* 422 */ 'X', '9', '_', '6', '4', 0,
254 : };
255 :
256 : extern const MCRegisterDesc RISCVRegDesc[] = { // Descriptors
257 : { 6, 0, 0, 0, 0, 0 },
258 : { 21, 1, 2, 1, 0, 0 },
259 : { 235, 64, 1, 0, 0, 2 },
260 : { 48, 1, 2, 1, 32, 0 },
261 : { 262, 64, 1, 0, 32, 2 },
262 : { 68, 1, 2, 1, 64, 0 },
263 : { 282, 64, 1, 0, 64, 2 },
264 : { 88, 1, 2, 1, 96, 0 },
265 : { 302, 64, 1, 0, 96, 2 },
266 : { 108, 1, 2, 1, 128, 0 },
267 : { 322, 64, 1, 0, 128, 2 },
268 : { 128, 1, 2, 1, 160, 0 },
269 : { 342, 64, 1, 0, 160, 2 },
270 : { 148, 1, 2, 1, 192, 0 },
271 : { 362, 64, 1, 0, 192, 2 },
272 : { 168, 1, 2, 1, 224, 0 },
273 : { 382, 64, 1, 0, 224, 2 },
274 : { 188, 1, 2, 1, 256, 0 },
275 : { 402, 64, 1, 0, 256, 2 },
276 : { 208, 1, 2, 1, 288, 0 },
277 : { 422, 64, 1, 0, 288, 2 },
278 : { 0, 1, 2, 1, 320, 0 },
279 : { 214, 64, 1, 0, 320, 2 },
280 : { 27, 1, 2, 1, 352, 0 },
281 : { 241, 64, 1, 0, 352, 2 },
282 : { 54, 1, 2, 1, 384, 0 },
283 : { 268, 64, 1, 0, 384, 2 },
284 : { 74, 1, 2, 1, 416, 0 },
285 : { 288, 64, 1, 0, 416, 2 },
286 : { 94, 1, 2, 1, 448, 0 },
287 : { 308, 64, 1, 0, 448, 2 },
288 : { 114, 1, 2, 1, 480, 0 },
289 : { 328, 64, 1, 0, 480, 2 },
290 : { 134, 1, 2, 1, 512, 0 },
291 : { 348, 64, 1, 0, 512, 2 },
292 : { 154, 1, 2, 1, 544, 0 },
293 : { 368, 64, 1, 0, 544, 2 },
294 : { 174, 1, 2, 1, 576, 0 },
295 : { 388, 64, 1, 0, 576, 2 },
296 : { 194, 1, 2, 1, 608, 0 },
297 : { 408, 64, 1, 0, 608, 2 },
298 : { 7, 1, 2, 1, 640, 0 },
299 : { 221, 64, 1, 0, 640, 2 },
300 : { 34, 1, 2, 1, 672, 0 },
301 : { 248, 64, 1, 0, 672, 2 },
302 : { 61, 1, 2, 1, 704, 0 },
303 : { 275, 64, 1, 0, 704, 2 },
304 : { 81, 1, 2, 1, 736, 0 },
305 : { 295, 64, 1, 0, 736, 2 },
306 : { 101, 1, 2, 1, 768, 0 },
307 : { 315, 64, 1, 0, 768, 2 },
308 : { 121, 1, 2, 1, 800, 0 },
309 : { 335, 64, 1, 0, 800, 2 },
310 : { 141, 1, 2, 1, 832, 0 },
311 : { 355, 64, 1, 0, 832, 2 },
312 : { 161, 1, 2, 1, 864, 0 },
313 : { 375, 64, 1, 0, 864, 2 },
314 : { 181, 1, 2, 1, 896, 0 },
315 : { 395, 64, 1, 0, 896, 2 },
316 : { 201, 1, 2, 1, 928, 0 },
317 : { 415, 64, 1, 0, 928, 2 },
318 : { 14, 1, 2, 1, 960, 0 },
319 : { 228, 64, 1, 0, 960, 2 },
320 : { 41, 1, 2, 1, 992, 0 },
321 : { 255, 64, 1, 0, 992, 2 },
322 : };
323 :
324 : extern const MCPhysReg RISCVRegUnitRoots[][2] = {
325 : { RISCV::X0_32 },
326 : { RISCV::X1_32 },
327 : { RISCV::X2_32 },
328 : { RISCV::X3_32 },
329 : { RISCV::X4_32 },
330 : { RISCV::X5_32 },
331 : { RISCV::X6_32 },
332 : { RISCV::X7_32 },
333 : { RISCV::X8_32 },
334 : { RISCV::X9_32 },
335 : { RISCV::X10_32 },
336 : { RISCV::X11_32 },
337 : { RISCV::X12_32 },
338 : { RISCV::X13_32 },
339 : { RISCV::X14_32 },
340 : { RISCV::X15_32 },
341 : { RISCV::X16_32 },
342 : { RISCV::X17_32 },
343 : { RISCV::X18_32 },
344 : { RISCV::X19_32 },
345 : { RISCV::X20_32 },
346 : { RISCV::X21_32 },
347 : { RISCV::X22_32 },
348 : { RISCV::X23_32 },
349 : { RISCV::X24_32 },
350 : { RISCV::X25_32 },
351 : { RISCV::X26_32 },
352 : { RISCV::X27_32 },
353 : { RISCV::X28_32 },
354 : { RISCV::X29_32 },
355 : { RISCV::X30_32 },
356 : { RISCV::X31_32 },
357 : };
358 :
359 : namespace { // Register classes...
360 : // GPR Register Class...
361 : const MCPhysReg GPR[] = {
362 : RISCV::X0_32, RISCV::X1_32, RISCV::X2_32, RISCV::X3_32, RISCV::X4_32, RISCV::X5_32, RISCV::X6_32, RISCV::X7_32, RISCV::X8_32, RISCV::X9_32, RISCV::X10_32, RISCV::X11_32, RISCV::X12_32, RISCV::X13_32, RISCV::X14_32, RISCV::X15_32, RISCV::X16_32, RISCV::X17_32, RISCV::X18_32, RISCV::X19_32, RISCV::X20_32, RISCV::X21_32, RISCV::X22_32, RISCV::X23_32, RISCV::X24_32, RISCV::X25_32, RISCV::X26_32, RISCV::X27_32, RISCV::X28_32, RISCV::X29_32, RISCV::X30_32, RISCV::X31_32,
363 : };
364 :
365 : // GPR Bit set.
366 : const uint8_t GPRBits[] = {
367 : 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
368 : };
369 :
370 : // GPR64 Register Class...
371 : const MCPhysReg GPR64[] = {
372 : RISCV::X0_64, RISCV::X1_64, RISCV::X2_64, RISCV::X3_64, RISCV::X4_64, RISCV::X5_64, RISCV::X6_64, RISCV::X7_64, RISCV::X8_64, RISCV::X9_64, RISCV::X10_64, RISCV::X11_64, RISCV::X12_64, RISCV::X13_64, RISCV::X14_64, RISCV::X15_64, RISCV::X16_64, RISCV::X17_64, RISCV::X18_64, RISCV::X19_64, RISCV::X20_64, RISCV::X21_64, RISCV::X22_64, RISCV::X23_64, RISCV::X24_64, RISCV::X25_64, RISCV::X26_64, RISCV::X27_64, RISCV::X28_64, RISCV::X29_64, RISCV::X30_64, RISCV::X31_64,
373 : };
374 :
375 : // GPR64 Bit set.
376 : const uint8_t GPR64Bits[] = {
377 : 0x54, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x01,
378 : };
379 :
380 : } // end anonymous namespace
381 :
382 : extern const char RISCVRegClassStrings[] = {
383 : /* 0 */ 'G', 'P', 'R', '6', '4', 0,
384 : /* 6 */ 'G', 'P', 'R', 0,
385 : };
386 :
387 : extern const MCRegisterClass RISCVMCRegisterClasses[] = {
388 : { GPR, GPRBits, 6, 32, sizeof(GPRBits), RISCV::GPRRegClassID, 4, 1, true },
389 : { GPR64, GPR64Bits, 0, 32, sizeof(GPR64Bits), RISCV::GPR64RegClassID, 8, 1, true },
390 : };
391 :
392 : // RISCV Dwarf<->LLVM register mappings.
393 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVDwarfFlavour0Dwarf2L[] = {
394 : { 0U, RISCV::X0_64 },
395 : { 1U, RISCV::X1_64 },
396 : { 2U, RISCV::X2_64 },
397 : { 3U, RISCV::X3_64 },
398 : { 4U, RISCV::X4_64 },
399 : { 5U, RISCV::X5_64 },
400 : { 6U, RISCV::X6_64 },
401 : { 7U, RISCV::X7_64 },
402 : { 8U, RISCV::X8_64 },
403 : { 9U, RISCV::X9_64 },
404 : { 10U, RISCV::X10_64 },
405 : { 11U, RISCV::X11_64 },
406 : { 12U, RISCV::X12_64 },
407 : { 13U, RISCV::X13_64 },
408 : { 14U, RISCV::X14_64 },
409 : { 15U, RISCV::X15_64 },
410 : { 16U, RISCV::X16_64 },
411 : { 17U, RISCV::X17_64 },
412 : { 18U, RISCV::X18_64 },
413 : { 19U, RISCV::X19_64 },
414 : { 20U, RISCV::X20_64 },
415 : { 21U, RISCV::X21_64 },
416 : { 22U, RISCV::X22_64 },
417 : { 23U, RISCV::X23_64 },
418 : { 24U, RISCV::X24_64 },
419 : { 25U, RISCV::X25_64 },
420 : { 26U, RISCV::X26_64 },
421 : { 27U, RISCV::X27_64 },
422 : { 28U, RISCV::X28_64 },
423 : { 29U, RISCV::X29_64 },
424 : { 30U, RISCV::X30_64 },
425 : { 31U, RISCV::X31_64 },
426 : };
427 : extern const unsigned RISCVDwarfFlavour0Dwarf2LSize = array_lengthof(RISCVDwarfFlavour0Dwarf2L);
428 :
429 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVEHFlavour0Dwarf2L[] = {
430 : { 0U, RISCV::X0_64 },
431 : { 1U, RISCV::X1_64 },
432 : { 2U, RISCV::X2_64 },
433 : { 3U, RISCV::X3_64 },
434 : { 4U, RISCV::X4_64 },
435 : { 5U, RISCV::X5_64 },
436 : { 6U, RISCV::X6_64 },
437 : { 7U, RISCV::X7_64 },
438 : { 8U, RISCV::X8_64 },
439 : { 9U, RISCV::X9_64 },
440 : { 10U, RISCV::X10_64 },
441 : { 11U, RISCV::X11_64 },
442 : { 12U, RISCV::X12_64 },
443 : { 13U, RISCV::X13_64 },
444 : { 14U, RISCV::X14_64 },
445 : { 15U, RISCV::X15_64 },
446 : { 16U, RISCV::X16_64 },
447 : { 17U, RISCV::X17_64 },
448 : { 18U, RISCV::X18_64 },
449 : { 19U, RISCV::X19_64 },
450 : { 20U, RISCV::X20_64 },
451 : { 21U, RISCV::X21_64 },
452 : { 22U, RISCV::X22_64 },
453 : { 23U, RISCV::X23_64 },
454 : { 24U, RISCV::X24_64 },
455 : { 25U, RISCV::X25_64 },
456 : { 26U, RISCV::X26_64 },
457 : { 27U, RISCV::X27_64 },
458 : { 28U, RISCV::X28_64 },
459 : { 29U, RISCV::X29_64 },
460 : { 30U, RISCV::X30_64 },
461 : { 31U, RISCV::X31_64 },
462 : };
463 : extern const unsigned RISCVEHFlavour0Dwarf2LSize = array_lengthof(RISCVEHFlavour0Dwarf2L);
464 :
465 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVDwarfFlavour0L2Dwarf[] = {
466 : { RISCV::X0_32, 0U },
467 : { RISCV::X0_64, 0U },
468 : { RISCV::X1_32, 1U },
469 : { RISCV::X1_64, 1U },
470 : { RISCV::X2_32, 2U },
471 : { RISCV::X2_64, 2U },
472 : { RISCV::X3_32, 3U },
473 : { RISCV::X3_64, 3U },
474 : { RISCV::X4_32, 4U },
475 : { RISCV::X4_64, 4U },
476 : { RISCV::X5_32, 5U },
477 : { RISCV::X5_64, 5U },
478 : { RISCV::X6_32, 6U },
479 : { RISCV::X6_64, 6U },
480 : { RISCV::X7_32, 7U },
481 : { RISCV::X7_64, 7U },
482 : { RISCV::X8_32, 8U },
483 : { RISCV::X8_64, 8U },
484 : { RISCV::X9_32, 9U },
485 : { RISCV::X9_64, 9U },
486 : { RISCV::X10_32, 10U },
487 : { RISCV::X10_64, 10U },
488 : { RISCV::X11_32, 11U },
489 : { RISCV::X11_64, 11U },
490 : { RISCV::X12_32, 12U },
491 : { RISCV::X12_64, 12U },
492 : { RISCV::X13_32, 13U },
493 : { RISCV::X13_64, 13U },
494 : { RISCV::X14_32, 14U },
495 : { RISCV::X14_64, 14U },
496 : { RISCV::X15_32, 15U },
497 : { RISCV::X15_64, 15U },
498 : { RISCV::X16_32, 16U },
499 : { RISCV::X16_64, 16U },
500 : { RISCV::X17_32, 17U },
501 : { RISCV::X17_64, 17U },
502 : { RISCV::X18_32, 18U },
503 : { RISCV::X18_64, 18U },
504 : { RISCV::X19_32, 19U },
505 : { RISCV::X19_64, 19U },
506 : { RISCV::X20_32, 20U },
507 : { RISCV::X20_64, 20U },
508 : { RISCV::X21_32, 21U },
509 : { RISCV::X21_64, 21U },
510 : { RISCV::X22_32, 22U },
511 : { RISCV::X22_64, 22U },
512 : { RISCV::X23_32, 23U },
513 : { RISCV::X23_64, 23U },
514 : { RISCV::X24_32, 24U },
515 : { RISCV::X24_64, 24U },
516 : { RISCV::X25_32, 25U },
517 : { RISCV::X25_64, 25U },
518 : { RISCV::X26_32, 26U },
519 : { RISCV::X26_64, 26U },
520 : { RISCV::X27_32, 27U },
521 : { RISCV::X27_64, 27U },
522 : { RISCV::X28_32, 28U },
523 : { RISCV::X28_64, 28U },
524 : { RISCV::X29_32, 29U },
525 : { RISCV::X29_64, 29U },
526 : { RISCV::X30_32, 30U },
527 : { RISCV::X30_64, 30U },
528 : { RISCV::X31_32, 31U },
529 : { RISCV::X31_64, 31U },
530 : };
531 : extern const unsigned RISCVDwarfFlavour0L2DwarfSize = array_lengthof(RISCVDwarfFlavour0L2Dwarf);
532 :
533 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVEHFlavour0L2Dwarf[] = {
534 : { RISCV::X0_32, 0U },
535 : { RISCV::X0_64, 0U },
536 : { RISCV::X1_32, 1U },
537 : { RISCV::X1_64, 1U },
538 : { RISCV::X2_32, 2U },
539 : { RISCV::X2_64, 2U },
540 : { RISCV::X3_32, 3U },
541 : { RISCV::X3_64, 3U },
542 : { RISCV::X4_32, 4U },
543 : { RISCV::X4_64, 4U },
544 : { RISCV::X5_32, 5U },
545 : { RISCV::X5_64, 5U },
546 : { RISCV::X6_32, 6U },
547 : { RISCV::X6_64, 6U },
548 : { RISCV::X7_32, 7U },
549 : { RISCV::X7_64, 7U },
550 : { RISCV::X8_32, 8U },
551 : { RISCV::X8_64, 8U },
552 : { RISCV::X9_32, 9U },
553 : { RISCV::X9_64, 9U },
554 : { RISCV::X10_32, 10U },
555 : { RISCV::X10_64, 10U },
556 : { RISCV::X11_32, 11U },
557 : { RISCV::X11_64, 11U },
558 : { RISCV::X12_32, 12U },
559 : { RISCV::X12_64, 12U },
560 : { RISCV::X13_32, 13U },
561 : { RISCV::X13_64, 13U },
562 : { RISCV::X14_32, 14U },
563 : { RISCV::X14_64, 14U },
564 : { RISCV::X15_32, 15U },
565 : { RISCV::X15_64, 15U },
566 : { RISCV::X16_32, 16U },
567 : { RISCV::X16_64, 16U },
568 : { RISCV::X17_32, 17U },
569 : { RISCV::X17_64, 17U },
570 : { RISCV::X18_32, 18U },
571 : { RISCV::X18_64, 18U },
572 : { RISCV::X19_32, 19U },
573 : { RISCV::X19_64, 19U },
574 : { RISCV::X20_32, 20U },
575 : { RISCV::X20_64, 20U },
576 : { RISCV::X21_32, 21U },
577 : { RISCV::X21_64, 21U },
578 : { RISCV::X22_32, 22U },
579 : { RISCV::X22_64, 22U },
580 : { RISCV::X23_32, 23U },
581 : { RISCV::X23_64, 23U },
582 : { RISCV::X24_32, 24U },
583 : { RISCV::X24_64, 24U },
584 : { RISCV::X25_32, 25U },
585 : { RISCV::X25_64, 25U },
586 : { RISCV::X26_32, 26U },
587 : { RISCV::X26_64, 26U },
588 : { RISCV::X27_32, 27U },
589 : { RISCV::X27_64, 27U },
590 : { RISCV::X28_32, 28U },
591 : { RISCV::X28_64, 28U },
592 : { RISCV::X29_32, 29U },
593 : { RISCV::X29_64, 29U },
594 : { RISCV::X30_32, 30U },
595 : { RISCV::X30_64, 30U },
596 : { RISCV::X31_32, 31U },
597 : { RISCV::X31_64, 31U },
598 : };
599 : extern const unsigned RISCVEHFlavour0L2DwarfSize = array_lengthof(RISCVEHFlavour0L2Dwarf);
600 :
601 : extern const uint16_t RISCVRegEncodingTable[] = {
602 : 0,
603 : 0,
604 : 0,
605 : 1,
606 : 1,
607 : 2,
608 : 2,
609 : 3,
610 : 3,
611 : 4,
612 : 4,
613 : 5,
614 : 5,
615 : 6,
616 : 6,
617 : 7,
618 : 7,
619 : 8,
620 : 8,
621 : 9,
622 : 9,
623 : 10,
624 : 10,
625 : 11,
626 : 11,
627 : 12,
628 : 12,
629 : 13,
630 : 13,
631 : 14,
632 : 14,
633 : 15,
634 : 15,
635 : 16,
636 : 16,
637 : 17,
638 : 17,
639 : 18,
640 : 18,
641 : 19,
642 : 19,
643 : 20,
644 : 20,
645 : 21,
646 : 21,
647 : 22,
648 : 22,
649 : 23,
650 : 23,
651 : 24,
652 : 24,
653 : 25,
654 : 25,
655 : 26,
656 : 26,
657 : 27,
658 : 27,
659 : 28,
660 : 28,
661 : 29,
662 : 29,
663 : 30,
664 : 30,
665 : 31,
666 : 31,
667 : };
668 : static inline void InitRISCVMCRegisterInfo(MCRegisterInfo *RI, unsigned RA, unsigned DwarfFlavour = 0, unsigned EHFlavour = 0, unsigned PC = 0) {
669 : RI->InitMCRegisterInfo(RISCVRegDesc, 65, RA, PC, RISCVMCRegisterClasses, 2, RISCVRegUnitRoots, 32, RISCVRegDiffLists, RISCVLaneMaskLists, RISCVRegStrings, RISCVRegClassStrings, RISCVSubRegIdxLists, 2,
670 0 : RISCVSubRegIdxRanges, RISCVRegEncodingTable);
671 :
672 : switch (DwarfFlavour) {
673 : default:
674 : llvm_unreachable("Unknown DWARF flavour");
675 : case 0:
676 0 : RI->mapDwarfRegsToLLVMRegs(RISCVDwarfFlavour0Dwarf2L, RISCVDwarfFlavour0Dwarf2LSize, false);
677 : break;
678 : }
679 : switch (EHFlavour) {
680 : default:
681 : llvm_unreachable("Unknown DWARF flavour");
682 : case 0:
683 0 : RI->mapDwarfRegsToLLVMRegs(RISCVEHFlavour0Dwarf2L, RISCVEHFlavour0Dwarf2LSize, true);
684 : break;
685 : }
686 : switch (DwarfFlavour) {
687 : default:
688 : llvm_unreachable("Unknown DWARF flavour");
689 : case 0:
690 0 : RI->mapLLVMRegsToDwarfRegs(RISCVDwarfFlavour0L2Dwarf, RISCVDwarfFlavour0L2DwarfSize, false);
691 : break;
692 : }
693 : switch (EHFlavour) {
694 : default:
695 : llvm_unreachable("Unknown DWARF flavour");
696 : case 0:
697 0 : RI->mapLLVMRegsToDwarfRegs(RISCVEHFlavour0L2Dwarf, RISCVEHFlavour0L2DwarfSize, true);
698 : break;
699 : }
700 : }
701 :
702 : } // end namespace llvm
703 :
704 : #endif // GET_REGINFO_MC_DESC
705 :
706 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
707 : |* *|
708 : |* Register Information Header Fragment *|
709 : |* *|
710 : |* Automatically generated file, do not edit! *|
711 : |* *|
712 : \*===----------------------------------------------------------------------===*/
713 :
714 :
715 : #ifdef GET_REGINFO_HEADER
716 : #undef GET_REGINFO_HEADER
717 :
718 : #include "llvm/Target/TargetRegisterInfo.h"
719 :
720 : namespace llvm {
721 :
722 : class RISCVFrameLowering;
723 :
724 : struct RISCVGenRegisterInfo : public TargetRegisterInfo {
725 : explicit RISCVGenRegisterInfo(unsigned RA, unsigned D = 0, unsigned E = 0, unsigned PC = 0);
726 : unsigned composeSubRegIndicesImpl(unsigned, unsigned) const override;
727 : LaneBitmask composeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
728 : LaneBitmask reverseComposeSubRegIndexLaneMaskImpl(unsigned, LaneBitmask) const override;
729 : const TargetRegisterClass *getSubClassWithSubReg(const TargetRegisterClass*, unsigned) const override;
730 : const RegClassWeight &getRegClassWeight(const TargetRegisterClass *RC) const override;
731 : unsigned getRegUnitWeight(unsigned RegUnit) const override;
732 : unsigned getNumRegPressureSets() const override;
733 : const char *getRegPressureSetName(unsigned Idx) const override;
734 : unsigned getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const override;
735 : const int *getRegClassPressureSets(const TargetRegisterClass *RC) const override;
736 : const int *getRegUnitPressureSets(unsigned RegUnit) const override;
737 : ArrayRef<const char *> getRegMaskNames() const override;
738 : ArrayRef<const uint32_t *> getRegMasks() const override;
739 : /// Devirtualized TargetFrameLowering.
740 : static const RISCVFrameLowering *getFrameLowering(
741 : const MachineFunction &MF);
742 : };
743 :
744 : namespace RISCV { // Register classes
745 : extern const TargetRegisterClass GPRRegClass;
746 : extern const TargetRegisterClass GPR64RegClass;
747 : } // end namespace RISCV
748 :
749 : } // end namespace llvm
750 :
751 : #endif // GET_REGINFO_HEADER
752 :
753 : /*===- TableGen'erated file -------------------------------------*- C++ -*-===*\
754 : |* *|
755 : |* Target Register and Register Classes Information *|
756 : |* *|
757 : |* Automatically generated file, do not edit! *|
758 : |* *|
759 : \*===----------------------------------------------------------------------===*/
760 :
761 :
762 : #ifdef GET_REGINFO_TARGET_DESC
763 : #undef GET_REGINFO_TARGET_DESC
764 :
765 : namespace llvm {
766 :
767 : extern const MCRegisterClass RISCVMCRegisterClasses[];
768 :
769 : static const MVT::SimpleValueType VTLists[] = {
770 : /* 0 */ MVT::i32, MVT::Other,
771 : /* 2 */ MVT::i64, MVT::Other,
772 : };
773 :
774 : static const char *const SubRegIndexNameTable[] = { "sub_32", "" };
775 :
776 :
777 : static const LaneBitmask SubRegIndexLaneMaskTable[] = {
778 : LaneBitmask::getAll(),
779 : LaneBitmask(0x00000001), // sub_32
780 : };
781 :
782 :
783 :
784 : static const TargetRegisterClass *const NullRegClasses[] = { nullptr };
785 :
786 : static const uint32_t GPRSubClassMask[] = {
787 : 0x00000001,
788 : 0x00000002, // sub_32
789 : };
790 :
791 : static const uint32_t GPR64SubClassMask[] = {
792 : 0x00000002,
793 : };
794 :
795 : static const uint16_t SuperRegIdxSeqs[] = {
796 : /* 0 */ 1, 0,
797 : };
798 :
799 :
800 : namespace RISCV { // Register class instances
801 : extern const TargetRegisterClass GPRRegClass = {
802 : &RISCVMCRegisterClasses[GPRRegClassID],
803 : 4, /* SpillSize */
804 : 4, /* SpillAlignment */
805 : VTLists + 0,
806 : GPRSubClassMask,
807 : SuperRegIdxSeqs + 0,
808 : LaneBitmask(0x00000001),
809 : 0,
810 : false, /* HasDisjunctSubRegs */
811 : false, /* CoveredBySubRegs */
812 : NullRegClasses,
813 : nullptr
814 : };
815 :
816 : extern const TargetRegisterClass GPR64RegClass = {
817 : &RISCVMCRegisterClasses[GPR64RegClassID],
818 : 8, /* SpillSize */
819 : 8, /* SpillAlignment */
820 : VTLists + 2,
821 : GPR64SubClassMask,
822 : SuperRegIdxSeqs + 1,
823 : LaneBitmask(0x00000001),
824 : 0,
825 : false, /* HasDisjunctSubRegs */
826 : false, /* CoveredBySubRegs */
827 : NullRegClasses,
828 : nullptr
829 : };
830 :
831 : } // end namespace RISCV
832 :
833 : namespace {
834 : const TargetRegisterClass* const RegisterClasses[] = {
835 : &RISCV::GPRRegClass,
836 : &RISCV::GPR64RegClass,
837 : };
838 : } // end anonymous namespace
839 :
840 : static const TargetRegisterInfoDesc RISCVRegInfoDesc[] = { // Extra Descriptors
841 : { 0, false },
842 : { 0, true },
843 : { 0, true },
844 : { 0, true },
845 : { 0, true },
846 : { 0, true },
847 : { 0, true },
848 : { 0, true },
849 : { 0, true },
850 : { 0, true },
851 : { 0, true },
852 : { 0, true },
853 : { 0, true },
854 : { 0, true },
855 : { 0, true },
856 : { 0, true },
857 : { 0, true },
858 : { 0, true },
859 : { 0, true },
860 : { 0, true },
861 : { 0, true },
862 : { 0, true },
863 : { 0, true },
864 : { 0, true },
865 : { 0, true },
866 : { 0, true },
867 : { 0, true },
868 : { 0, true },
869 : { 0, true },
870 : { 0, true },
871 : { 0, true },
872 : { 0, true },
873 : { 0, true },
874 : { 0, true },
875 : { 0, true },
876 : { 0, true },
877 : { 0, true },
878 : { 0, true },
879 : { 0, true },
880 : { 0, true },
881 : { 0, true },
882 : { 0, true },
883 : { 0, true },
884 : { 0, true },
885 : { 0, true },
886 : { 0, true },
887 : { 0, true },
888 : { 0, true },
889 : { 0, true },
890 : { 0, true },
891 : { 0, true },
892 : { 0, true },
893 : { 0, true },
894 : { 0, true },
895 : { 0, true },
896 : { 0, true },
897 : { 0, true },
898 : { 0, true },
899 : { 0, true },
900 : { 0, true },
901 : { 0, true },
902 : { 0, true },
903 : { 0, true },
904 : { 0, true },
905 : { 0, true },
906 : };
907 : unsigned RISCVGenRegisterInfo::composeSubRegIndicesImpl(unsigned IdxA, unsigned IdxB) const {
908 : static const uint8_t Rows[1][1] = {
909 : { 0, },
910 : };
911 :
912 : --IdxA; assert(IdxA < 1);
913 : --IdxB; assert(IdxB < 1);
914 : return Rows[0][IdxB];
915 : }
916 :
917 : struct MaskRolOp {
918 : LaneBitmask Mask;
919 : uint8_t RotateLeft;
920 : };
921 : static const MaskRolOp LaneMaskComposeSequences[] = {
922 : { LaneBitmask(0xFFFFFFFF), 0 }, { LaneBitmask::getNone(), 0 } // Sequence 0
923 : };
924 : static const MaskRolOp *const CompositeSequences[] = {
925 : &LaneMaskComposeSequences[0] // to sub_32
926 : };
927 :
928 : LaneBitmask RISCVGenRegisterInfo::composeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
929 : --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
930 : LaneBitmask Result;
931 : for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
932 : LaneBitmask::Type M = LaneMask.getAsInteger() & Ops->Mask.getAsInteger();
933 : if (unsigned S = Ops->RotateLeft)
934 : Result |= LaneBitmask((M << S) | (M >> (LaneBitmask::BitWidth - S)));
935 : else
936 : Result |= LaneBitmask(M);
937 : }
938 : return Result;
939 : }
940 :
941 : LaneBitmask RISCVGenRegisterInfo::reverseComposeSubRegIndexLaneMaskImpl(unsigned IdxA, LaneBitmask LaneMask) const {
942 : LaneMask &= getSubRegIndexLaneMask(IdxA);
943 : --IdxA; assert(IdxA < 1 && "Subregister index out of bounds");
944 : LaneBitmask Result;
945 : for (const MaskRolOp *Ops = CompositeSequences[IdxA]; Ops->Mask.any(); ++Ops) {
946 : LaneBitmask::Type M = LaneMask.getAsInteger();
947 : if (unsigned S = Ops->RotateLeft)
948 : Result |= LaneBitmask((M >> S) | (M << (LaneBitmask::BitWidth - S)));
949 : else
950 : Result |= LaneBitmask(M);
951 : }
952 : return Result;
953 : }
954 :
955 : const TargetRegisterClass *RISCVGenRegisterInfo::getSubClassWithSubReg(const TargetRegisterClass *RC, unsigned Idx) const {
956 : static const uint8_t Table[2][1] = {
957 : { // GPR
958 : 0, // sub_32
959 : },
960 : { // GPR64
961 : 2, // sub_32 -> GPR64
962 : },
963 : };
964 : assert(RC && "Missing regclass");
965 : if (!Idx) return RC;
966 : --Idx;
967 : assert(Idx < 1 && "Bad subreg");
968 : unsigned TV = Table[RC->getID()][Idx];
969 : return TV ? getRegClass(TV - 1) : nullptr;
970 : }
971 :
972 : /// Get the weight in units of pressure for this register class.
973 : const RegClassWeight &RISCVGenRegisterInfo::
974 : getRegClassWeight(const TargetRegisterClass *RC) const {
975 : static const RegClassWeight RCWeightTable[] = {
976 : {1, 32}, // GPR
977 : {1, 32}, // GPR64
978 : };
979 : return RCWeightTable[RC->getID()];
980 : }
981 :
982 : /// Get the weight in units of pressure for this register unit.
983 : unsigned RISCVGenRegisterInfo::
984 : getRegUnitWeight(unsigned RegUnit) const {
985 : assert(RegUnit < 32 && "invalid register unit");
986 : // All register units have unit weight.
987 : return 1;
988 : }
989 :
990 :
991 : // Get the number of dimensions of register pressure.
992 : unsigned RISCVGenRegisterInfo::getNumRegPressureSets() const {
993 : return 1;
994 : }
995 :
996 : // Get the name of this register unit pressure set.
997 : const char *RISCVGenRegisterInfo::
998 : getRegPressureSetName(unsigned Idx) const {
999 : static const char *const PressureNameTable[] = {
1000 : "GPR",
1001 : };
1002 : return PressureNameTable[Idx];
1003 : }
1004 :
1005 : // Get the register unit pressure limit for this dimension.
1006 : // This limit must be adjusted dynamically for reserved registers.
1007 : unsigned RISCVGenRegisterInfo::
1008 : getRegPressureSetLimit(const MachineFunction &MF, unsigned Idx) const {
1009 : static const uint8_t PressureLimitTable[] = {
1010 : 32, // 0: GPR
1011 : };
1012 : return PressureLimitTable[Idx];
1013 : }
1014 :
1015 : /// Table of pressure sets per register class or unit.
1016 : static const int RCSetsTable[] = {
1017 : /* 0 */ 0, -1,
1018 : };
1019 :
1020 : /// Get the dimensions of register pressure impacted by this register class.
1021 : /// Returns a -1 terminated array of pressure set IDs
1022 : const int* RISCVGenRegisterInfo::
1023 : getRegClassPressureSets(const TargetRegisterClass *RC) const {
1024 : static const uint8_t RCSetStartTable[] = {
1025 : 0,0,};
1026 : return &RCSetsTable[RCSetStartTable[RC->getID()]];
1027 : }
1028 :
1029 : /// Get the dimensions of register pressure impacted by this register unit.
1030 : /// Returns a -1 terminated array of pressure set IDs
1031 : const int* RISCVGenRegisterInfo::
1032 : getRegUnitPressureSets(unsigned RegUnit) const {
1033 : assert(RegUnit < 32 && "invalid register unit");
1034 : static const uint8_t RUSetStartTable[] = {
1035 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,};
1036 : return &RCSetsTable[RUSetStartTable[RegUnit]];
1037 : }
1038 :
1039 : extern const MCRegisterDesc RISCVRegDesc[];
1040 : extern const MCPhysReg RISCVRegDiffLists[];
1041 : extern const LaneBitmask RISCVLaneMaskLists[];
1042 : extern const char RISCVRegStrings[];
1043 : extern const char RISCVRegClassStrings[];
1044 : extern const MCPhysReg RISCVRegUnitRoots[][2];
1045 : extern const uint16_t RISCVSubRegIdxLists[];
1046 : extern const MCRegisterInfo::SubRegCoveredBits RISCVSubRegIdxRanges[];
1047 : extern const uint16_t RISCVRegEncodingTable[];
1048 : // RISCV Dwarf<->LLVM register mappings.
1049 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVDwarfFlavour0Dwarf2L[];
1050 : extern const unsigned RISCVDwarfFlavour0Dwarf2LSize;
1051 :
1052 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVEHFlavour0Dwarf2L[];
1053 : extern const unsigned RISCVEHFlavour0Dwarf2LSize;
1054 :
1055 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVDwarfFlavour0L2Dwarf[];
1056 : extern const unsigned RISCVDwarfFlavour0L2DwarfSize;
1057 :
1058 : extern const MCRegisterInfo::DwarfLLVMRegPair RISCVEHFlavour0L2Dwarf[];
1059 : extern const unsigned RISCVEHFlavour0L2DwarfSize;
1060 :
1061 : RISCVGenRegisterInfo::
1062 : RISCVGenRegisterInfo(unsigned RA, unsigned DwarfFlavour, unsigned EHFlavour, unsigned PC)
1063 : : TargetRegisterInfo(RISCVRegInfoDesc, RegisterClasses, RegisterClasses+2,
1064 : SubRegIndexNameTable, SubRegIndexLaneMaskTable, LaneBitmask(0xFFFFFFFE)) {
1065 : InitMCRegisterInfo(RISCVRegDesc, 65, RA, PC,
1066 : RISCVMCRegisterClasses, 2,
1067 : RISCVRegUnitRoots,
1068 : 32,
1069 : RISCVRegDiffLists,
1070 : RISCVLaneMaskLists,
1071 : RISCVRegStrings,
1072 : RISCVRegClassStrings,
1073 : RISCVSubRegIdxLists,
1074 : 2,
1075 : RISCVSubRegIdxRanges,
1076 : RISCVRegEncodingTable);
1077 :
1078 : switch (DwarfFlavour) {
1079 : default:
1080 : llvm_unreachable("Unknown DWARF flavour");
1081 : case 0:
1082 : mapDwarfRegsToLLVMRegs(RISCVDwarfFlavour0Dwarf2L, RISCVDwarfFlavour0Dwarf2LSize, false);
1083 : break;
1084 : }
1085 : switch (EHFlavour) {
1086 : default:
1087 : llvm_unreachable("Unknown DWARF flavour");
1088 : case 0:
1089 : mapDwarfRegsToLLVMRegs(RISCVEHFlavour0Dwarf2L, RISCVEHFlavour0Dwarf2LSize, true);
1090 : break;
1091 : }
1092 : switch (DwarfFlavour) {
1093 : default:
1094 : llvm_unreachable("Unknown DWARF flavour");
1095 : case 0:
1096 : mapLLVMRegsToDwarfRegs(RISCVDwarfFlavour0L2Dwarf, RISCVDwarfFlavour0L2DwarfSize, false);
1097 : break;
1098 : }
1099 : switch (EHFlavour) {
1100 : default:
1101 : llvm_unreachable("Unknown DWARF flavour");
1102 : case 0:
1103 : mapLLVMRegsToDwarfRegs(RISCVEHFlavour0L2Dwarf, RISCVEHFlavour0L2DwarfSize, true);
1104 : break;
1105 : }
1106 : }
1107 :
1108 :
1109 :
1110 : ArrayRef<const uint32_t *> RISCVGenRegisterInfo::getRegMasks() const {
1111 : return None;
1112 : }
1113 :
1114 : ArrayRef<const char *> RISCVGenRegisterInfo::getRegMaskNames() const {
1115 : return None;
1116 : }
1117 :
1118 : const RISCVFrameLowering *
1119 : RISCVGenRegisterInfo::getFrameLowering(const MachineFunction &MF) {
1120 : return static_cast<const RISCVFrameLowering *>(
1121 : MF.getSubtarget().getFrameLowering());
1122 : }
1123 :
1124 : } // end namespace llvm
1125 :
1126 : #endif // GET_REGINFO_TARGET_DESC
1127 :
|
