contrib/llvm/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<1>;
  15 def sub_gt : SubRegIndex<1, 1>;
  16 def sub_eq : SubRegIndex<1, 2>;
  17 def sub_un : SubRegIndex<1, 3>;
  18 def sub_32 : SubRegIndex<32>;
  19 def sub_64 : SubRegIndex<64>;
  20 }
  21
  22
  23 class PPCReg<string n> : Register<n> {
  24   let Namespace = "PPC";
  25 }
  26
  27 // We identify all our registers with a 5-bit ID, for consistency's sake.
  28
  29 // GPR - One of the 32 32-bit general-purpose registers
  30 class GPR<bits<5> num, string n> : PPCReg<n> {
  31   let HWEncoding{4-0} = num;
  32 }
  33
  34 // GP8 - One of the 32 64-bit general-purpose registers
  35 class GP8<GPR SubReg, string n> : PPCReg<n> {
  36   let HWEncoding = SubReg.HWEncoding;
  37   let SubRegs = [SubReg];
  38   let SubRegIndices = [sub_32];
  39 }
  40
  41 // SPE - One of the 32 64-bit general-purpose registers (SPE)
  42 class SPE<GPR SubReg, string n> : PPCReg<n> {
  43   let HWEncoding = SubReg.HWEncoding;
  44   let SubRegs = [SubReg];
  45   let SubRegIndices = [sub_32];
  46 }
  47
  48 // SPR - One of the 32-bit special-purpose registers
  49 class SPR<bits<10> num, string n> : PPCReg<n> {
  50   let HWEncoding{9-0} = num;
  51 }
  52
  53 // FPR - One of the 32 64-bit floating-point registers
  54 class FPR<bits<5> num, string n> : PPCReg<n> {
  55   let HWEncoding{4-0} = num;
  56 }
  57
  58 // QFPR - One of the 32 256-bit floating-point vector registers (used for QPX)
  59 class QFPR<FPR SubReg, string n> : PPCReg<n> {
  60   let HWEncoding = SubReg.HWEncoding;
  61   let SubRegs = [SubReg];
  62   let SubRegIndices = [sub_64];
  63 }
  64
  65 // VF - One of the 32 64-bit floating-point subregisters of the vector
  66 // registers (used by VSX).
  67 class VF<bits<5> num, string n> : PPCReg<n> {
  68   let HWEncoding{4-0} = num;
  69   let HWEncoding{5} = 1;
  70 }
  71
  72 // VR - One of the 32 128-bit vector registers
  73 class VR<VF SubReg, string n> : PPCReg<n> {
  74   let HWEncoding{4-0} = SubReg.HWEncoding{4-0};
  75   let HWEncoding{5} = 0;
  76   let SubRegs = [SubReg];
  77   let SubRegIndices = [sub_64];
  78 }
  79
  80 // VSRL - One of the 32 128-bit VSX registers that overlap with the scalar
  81 // floating-point registers.
  82 class VSRL<FPR SubReg, string n> : PPCReg<n> {
  83   let HWEncoding = SubReg.HWEncoding;
  84   let SubRegs = [SubReg];
  85   let SubRegIndices = [sub_64];
  86 }
  87
  88 // CR - One of the 8 4-bit condition registers
  89 class CR<bits<3> num, string n, list<Register> subregs> : PPCReg<n> {
  90   let HWEncoding{2-0} = num;
  91   let SubRegs = subregs;
  92 }
  93
  94 // CRBIT - One of the 32 1-bit condition register fields
  95 class CRBIT<bits<5> num, string n> : PPCReg<n> {
  96   let HWEncoding{4-0} = num;
  97 }
  98
  99 // General-purpose registers
 100 foreach Index = 0-31 in {
 101   def R#Index : GPR<Index, "r"#Index>, DwarfRegNum<[-2, Index]>;
 102 }
 103
 104 // 64-bit General-purpose registers
 105 foreach Index = 0-31 in {
 106   def X#Index : GP8<!cast<GPR>("R"#Index), "r"#Index>,
 107                     DwarfRegNum<[Index, -2]>;
 108 }
 109
 110 // SPE registers
 111 foreach Index = 0-31 in {
 112   def S#Index : SPE<!cast<GPR>("R"#Index), "r"#Index>,
 113                     DwarfRegNum<[!add(Index, 1200), !add(Index, 1200)]>;
 114 }
 115
 116 // Floating-point registers
 117 foreach Index = 0-31 in {
 118   def F#Index : FPR<Index, "f"#Index>,
 119                 DwarfRegNum<[!add(Index, 32), !add(Index, 32)]>;
 120 }
 121
 122 // 64-bit Floating-point subregisters of Altivec registers
 123 // Note: the register names are v0-v31 or vs32-vs63 depending on the use.
 124 //       Custom C++ code is used to produce the correct name and encoding.
 125 foreach Index = 0-31 in {
 126   def VF#Index : VF<Index, "v" #Index>,
 127                  DwarfRegNum<[!add(Index, 77), !add(Index, 77)]>;
 128 }
 129
 130 // QPX Floating-point registers
 131 foreach Index = 0-31 in {
 132   def QF#Index : QFPR<!cast<FPR>("F"#Index), "q"#Index>,
 133                  DwarfRegNum<[!add(Index, 32), !add(Index, 32)]>;
 134 }
 135
 136 // Vector registers
 137 foreach Index = 0-31 in {
 138   def V#Index : VR<!cast<VF>("VF"#Index), "v"#Index>,
 139                 DwarfRegNum<[!add(Index, 77), !add(Index, 77)]>;
 140 }
 141
 142 // VSX registers
 143 foreach Index = 0-31 in {
 144   def VSL#Index : VSRL<!cast<FPR>("F"#Index), "vs"#Index>,
 145                   DwarfRegAlias<!cast<FPR>("F"#Index)>;
 146 }
 147
 148 // Dummy VSX registers, this defines string: "vs32"-"vs63", and is only used for
 149 // asm printing.
 150 foreach Index = 32-63 in {
 151   def VSX#Index : PPCReg<"vs"#Index>;
 152 }
 153
 154 // The reprsentation of r0 when treated as the constant 0.
 155 def ZERO  : GPR<0, "0">,    DwarfRegAlias<R0>;
 156 def ZERO8 : GP8<ZERO, "0">, DwarfRegAlias<X0>;
 157
 158 // Representations of the frame pointer used by ISD::FRAMEADDR.
 159 def FP   : GPR<0 /* arbitrary */, "**FRAME POINTER**">;
 160 def FP8  : GP8<FP, "**FRAME POINTER**">;
 161
 162 // Representations of the base pointer used by setjmp.
 163 def BP   : GPR<0 /* arbitrary */, "**BASE POINTER**">;
 164 def BP8  : GP8<BP, "**BASE POINTER**">;
 165
 166 // Condition register bits
 167 def CR0LT : CRBIT< 0, "0">;
 168 def CR0GT : CRBIT< 1, "1">;
 169 def CR0EQ : CRBIT< 2, "2">;
 170 def CR0UN : CRBIT< 3, "3">;
 171 def CR1LT : CRBIT< 4, "4">;
 172 def CR1GT : CRBIT< 5, "5">;
 173 def CR1EQ : CRBIT< 6, "6">;
 174 def CR1UN : CRBIT< 7, "7">;
 175 def CR2LT : CRBIT< 8, "8">;
 176 def CR2GT : CRBIT< 9, "9">;
 177 def CR2EQ : CRBIT<10, "10">;
 178 def CR2UN : CRBIT<11, "11">;
 179 def CR3LT : CRBIT<12, "12">;
 180 def CR3GT : CRBIT<13, "13">;
 181 def CR3EQ : CRBIT<14, "14">;
 182 def CR3UN : CRBIT<15, "15">;
 183 def CR4LT : CRBIT<16, "16">;
 184 def CR4GT : CRBIT<17, "17">;
 185 def CR4EQ : CRBIT<18, "18">;
 186 def CR4UN : CRBIT<19, "19">;
 187 def CR5LT : CRBIT<20, "20">;
 188 def CR5GT : CRBIT<21, "21">;
 189 def CR5EQ : CRBIT<22, "22">;
 190 def CR5UN : CRBIT<23, "23">;
 191 def CR6LT : CRBIT<24, "24">;
 192 def CR6GT : CRBIT<25, "25">;
 193 def CR6EQ : CRBIT<26, "26">;
 194 def CR6UN : CRBIT<27, "27">;
 195 def CR7LT : CRBIT<28, "28">;
 196 def CR7GT : CRBIT<29, "29">;
 197 def CR7EQ : CRBIT<30, "30">;
 198 def CR7UN : CRBIT<31, "31">;
 199
 200 // Condition registers
 201 let SubRegIndices = [sub_lt, sub_gt, sub_eq, sub_un] in {
 202 def CR0 : CR<0, "cr0", [CR0LT, CR0GT, CR0EQ, CR0UN]>, DwarfRegNum<[68, 68]>;
 203 def CR1 : CR<1, "cr1", [CR1LT, CR1GT, CR1EQ, CR1UN]>, DwarfRegNum<[69, 69]>;
 204 def CR2 : CR<2, "cr2", [CR2LT, CR2GT, CR2EQ, CR2UN]>, DwarfRegNum<[70, 70]>;
 205 def CR3 : CR<3, "cr3", [CR3LT, CR3GT, CR3EQ, CR3UN]>, DwarfRegNum<[71, 71]>;
 206 def CR4 : CR<4, "cr4", [CR4LT, CR4GT, CR4EQ, CR4UN]>, DwarfRegNum<[72, 72]>;
 207 def CR5 : CR<5, "cr5", [CR5LT, CR5GT, CR5EQ, CR5UN]>, DwarfRegNum<[73, 73]>;
 208 def CR6 : CR<6, "cr6", [CR6LT, CR6GT, CR6EQ, CR6UN]>, DwarfRegNum<[74, 74]>;
 209 def CR7 : CR<7, "cr7", [CR7LT, CR7GT, CR7EQ, CR7UN]>, DwarfRegNum<[75, 75]>;
 210 }
 211
 212 // Link register
 213 def LR  : SPR<8, "lr">, DwarfRegNum<[-2, 65]>;
 214 //let Aliases = [LR] in
 215 def LR8 : SPR<8, "lr">, DwarfRegNum<[65, -2]>;
 216
 217 // Count register
 218 def CTR  : SPR<9, "ctr">, DwarfRegNum<[-2, 66]>;
 219 def CTR8 : SPR<9, "ctr">, DwarfRegNum<[66, -2]>;
 220
 221 // VRsave register
 222 def VRSAVE: SPR<256, "vrsave">, DwarfRegNum<[109]>;
 223
 224 // SPE extra registers
 225 // SPE Accumulator for multiply-accumulate SPE operations.  Never directly
 226 // accessed, so there's no real encoding for it.
 227 def SPEACC: DwarfRegNum<[99, 111]>;
 228 def SPEFSCR: SPR<512, "spefscr">, DwarfRegNum<[612, 112]>;
 229
 230 def XER: SPR<1, "xer">, DwarfRegNum<[76]>;
 231
 232 // Carry bit.  In the architecture this is really bit 0 of the XER register
 233 // (which really is SPR register 1);  this is the only bit interesting to a
 234 // compiler.
 235 def CARRY: SPR<1, "xer">, DwarfRegNum<[76]> {
 236   let Aliases = [XER];
 237 }
 238
 239 // FP rounding mode:  bits 30 and 31 of the FP status and control register
 240 // This is not allocated as a normal register; it appears only in
 241 // Uses and Defs.  The ABI says it needs to be preserved by a function,
 242 // but this is not achieved by saving and restoring it as with
 243 // most registers, it has to be done in code; to make this work all the
 244 // return and call instructions are described as Uses of RM, so instructions
 245 // that do nothing but change RM will not get deleted.
 246 def RM: PPCReg<"**ROUNDING MODE**">;
 247
 248 /// Register classes
 249 // Allocate volatiles first
 250 // then nonvolatiles in reverse order since stmw/lmw save from rN to r31
 251 def GPRC : RegisterClass<"PPC", [i32], 32, (add (sequence "R%u", 2, 12),
 252                                                 (sequence "R%u", 30, 13),
 253                                                 R31, R0, R1, FP, BP)> {
 254   // On non-Darwin PPC64 systems, R2 can be allocated, but must be restored, so
 255   // put it at the end of the list.
 256   let AltOrders = [(add (sub GPRC, R2), R2)];
 257   let AltOrderSelect = [{
 258     const PPCSubtarget &S = MF.getSubtarget<PPCSubtarget>();
 259     return S.isPPC64() && S.isSVR4ABI();
 260   }];
 261 }
 262
 263 def G8RC : RegisterClass<"PPC", [i64], 64, (add (sequence "X%u", 2, 12),
 264                                                 (sequence "X%u", 30, 14),
 265                                                 X31, X13, X0, X1, FP8, BP8)> {
 266   // On non-Darwin PPC64 systems, R2 can be allocated, but must be restored, so
 267   // put it at the end of the list.
 268   let AltOrders = [(add (sub G8RC, X2), X2)];
 269   let AltOrderSelect = [{
 270     const PPCSubtarget &S = MF.getSubtarget<PPCSubtarget>();
 271     return S.isPPC64() && S.isSVR4ABI();
 272   }];
 273 }
 274
 275 // For some instructions r0 is special (representing the value 0 instead of
 276 // the value in the r0 register), and we use these register subclasses to
 277 // prevent r0 from being allocated for use by those instructions.
 278 def GPRC_NOR0 : RegisterClass<"PPC", [i32], 32, (add (sub GPRC, R0), ZERO)> {
 279   // On non-Darwin PPC64 systems, R2 can be allocated, but must be restored, so
 280   // put it at the end of the list.
 281   let AltOrders = [(add (sub GPRC_NOR0, R2), R2)];
 282   let AltOrderSelect = [{
 283     const PPCSubtarget &S = MF.getSubtarget<PPCSubtarget>();
 284     return S.isPPC64() && S.isSVR4ABI();
 285   }];
 286 }
 287
 288 def G8RC_NOX0 : RegisterClass<"PPC", [i64], 64, (add (sub G8RC, X0), ZERO8)> {
 289   // On non-Darwin PPC64 systems, R2 can be allocated, but must be restored, so
 290   // put it at the end of the list.
 291   let AltOrders = [(add (sub G8RC_NOX0, X2), X2)];
 292   let AltOrderSelect = [{
 293     const PPCSubtarget &S = MF.getSubtarget<PPCSubtarget>();
 294     return S.isPPC64() && S.isSVR4ABI();
 295   }];
 296 }
 297
 298 def SPERC : RegisterClass<"PPC", [f64], 64, (add (sequence "S%u", 2, 12),
 299                                                 (sequence "S%u", 30, 13),
 300                                                 S31, S0, S1)>;
 301
 302 def SPE4RC : RegisterClass<"PPC", [f32], 32, (add GPRC)>;
 303
 304 // Allocate volatiles first, then non-volatiles in reverse order. With the SVR4
 305 // ABI the size of the Floating-point register save area is determined by the
 306 // allocated non-volatile register with the lowest register number, as FP
 307 // register N is spilled to offset 8 * (32 - N) below the back chain word of the
 308 // previous stack frame. By allocating non-volatiles in reverse order we make
 309 // sure that the Floating-point register save area is always as small as
 310 // possible because there aren't any unused spill slots.
 311 def F8RC : RegisterClass<"PPC", [f64], 64, (add (sequence "F%u", 0, 13),
 312                                                 (sequence "F%u", 31, 14))>;
 313 def F4RC : RegisterClass<"PPC", [f32], 32, (add F8RC)>;
 314
 315 def VRRC : RegisterClass<"PPC",
 316                          [v16i8,v8i16,v4i32,v2i64,v1i128,v4f32,v2f64, f128],
 317                          128,
 318                          (add V2, V3, V4, V5, V0, V1, V6, V7, V8, V9, V10, V11,
 319                              V12, V13, V14, V15, V16, V17, V18, V19, V31, V30,
 320                              V29, V28, V27, V26, V25, V24, V23, V22, V21, V20)>;
 321
 322 // VSX register classes (the allocation order mirrors that of the corresponding
 323 // subregister classes).
 324 def VSLRC : RegisterClass<"PPC", [v4i32,v4f32,v2f64,v2i64], 128,
 325                           (add (sequence "VSL%u", 0, 13),
 326                                (sequence "VSL%u", 31, 14))>;
 327 def VSRC  : RegisterClass<"PPC", [v4i32,v4f32,v2f64,v2i64], 128,
 328                           (add VSLRC, VRRC)>;
 329
 330 // Register classes for the 64-bit "scalar" VSX subregisters.
 331 def VFRC :  RegisterClass<"PPC", [f64], 64,
 332                           (add VF2, VF3, VF4, VF5, VF0, VF1, VF6, VF7,
 333                                VF8, VF9, VF10, VF11, VF12, VF13, VF14,
 334                                VF15, VF16, VF17, VF18, VF19, VF31, VF30,
 335                                VF29, VF28, VF27, VF26, VF25, VF24, VF23,
 336                                VF22, VF21, VF20)>;
 337 def VSFRC : RegisterClass<"PPC", [f64], 64, (add F8RC, VFRC)>;
 338
 339 // Allow spilling GPR's into caller-saved VSR's.
 340 def SPILLTOVSRRC : RegisterClass<"PPC", [i64, f64], 64, (add G8RC, (sub VSFRC,
 341                                 (sequence "VF%u", 31, 20),
 342                                 (sequence "F%u", 31, 14)))>;
 343
 344 // Register class for single precision scalars in VSX registers
 345 def VSSRC : RegisterClass<"PPC", [f32], 32, (add VSFRC)>;
 346
 347 // For QPX
 348 def QFRC : RegisterClass<"PPC", [v4f64], 256, (add (sequence "QF%u", 0, 13),
 349                                                 (sequence "QF%u", 31, 14))>;
 350 def QSRC : RegisterClass<"PPC", [v4f32], 128, (add QFRC)>;
 351 def QBRC : RegisterClass<"PPC", [v4i1], 256, (add QFRC)> {
 352   // These are actually stored as floating-point values where a positive
 353   // number is true and anything else (including NaN) is false.
 354   let Size = 256;
 355 }
 356
 357 def CRBITRC : RegisterClass<"PPC", [i1], 32,
 358   (add CR2LT, CR2GT, CR2EQ, CR2UN,
 359        CR3LT, CR3GT, CR3EQ, CR3UN,
 360        CR4LT, CR4GT, CR4EQ, CR4UN,
 361        CR5LT, CR5GT, CR5EQ, CR5UN,
 362        CR6LT, CR6GT, CR6EQ, CR6UN,
 363        CR7LT, CR7GT, CR7EQ, CR7UN,
 364        CR1LT, CR1GT, CR1EQ, CR1UN,
 365        CR0LT, CR0GT, CR0EQ, CR0UN)> {
 366   let Size = 32;
 367 }
 368
 369 def CRRC : RegisterClass<"PPC", [i32], 32, (add CR0, CR1, CR5, CR6,
 370                                                 CR7, CR2, CR3, CR4)>;
 371
 372 def CRRC0 : RegisterClass<"PPC", [i32], 32, (add CR0)>;
 373
 374 // The CTR registers are not allocatable because they're used by the
 375 // decrement-and-branch instructions, and thus need to stay live across
 376 // multiple basic blocks.
 377 def CTRRC : RegisterClass<"PPC", [i32], 32, (add CTR)> {
 378   let isAllocatable = 0;
 379 }
 380 def CTRRC8 : RegisterClass<"PPC", [i64], 64, (add CTR8)> {
 381   let isAllocatable = 0;
 382 }
 383
 384 def VRSAVERC : RegisterClass<"PPC", [i32], 32, (add VRSAVE)>;
 385 def CARRYRC : RegisterClass<"PPC", [i32], 32, (add CARRY, XER)> {
 386   let CopyCost = -1;
 387 }
 388