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