1 //===- MipsRegisterInfo.td - Mips Register defs -----------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 //===----------------------------------------------------------------------===//
11 // Declarations that describe the MIPS register file
12 //===----------------------------------------------------------------------===//
14 // We have banks of 32 registers each.
15 class MipsReg<string n> : Register<n> {
17 let Namespace = "Mips";
21 class MipsGPRReg<bits<5> num, string n> : MipsReg<n> {
25 // Mips 32-bit FPU Registers
26 class FPR<bits<5> num, string n> : MipsReg<n> {
30 // Mips 64-bit (aliased) FPU Registers
31 class AFPR<bits<5> num, string n, list<Register> aliases> : MipsReg<n> {
33 let Aliases = aliases;
36 //===----------------------------------------------------------------------===//
38 //===----------------------------------------------------------------------===//
40 let Namespace = "Mips" in {
42 // General Purpose Registers
43 def ZERO : MipsGPRReg< 0, "ZERO">, DwarfRegNum<[0]>;
44 def AT : MipsGPRReg< 1, "AT">, DwarfRegNum<[1]>;
45 def V0 : MipsGPRReg< 2, "2">, DwarfRegNum<[2]>;
46 def V1 : MipsGPRReg< 3, "3">, DwarfRegNum<[3]>;
47 def A0 : MipsGPRReg< 4, "4">, DwarfRegNum<[5]>;
48 def A1 : MipsGPRReg< 5, "5">, DwarfRegNum<[5]>;
49 def A2 : MipsGPRReg< 6, "6">, DwarfRegNum<[6]>;
50 def A3 : MipsGPRReg< 7, "7">, DwarfRegNum<[7]>;
51 def T0 : MipsGPRReg< 8, "8">, DwarfRegNum<[8]>;
52 def T1 : MipsGPRReg< 9, "9">, DwarfRegNum<[9]>;
53 def T2 : MipsGPRReg< 10, "10">, DwarfRegNum<[10]>;
54 def T3 : MipsGPRReg< 11, "11">, DwarfRegNum<[11]>;
55 def T4 : MipsGPRReg< 12, "12">, DwarfRegNum<[12]>;
56 def T5 : MipsGPRReg< 13, "13">, DwarfRegNum<[13]>;
57 def T6 : MipsGPRReg< 14, "14">, DwarfRegNum<[14]>;
58 def T7 : MipsGPRReg< 15, "15">, DwarfRegNum<[15]>;
59 def S0 : MipsGPRReg< 16, "16">, DwarfRegNum<[16]>;
60 def S1 : MipsGPRReg< 17, "17">, DwarfRegNum<[17]>;
61 def S2 : MipsGPRReg< 18, "18">, DwarfRegNum<[18]>;
62 def S3 : MipsGPRReg< 19, "19">, DwarfRegNum<[19]>;
63 def S4 : MipsGPRReg< 20, "20">, DwarfRegNum<[20]>;
64 def S5 : MipsGPRReg< 21, "21">, DwarfRegNum<[21]>;
65 def S6 : MipsGPRReg< 22, "22">, DwarfRegNum<[22]>;
66 def S7 : MipsGPRReg< 23, "23">, DwarfRegNum<[23]>;
67 def T8 : MipsGPRReg< 24, "24">, DwarfRegNum<[24]>;
68 def T9 : MipsGPRReg< 25, "25">, DwarfRegNum<[25]>;
69 def K0 : MipsGPRReg< 26, "26">, DwarfRegNum<[26]>;
70 def K1 : MipsGPRReg< 27, "27">, DwarfRegNum<[27]>;
71 def GP : MipsGPRReg< 28, "GP">, DwarfRegNum<[28]>;
72 def SP : MipsGPRReg< 29, "SP">, DwarfRegNum<[29]>;
73 def FP : MipsGPRReg< 30, "FP">, DwarfRegNum<[30]>;
74 def RA : MipsGPRReg< 31, "RA">, DwarfRegNum<[31]>;
76 /// Mips Single point precision FPU Registers
77 def F0 : FPR< 0, "F0">, DwarfRegNum<[32]>;
78 def F1 : FPR< 1, "F1">, DwarfRegNum<[33]>;
79 def F2 : FPR< 2, "F2">, DwarfRegNum<[34]>;
80 def F3 : FPR< 3, "F3">, DwarfRegNum<[35]>;
81 def F4 : FPR< 4, "F4">, DwarfRegNum<[36]>;
82 def F5 : FPR< 5, "F5">, DwarfRegNum<[37]>;
83 def F6 : FPR< 6, "F6">, DwarfRegNum<[38]>;
84 def F7 : FPR< 7, "F7">, DwarfRegNum<[39]>;
85 def F8 : FPR< 8, "F8">, DwarfRegNum<[40]>;
86 def F9 : FPR< 9, "F9">, DwarfRegNum<[41]>;
87 def F10 : FPR<10, "F10">, DwarfRegNum<[42]>;
88 def F11 : FPR<11, "F11">, DwarfRegNum<[43]>;
89 def F12 : FPR<12, "F12">, DwarfRegNum<[44]>;
90 def F13 : FPR<13, "F13">, DwarfRegNum<[45]>;
91 def F14 : FPR<14, "F14">, DwarfRegNum<[46]>;
92 def F15 : FPR<15, "F15">, DwarfRegNum<[47]>;
93 def F16 : FPR<16, "F16">, DwarfRegNum<[48]>;
94 def F17 : FPR<17, "F17">, DwarfRegNum<[49]>;
95 def F18 : FPR<18, "F18">, DwarfRegNum<[50]>;
96 def F19 : FPR<19, "F19">, DwarfRegNum<[51]>;
97 def F20 : FPR<20, "F20">, DwarfRegNum<[52]>;
98 def F21 : FPR<21, "F21">, DwarfRegNum<[53]>;
99 def F22 : FPR<22, "F22">, DwarfRegNum<[54]>;
100 def F23 : FPR<23, "F23">, DwarfRegNum<[55]>;
101 def F24 : FPR<24, "F24">, DwarfRegNum<[56]>;
102 def F25 : FPR<25, "F25">, DwarfRegNum<[57]>;
103 def F26 : FPR<26, "F26">, DwarfRegNum<[58]>;
104 def F27 : FPR<27, "F27">, DwarfRegNum<[59]>;
105 def F28 : FPR<28, "F28">, DwarfRegNum<[60]>;
106 def F29 : FPR<29, "F29">, DwarfRegNum<[61]>;
107 def F30 : FPR<30, "F30">, DwarfRegNum<[62]>;
108 def F31 : FPR<31, "F31">, DwarfRegNum<[63]>;
110 /// Mips Double point precision FPU Registers (aliased
111 /// with the single precision to hold 64 bit values)
112 def D0 : AFPR< 0, "F0", [F0, F1]>, DwarfRegNum<[32]>;
113 def D1 : AFPR< 2, "F2", [F2, F3]>, DwarfRegNum<[34]>;
114 def D2 : AFPR< 4, "F4", [F4, F5]>, DwarfRegNum<[36]>;
115 def D3 : AFPR< 6, "F6", [F6, F7]>, DwarfRegNum<[38]>;
116 def D4 : AFPR< 8, "F8", [F8, F9]>, DwarfRegNum<[40]>;
117 def D5 : AFPR<10, "F10", [F10, F11]>, DwarfRegNum<[42]>;
118 def D6 : AFPR<12, "F12", [F12, F13]>, DwarfRegNum<[44]>;
119 def D7 : AFPR<14, "F14", [F14, F15]>, DwarfRegNum<[46]>;
120 def D8 : AFPR<16, "F16", [F16, F17]>, DwarfRegNum<[48]>;
121 def D9 : AFPR<18, "F18", [F18, F19]>, DwarfRegNum<[50]>;
122 def D10 : AFPR<20, "F20", [F20, F21]>, DwarfRegNum<[52]>;
123 def D11 : AFPR<22, "F22", [F22, F23]>, DwarfRegNum<[54]>;
124 def D12 : AFPR<24, "F24", [F24, F25]>, DwarfRegNum<[56]>;
125 def D13 : AFPR<26, "F26", [F26, F27]>, DwarfRegNum<[58]>;
126 def D14 : AFPR<28, "F28", [F28, F29]>, DwarfRegNum<[60]>;
127 def D15 : AFPR<30, "F30", [F30, F31]>, DwarfRegNum<[62]>;
130 def HI : Register<"hi">, DwarfRegNum<[64]>;
131 def LO : Register<"lo">, DwarfRegNum<[65]>;
133 // Status flags register
134 def FCR31 : Register<"FCR31">;
137 //===----------------------------------------------------------------------===//
139 //===----------------------------------------------------------------------===//
141 def CPURegs : RegisterClass<"Mips", [i32], 32,
142 // Return Values and Arguments
143 [V0, V1, A0, A1, A2, A3,
144 // Not preserved across procedure calls
145 T0, T1, T2, T3, T4, T5, T6, T7, T8, T9,
147 S0, S1, S2, S3, S4, S5, S6, S7,
149 ZERO, AT, K0, K1, GP, SP, FP, RA]>
151 let MethodProtos = [{
152 iterator allocation_order_end(const MachineFunction &MF) const;
154 let MethodBodies = [{
155 CPURegsClass::iterator
156 CPURegsClass::allocation_order_end(const MachineFunction &MF) const {
157 // The last 8 registers on the list above are reserved
164 // - FGR64 = 32 64-bit registers (default mode)
165 // - AFGR32/AFGR64 = 16 even 32-bit registers (32-bit compatible mode) for
166 // single and double access.
168 // - AFGR32/AFGR64 = 16 even 32-bit registers - single and double
169 // - FGR32 = 32 32-bit registers (within single-only mode)
170 def FGR32 : RegisterClass<"Mips", [f32], 32,
171 // Return Values and Arguments
172 [F0, F1, F2, F3, F12, F13, F14, F15,
173 // Not preserved across procedure calls
174 F4, F5, F6, F7, F8, F9, F10, F11, F16, F17, F18, F19,
176 F20, F21, F22, F23, F24, F25, F26, F27, F28, F29, F30,
180 let MethodProtos = [{
181 iterator allocation_order_end(const MachineFunction &MF) const;
183 let MethodBodies = [{
185 FGR32Class::allocation_order_end(const MachineFunction &MF) const {
186 // The last register on the list above is reserved
192 def AFGR32 : RegisterClass<"Mips", [f32], 32,
193 // Return Values and Arguments
195 // Not preserved across procedure calls
196 F4, F6, F8, F10, F16, F18,
198 F20, F22, F24, F26, F28, F30,
202 let MethodProtos = [{
203 iterator allocation_order_end(const MachineFunction &MF) const;
205 let MethodBodies = [{
206 AFGR32Class::iterator
207 AFGR32Class::allocation_order_end(const MachineFunction &MF) const {
208 // The last register on the list above is reserved
214 def AFGR64 : RegisterClass<"Mips", [f64], 64,
215 // Return Values and Arguments
217 // Not preserved across procedure calls
218 D2, D3, D4, D5, D8, D9,
220 D10, D11, D12, D13, D14,
224 let MethodProtos = [{
225 iterator allocation_order_end(const MachineFunction &MF) const;
227 let MethodBodies = [{
228 AFGR64Class::iterator
229 AFGR64Class::allocation_order_end(const MachineFunction &MF) const {
230 // The last register on the list above is reserved
236 def CCR : RegisterClass<"Mips", [i32], 32, [FCR31]> {
237 let CopyCost = -1; // Don't allow copying of status registers.
240 def HILO : RegisterClass<"Mips", [i32], 32, [HI, LO]> {
241 //let CopyCost = -1; // Don't allow copying of hi/lo registers.