lib/Target/ARM/ARMRegisterInfo.td

   1 //===- ARMRegisterInfo.td - ARM Register defs ----------*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   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.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 //===----------------------------------------------------------------------===//
  12 //  Declarations that describe the ARM register file
  13 //===----------------------------------------------------------------------===//
  14
  15 // Registers are identified with 4-bit ID numbers.
  16 class ARMReg<string n> : Register<n> {
  17   let Namespace = "ARM";
  18 }
  19
  20 // Ri - 32-bit integer registers
  21 class Ri<bits<4> num, string n> : ARMReg<n> {
  22   field bits<4> Num;
  23   let Num = num;
  24 }
  25 // Rf - 32-bit floating-point registers
  26 class Rf<bits<5> num, string n> : ARMReg<n> {
  27   field bits<5> Num;
  28   let Num = num;
  29 }
  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> {
  32   field bits<5> Num;
  33   let Num = num;
  34   let Aliases = aliases;
  35 }
  36
  37 // Integer registers
  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>;
  54
  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>;
  89
  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>;
 107
 108 // Register classes.
 109 //
 110 // FIXME: the register order should be defined in terms of the preferred
 111 // allocation order...
 112 //
 113 def IntRegs : RegisterClass<"ARM", [i32], 32, [R0, R1, R2, R3, R4, R5, R6,
 114                                                R7, R8, R9, R10, R11, R12,
 115                                                R13, R14, R15]> {
 116   let MethodProtos = [{
 117     iterator allocation_order_end(const MachineFunction &MF) const;
 118   }];
 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
 128       return end() - 4;
 129     }
 130   }];
 131 }
 132
 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]>;
 136
 137 def DFPRegs : RegisterClass<"ARM", [f64], 64, [D0, D1, D2, D3, D4, D5, D6, D7,
 138   D8, D9, D10, D11, D12, D13, D14, D15]>;