contrib/llvm/lib/Target/PowerPC/PPCRegisterInfo.td

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