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 foreach Index = 0-31 in {
  79   def F#Index : FPR<Index, "f"#Index>,
  80                 DwarfRegNum<[!add(Index, 32), !add(Index, 32)]>;
  81 }
  82
  83 // Vector registers
  84 foreach Index = 0-31 in {
  85   def V#Index : VR<Index, "v"#Index>,
  86                 DwarfRegNum<[!add(Index, 77), !add(Index, 77)]>;
  87 }
  88
  89 // The reprsentation of r0 when treated as the constant 0.
  90 def ZERO : GPR<0, "r0">;
  91
  92 // Representations of the frame pointer used by ISD::FRAMEADDR.
  93 def FP   : GPR<0 /* arbitrary */, "**FRAME POINTER**">;
  94 def FP8  : GP8<FP, "**FRAME POINTER**">;
  95
  96 // Condition register bits
  97 def CR0LT : CRBIT< 0, "0">;
  98 def CR0GT : CRBIT< 1, "1">;
  99 def CR0EQ : CRBIT< 2, "2">;
 100 def CR0UN : CRBIT< 3, "3">;
 101 def CR1LT : CRBIT< 4, "4">;
 102 def CR1GT : CRBIT< 5, "5">;
 103 def CR1EQ : CRBIT< 6, "6">;
 104 def CR1UN : CRBIT< 7, "7">;
 105 def CR2LT : CRBIT< 8, "8">;
 106 def CR2GT : CRBIT< 9, "9">;
 107 def CR2EQ : CRBIT<10, "10">;
 108 def CR2UN : CRBIT<11, "11">;
 109 def CR3LT : CRBIT<12, "12">;
 110 def CR3GT : CRBIT<13, "13">;
 111 def CR3EQ : CRBIT<14, "14">;
 112 def CR3UN : CRBIT<15, "15">;
 113 def CR4LT : CRBIT<16, "16">;
 114 def CR4GT : CRBIT<17, "17">;
 115 def CR4EQ : CRBIT<18, "18">;
 116 def CR4UN : CRBIT<19, "19">;
 117 def CR5LT : CRBIT<20, "20">;
 118 def CR5GT : CRBIT<21, "21">;
 119 def CR5EQ : CRBIT<22, "22">;
 120 def CR5UN : CRBIT<23, "23">;
 121 def CR6LT : CRBIT<24, "24">;
 122 def CR6GT : CRBIT<25, "25">;
 123 def CR6EQ : CRBIT<26, "26">;
 124 def CR6UN : CRBIT<27, "27">;
 125 def CR7LT : CRBIT<28, "28">;
 126 def CR7GT : CRBIT<29, "29">;
 127 def CR7EQ : CRBIT<30, "30">;
 128 def CR7UN : CRBIT<31, "31">;
 129
 130 // Condition registers
 131 let SubRegIndices = [sub_lt, sub_gt, sub_eq, sub_un] in {
 132 def CR0 : CR<0, "cr0", [CR0LT, CR0GT, CR0EQ, CR0UN]>, DwarfRegNum<[68, 68]>;
 133 def CR1 : CR<1, "cr1", [CR1LT, CR1GT, CR1EQ, CR1UN]>, DwarfRegNum<[69, 69]>;
 134 def CR2 : CR<2, "cr2", [CR2LT, CR2GT, CR2EQ, CR2UN]>, DwarfRegNum<[70, 70]>;
 135 def CR3 : CR<3, "cr3", [CR3LT, CR3GT, CR3EQ, CR3UN]>, DwarfRegNum<[71, 71]>;
 136 def CR4 : CR<4, "cr4", [CR4LT, CR4GT, CR4EQ, CR4UN]>, DwarfRegNum<[72, 72]>;
 137 def CR5 : CR<5, "cr5", [CR5LT, CR5GT, CR5EQ, CR5UN]>, DwarfRegNum<[73, 73]>;
 138 def CR6 : CR<6, "cr6", [CR6LT, CR6GT, CR6EQ, CR6UN]>, DwarfRegNum<[74, 74]>;
 139 def CR7 : CR<7, "cr7", [CR7LT, CR7GT, CR7EQ, CR7UN]>, DwarfRegNum<[75, 75]>;
 140 }
 141
 142 // Link register
 143 def LR  : SPR<8, "lr">, DwarfRegNum<[-2, 65]>;
 144 //let Aliases = [LR] in
 145 def LR8 : SPR<8, "lr">, DwarfRegNum<[65, -2]>;
 146
 147 // Count register
 148 def CTR  : SPR<9, "ctr">, DwarfRegNum<[-2, 66]>;
 149 def CTR8 : SPR<9, "ctr">, DwarfRegNum<[66, -2]>;
 150
 151 // VRsave register
 152 def VRSAVE: SPR<256, "VRsave">, DwarfRegNum<[109]>;
 153
 154 // Carry bit.  In the architecture this is really bit 0 of the XER register
 155 // (which really is SPR register 1);  this is the only bit interesting to a
 156 // compiler.
 157 def CARRY: SPR<1, "ca">;
 158
 159 // FP rounding mode:  bits 30 and 31 of the FP status and control register
 160 // This is not allocated as a normal register; it appears only in
 161 // Uses and Defs.  The ABI says it needs to be preserved by a function,
 162 // but this is not achieved by saving and restoring it as with
 163 // most registers, it has to be done in code; to make this work all the
 164 // return and call instructions are described as Uses of RM, so instructions
 165 // that do nothing but change RM will not get deleted.
 166 // Also, in the architecture it is not really a SPR; 512 is arbitrary.
 167 def RM: SPR<512, "**ROUNDING MODE**">;
 168
 169 /// Register classes
 170 // Allocate volatiles first
 171 // then nonvolatiles in reverse order since stmw/lmw save from rN to r31
 172 def GPRC : RegisterClass<"PPC", [i32], 32, (add (sequence "R%u", 2, 12),
 173                                                 (sequence "R%u", 30, 13),
 174                                                 R31, R0, R1, LR, FP)>;
 175
 176 def G8RC : RegisterClass<"PPC", [i64], 64, (add (sequence "X%u", 2, 12),
 177                                                 (sequence "X%u", 30, 14),
 178                                                 X31, X13, X0, X1, LR8, FP8)>;
 179
 180 // For some instructions r0 is special (representing the value 0 instead of
 181 // the value in the r0 register), and we use these register subclasses to
 182 // prevent r0 from being allocated for use by those instructions.
 183 def GPRC_NOR0 : RegisterClass<"PPC", [i32], 32, (add (sub GPRC, R0), ZERO)>;
 184 def G8RC_NOX0 : RegisterClass<"PPC", [i64], 64, (add (sub G8RC, X0), ZERO)>;
 185
 186 // Allocate volatiles first, then non-volatiles in reverse order. With the SVR4
 187 // ABI the size of the Floating-point register save area is determined by the
 188 // allocated non-volatile register with the lowest register number, as FP
 189 // register N is spilled to offset 8 * (32 - N) below the back chain word of the
 190 // previous stack frame. By allocating non-volatiles in reverse order we make
 191 // sure that the Floating-point register save area is always as small as
 192 // possible because there aren't any unused spill slots.
 193 def F8RC : RegisterClass<"PPC", [f64], 64, (add (sequence "F%u", 0, 13),
 194                                                 (sequence "F%u", 31, 14))>;
 195 def F4RC : RegisterClass<"PPC", [f32], 32, (add F8RC)>;
 196
 197 def VRRC : RegisterClass<"PPC", [v16i8,v8i16,v4i32,v4f32], 128,
 198                          (add V2, V3, V4, V5, V0, V1, V6, V7, V8, V9, V10, V11,
 199                              V12, V13, V14, V15, V16, V17, V18, V19, V31, V30,
 200                              V29, V28, V27, V26, V25, V24, V23, V22, V21, V20)>;
 201
 202 def CRBITRC : RegisterClass<"PPC", [i32], 32,
 203   (add CR0LT, CR0GT, CR0EQ, CR0UN,
 204        CR1LT, CR1GT, CR1EQ, CR1UN,
 205        CR2LT, CR2GT, CR2EQ, CR2UN,
 206        CR3LT, CR3GT, CR3EQ, CR3UN,
 207        CR4LT, CR4GT, CR4EQ, CR4UN,
 208        CR5LT, CR5GT, CR5EQ, CR5UN,
 209        CR6LT, CR6GT, CR6EQ, CR6UN,
 210        CR7LT, CR7GT, CR7EQ, CR7UN)>
 211 {
 212   let CopyCost = -1;
 213 }
 214
 215 def CRRC : RegisterClass<"PPC", [i32], 32, (add CR0, CR1, CR5, CR6,
 216                                                 CR7, CR2, CR3, CR4)>;
 217
 218 // The CTR registers are not allocatable because they're used by the
 219 // decrement-and-branch instructions, and thus need to stay live across
 220 // multiple basic blocks.
 221 def CTRRC : RegisterClass<"PPC", [i32], 32, (add CTR)> {
 222   let isAllocatable = 0;
 223 }
 224 def CTRRC8 : RegisterClass<"PPC", [i64], 64, (add CTR8)> {
 225   let isAllocatable = 0;
 226 }
 227
 228 def VRSAVERC : RegisterClass<"PPC", [i32], 32, (add VRSAVE)>;
 229 def CARRYRC : RegisterClass<"PPC", [i32], 32, (add CARRY)> {
 230   let CopyCost = -1;
 231 }