lib/Target/SparcV9/SparcV9.td

   1 //===- Sparc.td - Target Description for Sparc V9 Target --------*- C++ -*-===//
   2 //
   3 //===----------------------------------------------------------------------===//
   4
   5 //===----------------------------------------------------------------------===//
   6 //  Target-Independent interface
   7 //===----------------------------------------------------------------------===//
   8
   9 class Register {
  10   string Namespace = "";
  11   int Size;
  12 }
  13
  14 class Instruction {
  15   string Name;          // The opcode string for this instruction
  16   string Namespace = "";
  17
  18   list<Register> Uses = [];  // Default to using no non-operand registers
  19   list<Register> Defs = [];  // Default to modifying no non-operand registers
  20
  21   // These bits capture information about the high-level semantics of the
  22   // instruction.
  23   bit isReturn     = 0;      // Is this instruction a return instruction?
  24   bit isBranch     = 0;      // Is this instruction a branch instruction?
  25   bit isCall       = 0;      // Is this instruction a call instruction?
  26 }
  27
  28
  29 //===----------------------------------------------------------------------===//
  30 //  Declarations that describe the Sparc register file
  31 //===----------------------------------------------------------------------===//
  32
  33 class V9Reg : Register { set Namespace = "SparcV9"; }
  34
  35 // Ri - One of the 32 64 bit integer registers
  36 class Ri<bits<5> num> : V9Reg { set Size = 64; field bits<5> Num = num; }
  37
  38 def G0 : Ri<0>;    def G1 : Ri<1>;    def G2 : Ri<2>;    def G3 : Ri<3>;
  39 // ...
  40
  41
  42 //===----------------------------------------------------------------------===//
  43 // This is temporary testing stuff.....
  44 //===----------------------------------------------------------------------===//
  45
  46 class InstV9 : Instruction {          // Sparc instruction baseline
  47   field bits<32> Inst;
  48
  49   set Namespace = "SparcV9";
  50
  51   bits<2> op;
  52   set Inst{31-30} = op;               // Top two bits are the 'op' field
  53
  54   // Bit attributes specific to Sparc instructions
  55   bit isPasi       = 0; // Does this instruction affect an alternate addr space?
  56   bit isDeprecated = 0; // Is this instruction deprecated?
  57   bit isPrivileged = 0; // Is this a privileged instruction?
  58 }
  59
  60
  61 //===----------------------------------------------------------------------===//
  62 // Format #2 classes
  63 //
  64 class F2 : InstV9 {                   // Format 2 instructions
  65   bits<3> op2;
  66   set op = 0;    // Op = 0
  67   set Inst{24-22} = op2;
  68 }
  69
  70 class F2_br : F2 {                    // Format 2 Branch instruction
  71   bit annul;  // All branches have an annul bit
  72   set Inst{29} = annul;
  73   set isBranch    = 1;      // All instances are branch instructions
  74 }
  75
  76 class F2_2<bits<4> cond, string name> : F2_br { // Format 2.2 instructions
  77   bits<22> disp;
  78
  79   set Name        = name;
  80   set Inst{28-25} = cond;
  81   set Inst{21-0}  = disp;
  82 }
  83
  84 class F2_3<bits<4> cond, string name> : F2_br { // Format 2.3 instructions
  85   bits<2> cc;
  86   bits<19> disp;
  87   bit predict;
  88
  89   set Name        = name;
  90   set Inst{28-25} = cond;
  91   set Inst{21-20} = cc;
  92   set Inst{19}    = predict;
  93   set Inst{18-0}  = disp;
  94 }
  95
  96 class F2_4<bits<3> rcond, string name> : F2_br { // Format 2.4 instructions
  97   // Variables exposed by the instruction...
  98   bit        predict;
  99   bits<5>    rs1;
 100   bits<16>   disp;
 101
 102   set Name = name;
 103   set Inst{28}    = 0;
 104   set Inst{27-25} = rcond;
 105   //  Inst{24-22} = op2 field
 106   set Inst{21-20} = disp{15-14};
 107   set Inst{19}    = predict;
 108   set Inst{18-14} = rs1;
 109   set Inst{13-0 } = disp{13-0};
 110 }
 111
 112
 113 //===----------------------------------------------------------------------===//
 114 // Format #3 classes
 115 //
 116
 117 // F3 - Common superclass of all F3 instructions.  All instructions have an op3
 118 // field.
 119 class F3 : InstV9 {
 120   bits<6> op3;
 121   set op{1} = 1;   // Op = 2 or 3
 122   set Inst{24-19} = op3;
 123 }
 124
 125 // F3_rs1 - Common superclass of instructions that use rs1
 126 class F3_rs1 : F3 {
 127   bits<5> rs1;
 128   set Inst{18-14} = rs1;
 129 }
 130
 131 // F3_rs1rd - Common superclass of instructions that use rs1 & rd...
 132 class F3_rs1rd : F3_rs1 {
 133   bits<5> rd;
 134   set Inst{29-25} = rd;
 135 }
 136
 137 // F3_rs1rdrs2 - Common superclass of instructions with rs1, rd, & rs2 fields
 138 class F3_rs1rdrs2 : F3_rs1 {
 139   bits<5> rs2;
 140   set Inst{4-0} = rs2;
 141 }
 142
 143 // Specific F3 classes...
 144 //
 145
 146 class F3_1<bits<2> opVal,   bits<6> op3val,   string name> : F3_rs1rdrs2 {
 147   set op  = opVal;
 148   set op3 = op3val;
 149   set Name = name;
 150   set Inst{13} = 0;   // i field = 0
 151   //set Inst{12-5} = dontcare;
 152 }
 153
 154 class F3_2<bits<2> opVal,   bits<6> op3val,   string name> : F3_rs1rd {
 155   bits<13> simm;
 156
 157   set op  = opVal;
 158   set op3 = op3val;
 159   set Name = name;
 160   set Inst{13} = 1;   // i field = 1
 161   set Inst{12-0} = simm;
 162 }
 163
 164 class F3_3<bits<2> opVal,   bits<6> op3val,   string name> : F3_rs1 {
 165   bits<5> rs2;
 166   set op   = opVal;
 167   set op3  = op3val;
 168   set Name = name;
 169   //set Inst{29-25} = dontcare;
 170   set Inst{13}  = 0;
 171   //set Inst{12-5} = dontcare;
 172   set Inst{4-0} = rs2;
 173 }
 174
 175 class F3_4<bits<2> opVal,   bits<6> op3val,   string name> : F3_rs1 {
 176   bits<13> simm;
 177   set op   = opVal;
 178   set op3  = op3val;
 179   set Name = name;
 180   //set Inst{29-25} = dontcare;
 181   set Inst{13}  = 1;
 182   set Inst{12-0} = simm;
 183 }
 184
 185
 186
 187 class F3_16<bits<2> opVal,  bits<6> op3val,
 188             bits<9> opfval, string name> : F3_rs1rdrs2 {
 189   set op  = opVal;
 190   set op3 = op3val;
 191   set Name = name;
 192   set Inst{13-5} = opfval;
 193 }
 194
 195 class F3_18<bits<5> fcn, string name> : F3 {
 196   set op = 2;
 197   set op3 = 0b111110;
 198   set Name = name;
 199   set Inst{29-25} = fcn;
 200   //set Inst{18-0 } = dontcare;
 201 }
 202
 203 //===----------------------------------------------------------------------===//
 204 // Instruction list...
 205 //
 206
 207 // Section A.2: p161
 208 def ADDr    : F3_1<2, 0b000000, "add">;             // add r, r, r
 209 def ADDi    : F3_2<2, 0b000000, "add">;             // add r, r, i
 210 def ADDCCr  : F3_1<2, 0b010000, "addcc">;           // addcc r, r, r
 211 def ADDCCi  : F3_2<2, 0b010000, "addcc">;           // addcc r, r, i
 212 def ADDCr   : F3_1<2, 0b001000, "addC">;            // addC r, r, r
 213 def ADDCi   : F3_2<2, 0b001000, "addC">;            // addC r, r, i
 214 def ADDCCCr : F3_1<2, 0b011000, "addCcc">;          // addCcc r, r, r
 215 def ADDCCCi : F3_2<2, 0b011000, "addCcc">;          // addCcc r, r, i
 216
 217 // Section A.3: p162
 218 set op2 = 0b011 in {
 219   def BRZ     : F2_4<0b001, "brz">;                 // Branch on rs1 == 0
 220   def BRLEZ   : F2_4<0b010, "brlez">;               // Branch on rs1 <= 0
 221   def BRLZ    : F2_4<0b011, "brlz">;                // Branch on rs1 <  0
 222   def BRNZ    : F2_4<0b101, "brnz">;                // Branch on rs1 != 0
 223   def BRGZ    : F2_4<0b110, "brgz">;                // Branch on rs1 >  0
 224   def BRGEZ   : F2_4<0b111, "brgez">;               // Branch on rs1 >= 0
 225 }
 226
 227 // Section A.4: p164
 228 set isDeprecated = 1 in {
 229   set op2 = 0b110 in {
 230     def FBA     : F2_2<0b1000, "fba">;              // Branch always
 231     def FBN     : F2_2<0b0000, "fbn">;              // Branch never
 232     def FBU     : F2_2<0b0111, "fbu">;              // Branch on unordered
 233     def FBG     : F2_2<0b0110, "fbg">;              // Branch >
 234     def FBUG    : F2_2<0b0101, "fbug">;             // Branch on unordered or >
 235     def FBL     : F2_2<0b0100, "fbl">;              // Branch <
 236     def FBUL    : F2_2<0b0011, "fbul">;             // Branch on unordered or <
 237     def FBLG    : F2_2<0b0010, "fblg">;             // Branch < or >
 238     def FBNE    : F2_2<0b0001, "fbne">;             // Branch !=
 239     def FBE     : F2_2<0b1001, "fbe">;              // Branch ==
 240     def FBUE    : F2_2<0b1010, "fbue">;             // Branch on unordered or ==
 241     def FBGE    : F2_2<0b1011, "fbge">;             // Branch > or ==
 242     def FBUGE   : F2_2<0b1100, "fbuge">;            // Branch unord or > or ==
 243     def FBLE    : F2_2<0b1101, "fble">;             // Branch < or ==
 244     def FBULE   : F2_2<0b1110, "fbule">;            // Branch unord or < or ==
 245     def FBO     : F2_2<0b1111, "fbo">;              // Branch on ordered
 246   }
 247 }
 248
 249 // Section A.5: p167
 250 set op2 = 0b101 in {
 251   def FBPA     : F2_3<0b1000, "fbpa">;              // Branch always
 252   def FBPN     : F2_3<0b0000, "fbpn">;              // Branch never
 253   def FBPU     : F2_3<0b0111, "fbpu">;              // Branch on unordered
 254   def FBPG     : F2_3<0b0110, "fbpg">;              // Branch >
 255   def FBPUG    : F2_3<0b0101, "fbpug">;             // Branch on unordered or >
 256   def FBPL     : F2_3<0b0100, "fbpl">;              // Branch <
 257   def FBPUL    : F2_3<0b0011, "fbpul">;             // Branch on unordered or <
 258   def FBPLG    : F2_3<0b0010, "fbplg">;             // Branch < or >
 259   def FBPNE    : F2_3<0b0001, "fbpne">;             // Branch !=
 260   def FBPE     : F2_3<0b1001, "fbpe">;              // Branch ==
 261   def FBPUE    : F2_3<0b1010, "fbpue">;             // Branch on unordered or ==
 262   def FBPGE    : F2_3<0b1011, "fbpge">;             // Branch > or ==
 263   def FBPUGE   : F2_3<0b1100, "fbpuge">;            // Branch unord or > or ==
 264   def FBPLE    : F2_3<0b1101, "fbple">;             // Branch < or ==
 265   def FBPULE   : F2_3<0b1110, "fbpule">;            // Branch unord or < or ==
 266   def FBPO     : F2_3<0b1111, "fbpo">;              // Branch on ordered
 267 }
 268
 269 // Section A.6: p170: Bicc
 270 set isDeprecated = 1 in {
 271   set op2 = 0b010 in {
 272     def BA     : F2_2<0b1000, "ba">;              // Branch always
 273     def BN     : F2_2<0b0000, "bn">;              // Branch never
 274     def BNE    : F2_2<0b1001, "bne">;             // Branch !=
 275     def BE     : F2_2<0b0001, "be">;              // Branch ==
 276     def BG     : F2_2<0b1010, "bg">;              // Branch >
 277     def BLE    : F2_2<0b0010, "ble">;             // Branch <=
 278     def BGE    : F2_2<0b1011, "bge">;             // Branch >=
 279     def BL     : F2_2<0b0011, "bl">;              // Branch <
 280     def BGU    : F2_2<0b1100, "bgu">;             // Branch unsigned >
 281     def BLEU   : F2_2<0b0100, "bleu">;            // Branch unsigned <=
 282     def BCC    : F2_2<0b1101, "bcc">;             // Branch unsigned >=
 283     def BCS    : F2_2<0b0101, "bcs">;             // Branch unsigned <=
 284     def BPOS   : F2_2<0b1110, "bpos">;            // Branch on positive
 285     def BNEG   : F2_2<0b0110, "bneg">;            // Branch on negative
 286     def BVC    : F2_2<0b1111, "bvc">;             // Branch on overflow clear
 287     def BVS    : F2_2<0b0111, "bvs">;             // Branch on overflow set
 288   }
 289 }
 290
 291 // Section A.7: p172
 292 set op2 = 0b001 in {
 293   def BPA     : F2_3<0b1000, "bpa">;              // Branch always
 294   def BPN     : F2_3<0b0000, "bpn">;              // Branch never
 295   def BPNE    : F2_3<0b1001, "bpne">;             // Branch !=
 296   def BPE     : F2_3<0b0001, "bpe">;              // Branch ==
 297   def BPG     : F2_3<0b1010, "bpg">;              // Branch >
 298   def BPLE    : F2_3<0b0010, "bple">;             // Branch <=
 299   def BPGE    : F2_3<0b1011, "bpge">;             // Branch >=
 300   def BPL     : F2_3<0b0011, "bpl">;              // Branch <
 301   def BPGU    : F2_3<0b1100, "bpgu">;             // Branch unsigned >
 302
 303   def BPLEU   : F2_3<0b0100, "bpleu">;            // Branch unsigned <=
 304   def BPCC    : F2_3<0b1101, "bpcc">;             // Branch unsigned >=
 305   def BPCS    : F2_3<0b0101, "bpcs">;             // Branch unsigned <=
 306   def BPPOS   : F2_3<0b1110, "bppos">;            // Branch on positive
 307   def BPNEG   : F2_3<0b0110, "bpneg">;            // Branch on negative
 308   def BPVC    : F2_3<0b1111, "bpvc">;             // Branch on overflow clear
 309   def BPVS    : F2_3<0b0111, "bpvs">;             // Branch on overflow set
 310 }
 311
 312 // Section A.8: p175 - CALL - the only Format #1 instruction
 313 def CALL : InstV9 {
 314   bits<30> disp;
 315   set op = 1;
 316   set Inst{29-0} = disp;
 317   set Name = "call";
 318   set isCall = 1;
 319 }
 320
 321 // Section A.9: Compare and Swap - p176
 322 // CASA/CASXA: are for alternate address spaces!  Ignore them
 323
 324
 325 // Section A.10: Divide (64-bit / 32-bit) - p178
 326 set isDeprecated = 1 in {
 327   def UDIVr   : F3_1<2, 0b001110, "udiv">;        // udiv r, r, r
 328   def UDIVi   : F3_2<2, 0b001110, "udiv">;        // udiv r, r, i
 329   def SDIVr   : F3_1<2, 0b001111, "sdiv">;        // sdiv r, r, r
 330   def SDIVi   : F3_2<2, 0b001111, "sdiv">;        // sdiv r, r, i
 331   def UDIVCCr : F3_1<2, 0b011110, "udivcc">;      // udivcc r, r, r
 332   def UDIVCCi : F3_2<2, 0b011110, "udivcc">;      // udivcc r, r, i
 333   def SDIVCCr : F3_1<2, 0b011111, "sdivcc">;      // sdivcc r, r, r
 334   def SDIVCCi : F3_2<2, 0b011111, "sdivcc">;      // sdivcc r, r, i
 335 }
 336
 337 // Section A.11: DONE and RETRY - p181
 338 set isPrivileged = 1 in {
 339   def DONE    : F3_18<0, "done">;                 // done
 340   def RETRY   : F3_18<1, "retry">;                // retry
 341 }
 342
 343 // Section A.12: Floating-Point Add and Subtract - p182
 344 def FADDS : F3_16<2, 0b110100, 0x41, "fadds">;    // fadds f, f, f
 345 def FADDD : F3_16<2, 0b110100, 0x42, "faddd">;    // faddd f, f, f
 346 def FADDQ : F3_16<2, 0b110100, 0x43, "faddq">;    // faddq f, f, f
 347 def FSUBS : F3_16<2, 0b110100, 0x45, "fsubs">;    // fsubs f, f, f
 348 def FSUBD : F3_16<2, 0b110100, 0x46, "fsubd">;    // fsubd f, f, f
 349 def FSUBQ : F3_16<2, 0b110100, 0x47, "fsubq">;    // fsubq f, f, f
 350
 351 //
 352 // ...
 353 //
 354
 355 // Section A.45: RETURN - p240
 356 set isReturn = 1 in {
 357   def RETURNr : F3_3<2, 0b111001, "return">;      // return
 358   def RETURNi : F3_4<2, 0b111001, "return">;      // return
 359 }