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 def sub_128 : SubRegIndex<128>;
  21 }
  22
  23
  24 class PPCReg<string n> : Register<n> {
  25   let Namespace = "PPC";
  26 }
  27
  28 // We identify all our registers with a 5-bit ID, for consistency's sake.
  29
  30 // GPR - One of the 32 32-bit general-purpose registers
  31 class GPR<bits<5> num, string n> : PPCReg<n> {
  32   let HWEncoding{4-0} = num;
  33 }
  34
  35 // GP8 - One of the 32 64-bit general-purpose registers
  36 class GP8<GPR SubReg, string n> : PPCReg<n> {
  37   let HWEncoding = SubReg.HWEncoding;
  38   let SubRegs = [SubReg];
  39   let SubRegIndices = [sub_32];
  40 }
  41
  42 // SPR - One of the 32-bit special-purpose registers
  43 class SPR<bits<10> num, string n> : PPCReg<n> {
  44   let HWEncoding{9-0} = num;
  45 }
  46
  47 // FPR - One of the 32 64-bit floating-point registers
  48 class FPR<bits<5> num, string n> : PPCReg<n> {
  49   let HWEncoding{4-0} = num;
  50 }
  51
  52 // VR - One of the 32 128-bit vector registers
  53 class VR<bits<5> num, string n> : PPCReg<n> {
  54   let HWEncoding{4-0} = num;
  55 }
  56
  57 // VSRL - One of the 32 128-bit VSX registers that overlap with the scalar
  58 // floating-point registers.
  59 class VSRL<FPR SubReg, string n> : PPCReg<n> {
  60   let HWEncoding = SubReg.HWEncoding;
  61   let SubRegs = [SubReg];
  62   let SubRegIndices = [sub_64];
  63 }
  64
  65 // VSRH - One of the 32 128-bit VSX registers that overlap with the vector
  66 // registers.
  67 class VSRH<VR SubReg, string n> : PPCReg<n> {
  68   let HWEncoding{4-0} = SubReg.HWEncoding{4-0};
  69   let HWEncoding{5} = 1;
  70   let SubRegs = [SubReg];
  71   let SubRegIndices = [sub_128];
  72 }
  73
  74 // CR - One of the 8 4-bit condition registers
  75 class CR<bits<3> num, string n, list<Register> subregs> : PPCReg<n> {
  76   let HWEncoding{2-0} = num;
  77   let SubRegs = subregs;
  78 }
  79
  80 // CRBIT - One of the 32 1-bit condition register fields
  81 class CRBIT<bits<5> num, string n> : PPCReg<n> {
  82   let HWEncoding{4-0} = num;
  83 }
  84
  85 // General-purpose registers
  86 foreach Index = 0-31 in {
  87   def R#Index : GPR<Index, "r"#Index>, DwarfRegNum<[-2, Index]>;
  88 }
  89
  90 // 64-bit General-purpose registers
  91 foreach Index = 0-31 in {
  92   def X#Index : GP8<!cast<GPR>("R"#Index), "r"#Index>,
  93                     DwarfRegNum<[Index, -2]>;
  94 }
  95
  96 // Floating-point registers
  97 foreach Index = 0-31 in {
  98   def F#Index : FPR<Index, "f"#Index>,
  99                 DwarfRegNum<[!add(Index, 32), !add(Index, 32)]>;
 100 }
 101
 102 // Vector registers
 103 foreach Index = 0-31 in {
 104   def V#Index : VR<Index, "v"#Index>,
 105                 DwarfRegNum<[!add(Index, 77), !add(Index, 77)]>;
 106 }
 107
 108 // VSX registers
 109 foreach Index = 0-31 in {
 110   def VSL#Index : VSRL<!cast<FPR>("F"#Index), "vs"#Index>,
 111                   DwarfRegAlias<!cast<FPR>("F"#Index)>;
 112 }
 113 foreach Index = 0-31 in {
 114   def VSH#Index : VSRH<!cast<VR>("V"#Index), "vs" # !add(Index, 32)>,
 115                   DwarfRegAlias<!cast<VR>("V"#Index)>;
 116 }
 117
 118 // The reprsentation of r0 when treated as the constant 0.
 119 def ZERO  : GPR<0, "0">;
 120 def ZERO8 : GP8<ZERO, "0">;
 121
 122 // Representations of the frame pointer used by ISD::FRAMEADDR.
 123 def FP   : GPR<0 /* arbitrary */, "**FRAME POINTER**">;
 124 def FP8  : GP8<FP, "**FRAME POINTER**">;
 125
 126 // Representations of the base pointer used by setjmp.
 127 def BP   : GPR<0 /* arbitrary */, "**BASE POINTER**">;
 128 def BP8  : GP8<BP, "**BASE POINTER**">;
 129
 130 // Condition register bits
 131 def CR0LT : CRBIT< 0, "0">;
 132 def CR0GT : CRBIT< 1, "1">;
 133 def CR0EQ : CRBIT< 2, "2">;
 134 def CR0UN : CRBIT< 3, "3">;
 135 def CR1LT : CRBIT< 4, "4">;
 136 def CR1GT : CRBIT< 5, "5">;
 137 def CR1EQ : CRBIT< 6, "6">;
 138 def CR1UN : CRBIT< 7, "7">;
 139 def CR2LT : CRBIT< 8, "8">;
 140 def CR2GT : CRBIT< 9, "9">;
 141 def CR2EQ : CRBIT<10, "10">;
 142 def CR2UN : CRBIT<11, "11">;
 143 def CR3LT : CRBIT<12, "12">;
 144 def CR3GT : CRBIT<13, "13">;
 145 def CR3EQ : CRBIT<14, "14">;
 146 def CR3UN : CRBIT<15, "15">;
 147 def CR4LT : CRBIT<16, "16">;
 148 def CR4GT : CRBIT<17, "17">;
 149 def CR4EQ : CRBIT<18, "18">;
 150 def CR4UN : CRBIT<19, "19">;
 151 def CR5LT : CRBIT<20, "20">;
 152 def CR5GT : CRBIT<21, "21">;
 153 def CR5EQ : CRBIT<22, "22">;
 154 def CR5UN : CRBIT<23, "23">;
 155 def CR6LT : CRBIT<24, "24">;
 156 def CR6GT : CRBIT<25, "25">;
 157 def CR6EQ : CRBIT<26, "26">;
 158 def CR6UN : CRBIT<27, "27">;
 159 def CR7LT : CRBIT<28, "28">;
 160 def CR7GT : CRBIT<29, "29">;
 161 def CR7EQ : CRBIT<30, "30">;
 162 def CR7UN : CRBIT<31, "31">;
 163
 164 // Condition registers
 165 let SubRegIndices = [sub_lt, sub_gt, sub_eq, sub_un] in {
 166 def CR0 : CR<0, "cr0", [CR0LT, CR0GT, CR0EQ, CR0UN]>, DwarfRegNum<[68, 68]>;
 167 def CR1 : CR<1, "cr1", [CR1LT, CR1GT, CR1EQ, CR1UN]>, DwarfRegNum<[69, 69]>;
 168 def CR2 : CR<2, "cr2", [CR2LT, CR2GT, CR2EQ, CR2UN]>, DwarfRegNum<[70, 70]>;
 169 def CR3 : CR<3, "cr3", [CR3LT, CR3GT, CR3EQ, CR3UN]>, DwarfRegNum<[71, 71]>;
 170 def CR4 : CR<4, "cr4", [CR4LT, CR4GT, CR4EQ, CR4UN]>, DwarfRegNum<[72, 72]>;
 171 def CR5 : CR<5, "cr5", [CR5LT, CR5GT, CR5EQ, CR5UN]>, DwarfRegNum<[73, 73]>;
 172 def CR6 : CR<6, "cr6", [CR6LT, CR6GT, CR6EQ, CR6UN]>, DwarfRegNum<[74, 74]>;
 173 def CR7 : CR<7, "cr7", [CR7LT, CR7GT, CR7EQ, CR7UN]>, DwarfRegNum<[75, 75]>;
 174 }
 175
 176 // Link register
 177 def LR  : SPR<8, "lr">, DwarfRegNum<[-2, 65]>;
 178 //let Aliases = [LR] in
 179 def LR8 : SPR<8, "lr">, DwarfRegNum<[65, -2]>;
 180
 181 // Count register
 182 def CTR  : SPR<9, "ctr">, DwarfRegNum<[-2, 66]>;
 183 def CTR8 : SPR<9, "ctr">, DwarfRegNum<[66, -2]>;
 184
 185 // VRsave register
 186 def VRSAVE: SPR<256, "vrsave">, DwarfRegNum<[109]>;
 187
 188 // Carry bit.  In the architecture this is really bit 0 of the XER register
 189 // (which really is SPR register 1);  this is the only bit interesting to a
 190 // compiler.
 191 def CARRY: SPR<1, "ca">;
 192
 193 // FP rounding mode:  bits 30 and 31 of the FP status and control register
 194 // This is not allocated as a normal register; it appears only in
 195 // Uses and Defs.  The ABI says it needs to be preserved by a function,
 196 // but this is not achieved by saving and restoring it as with
 197 // most registers, it has to be done in code; to make this work all the
 198 // return and call instructions are described as Uses of RM, so instructions
 199 // that do nothing but change RM will not get deleted.
 200 // Also, in the architecture it is not really a SPR; 512 is arbitrary.
 201 def RM: SPR<512, "**ROUNDING MODE**">;
 202
 203 /// Register classes
 204 // Allocate volatiles first
 205 // then nonvolatiles in reverse order since stmw/lmw save from rN to r31
 206 def GPRC : RegisterClass<"PPC", [i32], 32, (add (sequence "R%u", 2, 12),
 207                                                 (sequence "R%u", 30, 13),
 208                                                 R31, R0, R1, FP, BP)>;
 209
 210 def G8RC : RegisterClass<"PPC", [i64], 64, (add (sequence "X%u", 2, 12),
 211                                                 (sequence "X%u", 30, 14),
 212                                                 X31, X13, X0, X1, FP8, BP8)>;
 213
 214 // For some instructions r0 is special (representing the value 0 instead of
 215 // the value in the r0 register), and we use these register subclasses to
 216 // prevent r0 from being allocated for use by those instructions.
 217 def GPRC_NOR0 : RegisterClass<"PPC", [i32], 32, (add (sub GPRC, R0), ZERO)>;
 218 def G8RC_NOX0 : RegisterClass<"PPC", [i64], 64, (add (sub G8RC, X0), ZERO8)>;
 219
 220 // Allocate volatiles first, then non-volatiles in reverse order. With the SVR4
 221 // ABI the size of the Floating-point register save area is determined by the
 222 // allocated non-volatile register with the lowest register number, as FP
 223 // register N is spilled to offset 8 * (32 - N) below the back chain word of the
 224 // previous stack frame. By allocating non-volatiles in reverse order we make
 225 // sure that the Floating-point register save area is always as small as
 226 // possible because there aren't any unused spill slots.
 227 def F8RC : RegisterClass<"PPC", [f64], 64, (add (sequence "F%u", 0, 13),
 228                                                 (sequence "F%u", 31, 14))>;
 229 def F4RC : RegisterClass<"PPC", [f32], 32, (add F8RC)>;
 230
 231 def VRRC : RegisterClass<"PPC", [v16i8,v8i16,v4i32,v4f32], 128,
 232                          (add V2, V3, V4, V5, V0, V1, V6, V7, V8, V9, V10, V11,
 233                              V12, V13, V14, V15, V16, V17, V18, V19, V31, V30,
 234                              V29, V28, V27, V26, V25, V24, V23, V22, V21, V20)>;
 235
 236 // VSX register classes (the allocation order mirrors that of the corresponding
 237 // subregister classes).
 238 def VSLRC : RegisterClass<"PPC", [v4i32,v4f32,f64,v2f64,v2i64], 128,
 239                           (add (sequence "VSL%u", 0, 13),
 240                                (sequence "VSL%u", 31, 14))>;
 241 def VSHRC : RegisterClass<"PPC", [v4i32,v4f32,f64,v2f64,v2i64], 128,
 242                           (add VSH2, VSH3, VSH4, VSH5, VSH0, VSH1, VSH6, VSH7,
 243                                VSH8, VSH9, VSH10, VSH11, VSH12, VSH13, VSH14,
 244                                VSH15, VSH16, VSH17, VSH18, VSH19, VSH31, VSH30,
 245                                VSH29, VSH28, VSH27, VSH26, VSH25, VSH24, VSH23,
 246                                VSH22, VSH21, VSH20)>;
 247 def VSRC  : RegisterClass<"PPC", [v4i32,v4f32,f64,v2f64,v2i64], 128,
 248                           (add VSLRC, VSHRC)>;
 249
 250 def CRBITRC : RegisterClass<"PPC", [i1], 32,
 251   (add CR2LT, CR2GT, CR2EQ, CR2UN,
 252        CR3LT, CR3GT, CR3EQ, CR3UN,
 253        CR4LT, CR4GT, CR4EQ, CR4UN,
 254        CR5LT, CR5GT, CR5EQ, CR5UN,
 255        CR6LT, CR6GT, CR6EQ, CR6UN,
 256        CR7LT, CR7GT, CR7EQ, CR7UN,
 257        CR1LT, CR1GT, CR1EQ, CR1UN,
 258        CR0LT, CR0GT, CR0EQ, CR0UN)> {
 259   let Size = 32;
 260 }
 261
 262 def CRRC : RegisterClass<"PPC", [i32], 32, (add CR0, CR1, CR5, CR6,
 263                                                 CR7, CR2, CR3, CR4)>;
 264
 265 // The CTR registers are not allocatable because they're used by the
 266 // decrement-and-branch instructions, and thus need to stay live across
 267 // multiple basic blocks.
 268 def CTRRC : RegisterClass<"PPC", [i32], 32, (add CTR)> {
 269   let isAllocatable = 0;
 270 }
 271 def CTRRC8 : RegisterClass<"PPC", [i64], 64, (add CTR8)> {
 272   let isAllocatable = 0;
 273 }
 274
 275 def VRSAVERC : RegisterClass<"PPC", [i32], 32, (add VRSAVE)>;
 276 def CARRYRC : RegisterClass<"PPC", [i32], 32, (add CARRY)> {
 277   let CopyCost = -1;
 278 }