lib/Target/PowerPC/PPCRegisterInfo.td

   1 //===-- PPCRegisterInfo.td - The PowerPC Register File -----*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 let Namespace = "PPC" in {
  14 def sub_lt : SubRegIndex;
  15 def sub_gt : SubRegIndex;
  16 def sub_eq : SubRegIndex;
  17 def sub_un : SubRegIndex;
  18 def sub_32 : SubRegIndex;
  19 }
  20
  21
  22 class PPCReg<string n> : Register<n> {
  23   let Namespace = "PPC";
  24 }
  25
  26 // We identify all our registers with a 5-bit ID, for consistency's sake.
  27
  28 // GPR - One of the 32 32-bit general-purpose registers
  29 class GPR<bits<5> num, string n> : PPCReg<n> {
  30   field bits<5> Num = num;
  31 }
  32
  33 // GP8 - One of the 32 64-bit general-purpose registers
  34 class GP8<GPR SubReg, string n> : PPCReg<n> {
  35   field bits<5> Num = SubReg.Num;
  36   let SubRegs = [SubReg];
  37   let SubRegIndices = [sub_32];
  38 }
  39
  40 // SPR - One of the 32-bit special-purpose registers
  41 class SPR<bits<10> num, string n> : PPCReg<n> {
  42   field bits<10> Num = num;
  43 }
  44
  45 // FPR - One of the 32 64-bit floating-point registers
  46 class FPR<bits<5> num, string n> : PPCReg<n> {
  47   field bits<5> Num = num;
  48 }
  49
  50 // VR - One of the 32 128-bit vector registers
  51 class VR<bits<5> num, string n> : PPCReg<n> {
  52   field bits<5> Num = num;
  53 }
  54
  55 // CR - One of the 8 4-bit condition registers
  56 class CR<bits<3> num, string n, list<Register> subregs> : PPCReg<n> {
  57   field bits<3> Num = num;
  58   let SubRegs = subregs;
  59 }
  60
  61 // CRBIT - One of the 32 1-bit condition register fields
  62 class CRBIT<bits<5> num, string n> : PPCReg<n> {
  63   field bits<5> Num = num;
  64 }
  65
  66 // General-purpose registers
  67 foreach Index = 0-31 in {
  68   def R#Index : GPR<Index, "r"#Index>, DwarfRegNum<[-2, Index]>;
  69 }
  70
  71 // 64-bit General-purpose registers
  72 foreach Index = 0-31 in {
  73   def X#Index : GP8<!cast<GPR>("R"#Index), "r"#Index>,
  74                     DwarfRegNum<[Index, -2]>;
  75 }
  76
  77 // Floating-point registers
  78 def F0  : FPR< 0,  "f0">, DwarfRegNum<[32, 32]>;
  79 def F1  : FPR< 1,  "f1">, DwarfRegNum<[33, 33]>;
  80 def F2  : FPR< 2,  "f2">, DwarfRegNum<[34, 34]>;
  81 def F3  : FPR< 3,  "f3">, DwarfRegNum<[35, 35]>;
  82 def F4  : FPR< 4,  "f4">, DwarfRegNum<[36, 36]>;
  83 def F5  : FPR< 5,  "f5">, DwarfRegNum<[37, 37]>;
  84 def F6  : FPR< 6,  "f6">, DwarfRegNum<[38, 38]>;
  85 def F7  : FPR< 7,  "f7">, DwarfRegNum<[39, 39]>;
  86 def F8  : FPR< 8,  "f8">, DwarfRegNum<[40, 40]>;
  87 def F9  : FPR< 9,  "f9">, DwarfRegNum<[41, 41]>;
  88 def F10 : FPR<10, "f10">, DwarfRegNum<[42, 42]>;
  89 def F11 : FPR<11, "f11">, DwarfRegNum<[43, 43]>;
  90 def F12 : FPR<12, "f12">, DwarfRegNum<[44, 44]>;
  91 def F13 : FPR<13, "f13">, DwarfRegNum<[45, 45]>;
  92 def F14 : FPR<14, "f14">, DwarfRegNum<[46, 46]>;
  93 def F15 : FPR<15, "f15">, DwarfRegNum<[47, 47]>;
  94 def F16 : FPR<16, "f16">, DwarfRegNum<[48, 48]>;
  95 def F17 : FPR<17, "f17">, DwarfRegNum<[49, 49]>;
  96 def F18 : FPR<18, "f18">, DwarfRegNum<[50, 50]>;
  97 def F19 : FPR<19, "f19">, DwarfRegNum<[51, 51]>;
  98 def F20 : FPR<20, "f20">, DwarfRegNum<[52, 52]>;
  99 def F21 : FPR<21, "f21">, DwarfRegNum<[53, 53]>;
 100 def F22 : FPR<22, "f22">, DwarfRegNum<[54, 54]>;
 101 def F23 : FPR<23, "f23">, DwarfRegNum<[55, 55]>;
 102 def F24 : FPR<24, "f24">, DwarfRegNum<[56, 56]>;
 103 def F25 : FPR<25, "f25">, DwarfRegNum<[57, 57]>;
 104 def F26 : FPR<26, "f26">, DwarfRegNum<[58, 58]>;
 105 def F27 : FPR<27, "f27">, DwarfRegNum<[59, 59]>;
 106 def F28 : FPR<28, "f28">, DwarfRegNum<[60, 60]>;
 107 def F29 : FPR<29, "f29">, DwarfRegNum<[61, 61]>;
 108 def F30 : FPR<30, "f30">, DwarfRegNum<[62, 62]>;
 109 def F31 : FPR<31, "f31">, DwarfRegNum<[63, 63]>;
 110
 111 // Vector registers
 112 def V0  : VR< 0,  "v0">, DwarfRegNum<[77, 77]>;
 113 def V1  : VR< 1,  "v1">, DwarfRegNum<[78, 78]>;
 114 def V2  : VR< 2,  "v2">, DwarfRegNum<[79, 79]>;
 115 def V3  : VR< 3,  "v3">, DwarfRegNum<[80, 80]>;
 116 def V4  : VR< 4,  "v4">, DwarfRegNum<[81, 81]>;
 117 def V5  : VR< 5,  "v5">, DwarfRegNum<[82, 82]>;
 118 def V6  : VR< 6,  "v6">, DwarfRegNum<[83, 83]>;
 119 def V7  : VR< 7,  "v7">, DwarfRegNum<[84, 84]>;
 120 def V8  : VR< 8,  "v8">, DwarfRegNum<[85, 85]>;
 121 def V9  : VR< 9,  "v9">, DwarfRegNum<[86, 86]>;
 122 def V10 : VR<10, "v10">, DwarfRegNum<[87, 87]>;
 123 def V11 : VR<11, "v11">, DwarfRegNum<[88, 88]>;
 124 def V12 : VR<12, "v12">, DwarfRegNum<[89, 89]>;
 125 def V13 : VR<13, "v13">, DwarfRegNum<[90, 90]>;
 126 def V14 : VR<14, "v14">, DwarfRegNum<[91, 91]>;
 127 def V15 : VR<15, "v15">, DwarfRegNum<[92, 92]>;
 128 def V16 : VR<16, "v16">, DwarfRegNum<[93, 93]>;
 129 def V17 : VR<17, "v17">, DwarfRegNum<[94, 94]>;
 130 def V18 : VR<18, "v18">, DwarfRegNum<[95, 95]>;
 131 def V19 : VR<19, "v19">, DwarfRegNum<[96, 96]>;
 132 def V20 : VR<20, "v20">, DwarfRegNum<[97, 97]>;
 133 def V21 : VR<21, "v21">, DwarfRegNum<[98, 98]>;
 134 def V22 : VR<22, "v22">, DwarfRegNum<[99, 99]>;
 135 def V23 : VR<23, "v23">, DwarfRegNum<[100, 100]>;
 136 def V24 : VR<24, "v24">, DwarfRegNum<[101, 101]>;
 137 def V25 : VR<25, "v25">, DwarfRegNum<[102, 102]>;
 138 def V26 : VR<26, "v26">, DwarfRegNum<[103, 103]>;
 139 def V27 : VR<27, "v27">, DwarfRegNum<[104, 104]>;
 140 def V28 : VR<28, "v28">, DwarfRegNum<[105, 105]>;
 141 def V29 : VR<29, "v29">, DwarfRegNum<[106, 106]>;
 142 def V30 : VR<30, "v30">, DwarfRegNum<[107, 107]>;
 143 def V31 : VR<31, "v31">, DwarfRegNum<[108, 108]>;
 144
 145 // Condition register bits
 146 def CR0LT : CRBIT< 0, "0">;
 147 def CR0GT : CRBIT< 1, "1">;
 148 def CR0EQ : CRBIT< 2, "2">;
 149 def CR0UN : CRBIT< 3, "3">;
 150 def CR1LT : CRBIT< 4, "4">;
 151 def CR1GT : CRBIT< 5, "5">;
 152 def CR1EQ : CRBIT< 6, "6">;
 153 def CR1UN : CRBIT< 7, "7">;
 154 def CR2LT : CRBIT< 8, "8">;
 155 def CR2GT : CRBIT< 9, "9">;
 156 def CR2EQ : CRBIT<10, "10">;
 157 def CR2UN : CRBIT<11, "11">;
 158 def CR3LT : CRBIT<12, "12">;
 159 def CR3GT : CRBIT<13, "13">;
 160 def CR3EQ : CRBIT<14, "14">;
 161 def CR3UN : CRBIT<15, "15">;
 162 def CR4LT : CRBIT<16, "16">;
 163 def CR4GT : CRBIT<17, "17">;
 164 def CR4EQ : CRBIT<18, "18">;
 165 def CR4UN : CRBIT<19, "19">;
 166 def CR5LT : CRBIT<20, "20">;
 167 def CR5GT : CRBIT<21, "21">;
 168 def CR5EQ : CRBIT<22, "22">;
 169 def CR5UN : CRBIT<23, "23">;
 170 def CR6LT : CRBIT<24, "24">;
 171 def CR6GT : CRBIT<25, "25">;
 172 def CR6EQ : CRBIT<26, "26">;
 173 def CR6UN : CRBIT<27, "27">;
 174 def CR7LT : CRBIT<28, "28">;
 175 def CR7GT : CRBIT<29, "29">;
 176 def CR7EQ : CRBIT<30, "30">;
 177 def CR7UN : CRBIT<31, "31">;
 178
 179 // Condition registers
 180 let SubRegIndices = [sub_lt, sub_gt, sub_eq, sub_un] in {
 181 def CR0 : CR<0, "cr0", [CR0LT, CR0GT, CR0EQ, CR0UN]>, DwarfRegNum<[68, 68]>;
 182 def CR1 : CR<1, "cr1", [CR1LT, CR1GT, CR1EQ, CR1UN]>, DwarfRegNum<[69, 69]>;
 183 def CR2 : CR<2, "cr2", [CR2LT, CR2GT, CR2EQ, CR2UN]>, DwarfRegNum<[70, 70]>;
 184 def CR3 : CR<3, "cr3", [CR3LT, CR3GT, CR3EQ, CR3UN]>, DwarfRegNum<[71, 71]>;
 185 def CR4 : CR<4, "cr4", [CR4LT, CR4GT, CR4EQ, CR4UN]>, DwarfRegNum<[72, 72]>;
 186 def CR5 : CR<5, "cr5", [CR5LT, CR5GT, CR5EQ, CR5UN]>, DwarfRegNum<[73, 73]>;
 187 def CR6 : CR<6, "cr6", [CR6LT, CR6GT, CR6EQ, CR6UN]>, DwarfRegNum<[74, 74]>;
 188 def CR7 : CR<7, "cr7", [CR7LT, CR7GT, CR7EQ, CR7UN]>, DwarfRegNum<[75, 75]>;
 189 }
 190
 191 // Link register
 192 def LR  : SPR<8, "lr">, DwarfRegNum<[-2, 65]>;
 193 //let Aliases = [LR] in
 194 def LR8 : SPR<8, "lr">, DwarfRegNum<[65, -2]>;
 195
 196 // Count register
 197 def CTR  : SPR<9, "ctr">, DwarfRegNum<[-2, 66]>;
 198 def CTR8 : SPR<9, "ctr">, DwarfRegNum<[66, -2]>;
 199
 200 // VRsave register
 201 def VRSAVE: SPR<256, "VRsave">, DwarfRegNum<[109]>;
 202
 203 // Carry bit.  In the architecture this is really bit 0 of the XER register
 204 // (which really is SPR register 1);  this is the only bit interesting to a
 205 // compiler.
 206 def CARRY: SPR<1, "ca">;
 207
 208 // FP rounding mode:  bits 30 and 31 of the FP status and control register
 209 // This is not allocated as a normal register; it appears only in
 210 // Uses and Defs.  The ABI says it needs to be preserved by a function,
 211 // but this is not achieved by saving and restoring it as with
 212 // most registers, it has to be done in code; to make this work all the
 213 // return and call instructions are described as Uses of RM, so instructions
 214 // that do nothing but change RM will not get deleted.
 215 // Also, in the architecture it is not really a SPR; 512 is arbitrary.
 216 def RM: SPR<512, "**ROUNDING MODE**">;
 217
 218 /// Register classes
 219 // Allocate volatiles first
 220 // then nonvolatiles in reverse order since stmw/lmw save from rN to r31
 221 def GPRC : RegisterClass<"PPC", [i32], 32, (add (sequence "R%u", 2, 12),
 222                                                 (sequence "R%u", 30, 13),
 223                                                 R31, R0, R1, LR)>;
 224
 225 def G8RC : RegisterClass<"PPC", [i64], 64, (add (sequence "X%u", 2, 12),
 226                                                 (sequence "X%u", 30, 14),
 227                                                 X31, X13, X0, X1, LR8)>;
 228
 229 // Allocate volatiles first, then non-volatiles in reverse order. With the SVR4
 230 // ABI the size of the Floating-point register save area is determined by the
 231 // allocated non-volatile register with the lowest register number, as FP
 232 // register N is spilled to offset 8 * (32 - N) below the back chain word of the
 233 // previous stack frame. By allocating non-volatiles in reverse order we make
 234 // sure that the Floating-point register save area is always as small as
 235 // possible because there aren't any unused spill slots.
 236 def F8RC : RegisterClass<"PPC", [f64], 64, (add (sequence "F%u", 0, 13),
 237                                                 (sequence "F%u", 31, 14))>;
 238 def F4RC : RegisterClass<"PPC", [f32], 32, (add F8RC)>;
 239
 240 def VRRC : RegisterClass<"PPC", [v16i8,v8i16,v4i32,v4f32], 128,
 241                          (add V2, V3, V4, V5, V0, V1, V6, V7, V8, V9, V10, V11,
 242                              V12, V13, V14, V15, V16, V17, V18, V19, V31, V30,
 243                              V29, V28, V27, V26, V25, V24, V23, V22, V21, V20)>;
 244
 245 def CRBITRC : RegisterClass<"PPC", [i32], 32,
 246   (add CR0LT, CR0GT, CR0EQ, CR0UN,
 247        CR1LT, CR1GT, CR1EQ, CR1UN,
 248        CR2LT, CR2GT, CR2EQ, CR2UN,
 249        CR3LT, CR3GT, CR3EQ, CR3UN,
 250        CR4LT, CR4GT, CR4EQ, CR4UN,
 251        CR5LT, CR5GT, CR5EQ, CR5UN,
 252        CR6LT, CR6GT, CR6EQ, CR6UN,
 253        CR7LT, CR7GT, CR7EQ, CR7UN)>
 254 {
 255   let CopyCost = -1;
 256 }
 257
 258 def CRRC : RegisterClass<"PPC", [i32], 32, (add CR0, CR1, CR5, CR6,
 259                                                 CR7, CR2, CR3, CR4)>;
 260
 261 // The CTR registers are not allocatable because they're used by the
 262 // decrement-and-branch instructions, and thus need to stay live across
 263 // multiple basic blocks.
 264 def CTRRC : RegisterClass<"PPC", [i32], 32, (add CTR)> {
 265   let isAllocatable = 0;
 266 }
 267 def CTRRC8 : RegisterClass<"PPC", [i64], 64, (add CTR8)> {
 268   let isAllocatable = 0;
 269 }
 270
 271 def VRSAVERC : RegisterClass<"PPC", [i32], 32, (add VRSAVE)>;
 272 def CARRYRC : RegisterClass<"PPC", [i32], 32, (add CARRY)> {
 273   let CopyCost = -1;
 274 }