1 //===- ARMRegisterInfo.td - ARM Register defs ----------*- tablegen -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the "Instituto Nokia de Tecnologia" and
6 // is distributed under the University of Illinois Open Source
7 // License. See LICENSE.TXT for details.
9 //===----------------------------------------------------------------------===//
11 //===----------------------------------------------------------------------===//
12 // Declarations that describe the ARM register file
13 //===----------------------------------------------------------------------===//
15 // Registers are identified with 4-bit ID numbers.
16 class ARMReg<string n> : Register<n> {
17 let Namespace = "ARM";
20 // Ri - 32-bit integer registers
21 class Ri<bits<4> num, string n> : ARMReg<n> {
25 // Rf - 32-bit floating-point registers
26 class Rf<bits<5> num, string n> : ARMReg<n> {
30 // Rd - Slots in the FP register file for 64-bit floating-point values.
31 class Rd<bits<5> num, string n, list<Register> aliases> : ARMReg<n> {
34 let Aliases = aliases;
38 def R0 : Ri< 0, "R0">, DwarfRegNum<0>;
39 def R1 : Ri< 1, "R1">, DwarfRegNum<1>;
40 def R2 : Ri< 2, "R2">, DwarfRegNum<2>;
41 def R3 : Ri< 3, "R3">, DwarfRegNum<3>;
42 def R4 : Ri< 4, "R4">, DwarfRegNum<4>;
43 def R5 : Ri< 5, "R5">, DwarfRegNum<5>;
44 def R6 : Ri< 6, "R6">, DwarfRegNum<6>;
45 def R7 : Ri< 7, "R7">, DwarfRegNum<7>;
46 def R8 : Ri< 8, "R8">, DwarfRegNum<8>;
47 def R9 : Ri< 9, "R9">, DwarfRegNum<9>;
48 def R10 : Ri<10, "R10">, DwarfRegNum<10>;
49 def R11 : Ri<11, "R11">, DwarfRegNum<11>;
50 def R12 : Ri<12, "R12">, DwarfRegNum<12>;
51 def R13 : Ri<13, "R13">, DwarfRegNum<13>;
52 def R14 : Ri<14, "R14">, DwarfRegNum<14>;
53 def R15 : Ri<15, "R15">, DwarfRegNum<15>;
55 // TODO: update to VFP-v3
56 // Floating-point registers
57 def S0 : Rf< 0, "S0">, DwarfRegNum<64>;
58 def S1 : Rf< 1, "S1">, DwarfRegNum<65>;
59 def S2 : Rf< 2, "S2">, DwarfRegNum<66>;
60 def S3 : Rf< 3, "S3">, DwarfRegNum<67>;
61 def S4 : Rf< 4, "S4">, DwarfRegNum<68>;
62 def S5 : Rf< 5, "S5">, DwarfRegNum<69>;
63 def S6 : Rf< 6, "S6">, DwarfRegNum<70>;
64 def S7 : Rf< 7, "S7">, DwarfRegNum<71>;
65 def S8 : Rf< 8, "S8">, DwarfRegNum<72>;
66 def S9 : Rf< 9, "S9">, DwarfRegNum<73>;
67 def S10 : Rf<10, "S10">, DwarfRegNum<74>;
68 def S11 : Rf<11, "S11">, DwarfRegNum<75>;
69 def S12 : Rf<12, "S12">, DwarfRegNum<76>;
70 def S13 : Rf<13, "S13">, DwarfRegNum<77>;
71 def S14 : Rf<14, "S14">, DwarfRegNum<78>;
72 def S15 : Rf<15, "S15">, DwarfRegNum<79>;
73 def S16 : Rf<16, "S16">, DwarfRegNum<80>;
74 def S17 : Rf<17, "S17">, DwarfRegNum<81>;
75 def S18 : Rf<18, "S18">, DwarfRegNum<82>;
76 def S19 : Rf<19, "S19">, DwarfRegNum<83>;
77 def S20 : Rf<20, "S20">, DwarfRegNum<84>;
78 def S21 : Rf<21, "S21">, DwarfRegNum<85>;
79 def S22 : Rf<22, "S22">, DwarfRegNum<86>;
80 def S23 : Rf<23, "S23">, DwarfRegNum<87>;
81 def S24 : Rf<24, "S24">, DwarfRegNum<88>;
82 def S25 : Rf<25, "S25">, DwarfRegNum<89>;
83 def S26 : Rf<26, "S26">, DwarfRegNum<90>;
84 def S27 : Rf<27, "S27">, DwarfRegNum<91>;
85 def S28 : Rf<28, "S28">, DwarfRegNum<92>;
86 def S29 : Rf<29, "S29">, DwarfRegNum<93>;
87 def S30 : Rf<30, "S30">, DwarfRegNum<94>;
88 def S31 : Rf<31, "S31">, DwarfRegNum<95>;
90 // Aliases of the S* registers used to hold 64-bit fp values (doubles)
91 def D0 : Rd< 0, "D0", [S0, S1]>, DwarfRegNum<64>;
92 def D1 : Rd< 2, "D1", [S2, S3]>, DwarfRegNum<66>;
93 def D2 : Rd< 4, "D2", [S4, S5]>, DwarfRegNum<68>;
94 def D3 : Rd< 6, "D3", [S6, S7]>, DwarfRegNum<70>;
95 def D4 : Rd< 8, "D4", [S8, S9]>, DwarfRegNum<72>;
96 def D5 : Rd<10, "D5", [S10, S11]>, DwarfRegNum<74>;
97 def D6 : Rd<12, "D6", [S12, S13]>, DwarfRegNum<76>;
98 def D7 : Rd<14, "D7", [S14, S15]>, DwarfRegNum<78>;
99 def D8 : Rd<16, "D8", [S16, S17]>, DwarfRegNum<80>;
100 def D9 : Rd<18, "D9", [S18, S19]>, DwarfRegNum<82>;
101 def D10 : Rd<20, "D10", [S20, S21]>, DwarfRegNum<84>;
102 def D11 : Rd<22, "D11", [S22, S23]>, DwarfRegNum<86>;
103 def D12 : Rd<24, "D12", [S24, S25]>, DwarfRegNum<88>;
104 def D13 : Rd<26, "D13", [S26, S27]>, DwarfRegNum<90>;
105 def D14 : Rd<28, "D14", [S28, S29]>, DwarfRegNum<92>;
106 def D15 : Rd<30, "D15", [S30, S31]>, DwarfRegNum<94>;
110 // FIXME: the register order should be defined in terms of the preferred
111 // allocation order...
113 def IntRegs : RegisterClass<"ARM", [i32], 32, [R0, R1, R2, R3, R4, R5, R6,
114 R7, R8, R9, R10, R11, R12,
116 let MethodProtos = [{
117 iterator allocation_order_end(const MachineFunction &MF) const;
119 let MethodBodies = [{
120 IntRegsClass::iterator
121 IntRegsClass::allocation_order_end(const MachineFunction &MF) const {
122 // r15 == Program Counter
123 // r14 == Link Register
124 // r13 == Stack Pointer
125 // r12 == ip (scratch)
126 // r11 == Frame Pointer
127 // r10 == Stack Limit
133 def FPRegs : RegisterClass<"ARM", [f32], 32, [S0, S1, S2, S3, S4, S5, S6, S7, S8,
134 S9, S10, S11, S12, S13, S14, S15, S16, S17, S18, S19, S20, S21, S22,
135 S23, S24, S25, S26, S27, S28, S29, S30, S31]>;
137 def DFPRegs : RegisterClass<"ARM", [f64], 64, [D0, D1, D2, D3, D4, D5, D6, D7,
138 D8, D9, D10, D11, D12, D13, D14, D15]>;