lib/Target/SparcV9/SparcV9.td

   1 //===- Sparc.td - Target Description for Sparc V9 Target --------*- C++ -*-===//
   2 // vim:ft=cpp
   3 //===----------------------------------------------------------------------===//
   4
   5 #include "../Target.td"
   6
   7 #include "SparcV9_Reg.td"
   8
   9 //===----------------------------------------------------------------------===//
  10 // Instructions
  11 //===----------------------------------------------------------------------===//
  12
  13 class InstV9 : Instruction {          // Sparc instruction baseline
  14   field bits<32> Inst;
  15
  16   set Namespace = "V9";
  17
  18   bits<2> op;
  19   set Inst{31-30} = op;               // Top two bits are the 'op' field
  20
  21   // Bit attributes specific to Sparc instructions
  22   bit isPasi       = 0; // Does this instruction affect an alternate addr space?
  23   bit isDeprecated = 0; // Is this instruction deprecated?
  24   bit isPrivileged = 0; // Is this a privileged instruction?
  25 }
  26
  27 #include "SparcV9_F2.td"
  28 #include "SparcV9_F3.td"
  29 #include "SparcV9_F4.td"
  30
  31 //===----------------------------------------------------------------------===//
  32 // Instruction list...
  33 //
  34
  35 // Section A.2: Add - p137
  36 def ADDr    : F3_1<2, 0b000000, "add">;             // add r, r, r
  37 def ADDi    : F3_2<2, 0b000000, "add">;             // add r, i, r
  38 def ADDccr  : F3_1<2, 0b010000, "addcc">;           // addcc r, r, r
  39 def ADDcci  : F3_2<2, 0b010000, "addcc">;           // addcc r, i, r
  40 def ADDCr   : F3_1<2, 0b001000, "addC">;            // addC r, r, r
  41 def ADDCi   : F3_2<2, 0b001000, "addC">;            // addC r, i, r
  42 def ADDCccr : F3_1<2, 0b011000, "addCcc">;          // addCcc r, r, r
  43 def ADDCcci : F3_2<2, 0b011000, "addCcc">;          // addCcc r, i, r
  44
  45 // Section A.3: Branch on Integer Register with Prediction - p162
  46 set op2 = 0b011 in {
  47   def BRZ     : F2_4<0b001, "brz">;                 // Branch on rs1 == 0
  48   def BRLEZ   : F2_4<0b010, "brlez">;               // Branch on rs1 <= 0
  49   def BRLZ    : F2_4<0b011, "brlz">;                // Branch on rs1 <  0
  50   def BRNZ    : F2_4<0b101, "brnz">;                // Branch on rs1 != 0
  51   def BRGZ    : F2_4<0b110, "brgz">;                // Branch on rs1 >  0
  52   def BRGEZ   : F2_4<0b111, "brgez">;               // Branch on rs1 >= 0
  53 }
  54
  55 // Section A.4: p164
  56 set isDeprecated = 1 in {
  57   set op2 = 0b110 in {
  58     def FBA     : F2_2<0b1000, "fba">;              // Branch always
  59     def FBN     : F2_2<0b0000, "fbn">;              // Branch never
  60     def FBU     : F2_2<0b0111, "fbu">;              // Branch on unordered
  61     def FBG     : F2_2<0b0110, "fbg">;              // Branch >
  62     def FBUG    : F2_2<0b0101, "fbug">;             // Branch on unordered or >
  63     def FBL     : F2_2<0b0100, "fbl">;              // Branch <
  64     def FBUL    : F2_2<0b0011, "fbul">;             // Branch on unordered or <
  65     def FBLG    : F2_2<0b0010, "fblg">;             // Branch < or >
  66     def FBNE    : F2_2<0b0001, "fbne">;             // Branch !=
  67     def FBE     : F2_2<0b1001, "fbe">;              // Branch ==
  68     def FBUE    : F2_2<0b1010, "fbue">;             // Branch on unordered or ==
  69     def FBGE    : F2_2<0b1011, "fbge">;             // Branch > or ==
  70     def FBUGE   : F2_2<0b1100, "fbuge">;            // Branch unord or > or ==
  71     def FBLE    : F2_2<0b1101, "fble">;             // Branch < or ==
  72     def FBULE   : F2_2<0b1110, "fbule">;            // Branch unord or < or ==
  73     def FBO     : F2_2<0b1111, "fbo">;              // Branch on ordered
  74   }
  75 }
  76
  77 // Section A.5: p167
  78 // Not used in the Sparc backend
  79 #if 0
  80 set op2 = 0b101 in {
  81   def FBPA     : F2_3<0b1000, "fbpa">;              // Branch always
  82   def FBPN     : F2_3<0b0000, "fbpn">;              // Branch never
  83   def FBPU     : F2_3<0b0111, "fbpu">;              // Branch on unordered
  84   def FBPG     : F2_3<0b0110, "fbpg">;              // Branch >
  85   def FBPUG    : F2_3<0b0101, "fbpug">;             // Branch on unordered or >
  86   def FBPL     : F2_3<0b0100, "fbpl">;              // Branch <
  87   def FBPUL    : F2_3<0b0011, "fbpul">;             // Branch on unordered or <
  88   def FBPLG    : F2_3<0b0010, "fbplg">;             // Branch < or >
  89   def FBPNE    : F2_3<0b0001, "fbpne">;             // Branch !=
  90   def FBPE     : F2_3<0b1001, "fbpe">;              // Branch ==
  91   def FBPUE    : F2_3<0b1010, "fbpue">;             // Branch on unordered or ==
  92   def FBPGE    : F2_3<0b1011, "fbpge">;             // Branch > or ==
  93   def FBPUGE   : F2_3<0b1100, "fbpuge">;            // Branch unord or > or ==
  94   def FBPLE    : F2_3<0b1101, "fbple">;             // Branch < or ==
  95   def FBPULE   : F2_3<0b1110, "fbpule">;            // Branch unord or < or ==
  96   def FBPO     : F2_3<0b1111, "fbpo">;              // Branch on ordered
  97 }
  98 #endif
  99
 100 // Section A.6: Branch on Integer condition codes (Bicc) - p146
 101 set isDeprecated = 1 in {
 102   set op2 = 0b010 in {
 103     def BA     : F2_2<0b1000, "ba">;              // Branch always
 104     def BN     : F2_2<0b0000, "bn">;              // Branch never
 105     def BNE    : F2_2<0b1001, "bne">;             // Branch !=
 106     def BE     : F2_2<0b0001, "be">;              // Branch ==
 107     def BG     : F2_2<0b1010, "bg">;              // Branch >
 108     def BLE    : F2_2<0b0010, "ble">;             // Branch <=
 109     def BGE    : F2_2<0b1011, "bge">;             // Branch >=
 110     def BL     : F2_2<0b0011, "bl">;              // Branch <
 111     def BGU    : F2_2<0b1100, "bgu">;             // Branch unsigned >
 112     def BLEU   : F2_2<0b0100, "bleu">;            // Branch unsigned <=
 113     def BCC    : F2_2<0b1101, "bcc">;             // Branch unsigned >=
 114     def BCS    : F2_2<0b0101, "bcs">;             // Branch unsigned <=
 115     def BPOS   : F2_2<0b1110, "bpos">;            // Branch on positive
 116     def BNEG   : F2_2<0b0110, "bneg">;            // Branch on negative
 117     def BVC    : F2_2<0b1111, "bvc">;             // Branch on overflow clear
 118     def BVS    : F2_2<0b0111, "bvs">;             // Branch on overflow set
 119   }
 120 }
 121
 122 // Section A.7: Branch on integer condition codes with prediction - p148
 123 // Not used in the Sparc backend
 124 #if 0
 125 set op2 = 0b001 in {
 126   def BPA     : F2_3<0b1000, "bpa">;              // Branch always
 127   def BPN     : F2_3<0b0000, "bpn">;              // Branch never
 128   def BPNE    : F2_3<0b1001, "bpne">;             // Branch !=
 129   def BPE     : F2_3<0b0001, "bpe">;              // Branch ==
 130   def BPG     : F2_3<0b1010, "bpg">;              // Branch >
 131   def BPLE    : F2_3<0b0010, "bple">;             // Branch <=
 132   def BPGE    : F2_3<0b1011, "bpge">;             // Branch >=
 133   def BPL     : F2_3<0b0011, "bpl">;              // Branch <
 134   def BPGU    : F2_3<0b1100, "bpgu">;             // Branch unsigned >
 135   def BPLEU   : F2_3<0b0100, "bpleu">;            // Branch unsigned <=
 136   def BPCC    : F2_3<0b1101, "bpcc">;             // Branch unsigned >=
 137   def BPCS    : F2_3<0b0101, "bpcs">;             // Branch unsigned <=
 138   def BPPOS   : F2_3<0b1110, "bppos">;            // Branch on positive
 139   def BPNEG   : F2_3<0b0110, "bpneg">;            // Branch on negative
 140   def BPVC    : F2_3<0b1111, "bpvc">;             // Branch on overflow clear
 141   def BPVS    : F2_3<0b0111, "bpvs">;             // Branch on overflow set
 142 }
 143 #endif
 144
 145 // Section A.8: CALL - p151, the only Format #1 instruction
 146 def CALL : InstV9 {
 147   bits<30> disp;
 148   set op = 1;
 149   set Inst{29-0} = disp;
 150   set Name = "call";
 151   set isCall = 1;
 152 }
 153
 154 // Section A.9: Compare and Swap - p176
 155 // CASA/CASXA: are for alternate address spaces!  Ignore them
 156
 157
 158 // Section A.10: Divide (64-bit / 32-bit) - p178
 159 // Not used in the Sparc backend
 160 #if 0
 161 set isDeprecated = 1 in {
 162   def UDIVr   : F3_1<2, 0b001110, "udiv">;        // udiv r, r, r
 163   def UDIVi   : F3_2<2, 0b001110, "udiv">;        // udiv r, r, i
 164   def SDIVr   : F3_1<2, 0b001111, "sdiv">;        // sdiv r, r, r
 165   def SDIVi   : F3_2<2, 0b001111, "sdiv">;        // sdiv r, r, i
 166   def UDIVCCr : F3_1<2, 0b011110, "udivcc">;      // udivcc r, r, r
 167   def UDIVCCi : F3_2<2, 0b011110, "udivcc">;      // udivcc r, r, i
 168   def SDIVCCr : F3_1<2, 0b011111, "sdivcc">;      // sdivcc r, r, r
 169   def SDIVCCi : F3_2<2, 0b011111, "sdivcc">;      // sdivcc r, r, i
 170 }
 171 #endif
 172
 173 // Section A.11: DONE and RETRY - p181
 174 // Not used in the Sparc backend
 175 #if 0
 176 set isPrivileged = 1 in {
 177   def DONE    : F3_18<0, "done">;                 // done
 178   def RETRY   : F3_18<1, "retry">;                // retry
 179 }
 180 #endif
 181
 182 // Section A.12: Floating-Point Add and Subtract - p182
 183 def FADDS : F3_16<2, 0b110100, 0x41, "fadds">;    // fadds f, f, f
 184 def FADDD : F3_16<2, 0b110100, 0x42, "faddd">;    // faddd f, f, f
 185 def FADDQ : F3_16<2, 0b110100, 0x43, "faddq">;    // faddq f, f, f
 186 def FSUBS : F3_16<2, 0b110100, 0x45, "fsubs">;    // fsubs f, f, f
 187 def FSUBD : F3_16<2, 0b110100, 0x46, "fsubd">;    // fsubd f, f, f
 188 def FSUBQ : F3_16<2, 0b110100, 0x47, "fsubq">;    // fsubq f, f, f
 189
 190 // Section A.13: Floating-point compare - p159
 191 def FCMPS  : F3_15<2, 0b110101, 0b010100001, "fcmps">;   // fcmps  %fcc, r1, r2
 192 def FCMPD  : F3_15<2, 0b110101, 0b010100010, "fcmpd">;   // fcmpd  %fcc, r1, r2
 193 def FCMPQ  : F3_15<2, 0b110101, 0b010100011, "fcmpq">;   // fcmpq  %fcc, r1, r2
 194 def FCMPES : F3_15<2, 0b110101, 0b010100101, "fcmpes">;  // fcmpes %fcc, r1, r2
 195 def FCMPED : F3_15<2, 0b110101, 0b010100110, "fcmped">;  // fcmped %fcc, r1, r2
 196 def FCMPEQ : F3_15<2, 0b110101, 0b010100111, "fcmpeq">;  // fcmpeq %fcc, r1, r2
 197
 198 // Section A.14: Convert floating-point to integer - p161
 199 def FSTOX : F3_14<2, 0b110100, 0b010000001, "fstox">;   // fstox rs2, rd
 200 def FDTOX : F3_14<2, 0b110100, 0b010000010, "fstox">;   // fstox rs2, rd
 201 def FQTOX : F3_14<2, 0b110100, 0b010000011, "fstox">;   // fstox rs2, rd
 202 def FSTOI : F3_14<2, 0b110100, 0b011010001, "fstoi">;   // fstoi rs2, rd
 203 def FDTOI : F3_14<2, 0b110100, 0b011010010, "fdtoi">;   // fdtoi rs2, rd
 204 def FQTOI : F3_14<2, 0b110100, 0b011010011, "fqtoi">;   // fqtoi rs2, rd
 205
 206 // Section A.15: Convert between floating-point formats - p162
 207 def FSTOD : F3_14<2, 0b110100, 0b011001001, "fstod">;   // fstod rs2, rd
 208 def FSTOQ : F3_14<2, 0b110100, 0b011001101, "fstoq">;   // fstoq rs2, rd
 209 def FDTOS : F3_14<2, 0b110100, 0b011000110, "fstos">;   // fstos rs2, rd
 210 def FDTOQ : F3_14<2, 0b110100, 0b011001110, "fdtoq">;   // fdtoq rs2, rd
 211 def FQTOS : F3_14<2, 0b110100, 0b011000111, "fqtos">;   // fqtos rs2, rd
 212 def FQTOD : F3_14<2, 0b110100, 0b011001011, "fqtod">;   // fqtod rs2, rd
 213
 214 // Section A.16: Convert integer to floating-point - p163
 215 def FXTOS : F3_14<2, 0b110100, 0b010000100, "fxtos">;   // fxtos rs2, rd
 216 def FXTOD : F3_14<2, 0b110100, 0b010001000, "fxtod">;   // fxtod rs2, rd
 217 def FXTOQ : F3_14<2, 0b110100, 0b010001100, "fxtoq">;   // fxtoq rs2, rd
 218 def FITOS : F3_14<2, 0b110100, 0b011000100, "fitos">;   // fitos rs2, rd
 219 def FITOD : F3_14<2, 0b110100, 0b011001000, "fitod">;   // fitod rs2, rd
 220 def FITOQ : F3_14<2, 0b110100, 0b011001100, "fitoq">;   // fitoq rs2, rd
 221
 222 // Section A.17: Floating-Point Move - p164
 223 def FMOVS : F3_14<2, 0b110100, 0b000000001, "fmovs">;   // fmovs r, r
 224 def FMOVD : F3_14<2, 0b110100, 0b000000010, "fmovs">;   // fmovd r, r
 225 //def FMOVQ : F3_14<2, 0b110100, 0b000000011, "fmovs">;   // fmovq r, r
 226 def FNEGS : F3_14<2, 0b110100, 0b000000101, "fnegs">;   // fnegs r, r
 227 def FNEGD : F3_14<2, 0b110100, 0b000000110, "fnegs">;   // fnegs r, r
 228 //def FNEGQ : F3_14<2, 0b110100, 0b000000111, "fnegs">;   // fnegs r, r
 229 def FABSS : F3_14<2, 0b110100, 0b000001001, "fabss">;   // fabss r, r
 230 def FABSD : F3_14<2, 0b110100, 0b000001010, "fabss">;   // fabss r, r
 231 //def FABSQ : F3_14<2, 0b110100, 0b000001011, "fabss">;   // fabss r, r
 232
 233 // Section A.18: Floating-Point Multiply and Divide - p165
 234 def FMULS  : F3_16<2, 0b110100, 0b001001001, "fmuls">;   // fmuls r, r, r
 235 def FMULD  : F3_16<2, 0b110100, 0b001001010, "fmuld">;   // fmuld r, r, r
 236 def FMULQ  : F3_16<2, 0b110100, 0b001001011, "fmulq">;   // fmulq r, r, r
 237 def FSMULD : F3_16<2, 0b110100, 0b001101001, "fsmuld">;  // fsmuls r, r, r
 238 def FDMULQ : F3_16<2, 0b110100, 0b001101110, "fdmulq">;  // fdmuls r, r, r
 239 def FDIVS  : F3_16<2, 0b110100, 0b001001101, "fdivs">;   // fdivs r, r, r
 240 def FDIVD  : F3_16<2, 0b110100, 0b001001110, "fdivs">;   // fdivd r, r, r
 241 def FDIVQ  : F3_16<2, 0b110100, 0b001001111, "fdivs">;   // fdivq r, r, r
 242
 243 // Section A.19: Floating-Point Square Root - p166
 244 def FSQRTS : F3_14<2, 0b110100, 0b000101001, "fsqrts">;  // fsqrts r, r
 245 def FSQRTD : F3_14<2, 0b110100, 0b000101010, "fsqrts">;  // fsqrts r, r
 246 def FSQRTQ : F3_14<2, 0b110100, 0b000101011, "fsqrts">;  // fsqrts r, r
 247
 248 // FIXME: A.20: Flush Instruction Memory - p167
 249 // FIXME: A.21: Flush Register Windows - p169
 250
 251 // A.22: Illegal instruction Trap - p170
 252 // Not currently used
 253
 254 // A.23: Implementation-Dependent Instructions - p171
 255 // Not currently used
 256
 257 // Section A.24: Jump and Link - p172
 258 // Mimicking the Sparc's instr def...
 259 def JMPLCALLr : F3_1<2, 0b111000, "jmpl">;              // jmpl [r+r], r
 260 def JMPLCALLi : F3_2<2, 0b111000, "jmpl">;              // jmpl [r+i], r
 261 def JMPLRETr  : F3_1<2, 0b111000, "jmpl">;              // jmpl [r+r], r
 262 def JMPLRETi  : F3_2<2, 0b111000, "jmpl">;              // jmpl [r+i], r
 263
 264 // Section A.25: Load Floating-Point - p173
 265 def LDFr  : F3_1<3, 0b100000, "ld">;             // ld [r+r], r
 266 def LDFi  : F3_2<3, 0b100000, "ld">;             // ld [r+i], r
 267 def LDDFr : F3_1<3, 0b100011, "ldd">;            // ldd [r+r], r
 268 def LDDFi : F3_2<3, 0b100011, "ldd">;            // ldd [r+i], r
 269 def LDQFr : F3_1<3, 0b100010, "ldq">;            // ldq [r+r], r
 270 def LDQFi : F3_2<3, 0b100010, "ldq">;            // ldq [r+i], r
 271 set isDeprecated = 1 in {
 272   set rd = 0 in {
 273     def LDFSRr : F3_1<3, 0b100001, "ld">;        // ld [r+r], r
 274     def LDFSRi : F3_2<3, 0b100001, "ld">;        // ld [r+i], r
 275   }
 276 }
 277 set rd = 1 in {
 278   def LDXFSRr : F3_1<3, 0b100001, "ldx">;         // ldx [r+r], r
 279   def LDXFSRi : F3_2<3, 0b100001, "ldx">;         // ldx [r+i], r
 280 }
 281
 282 // Section A.27: Load Integer - p178
 283 def LDSBr : F3_1<3, 0b001001, "ldsb">;           // ldsb [r+r], r
 284 def LDSBi : F3_2<3, 0b001001, "ldsb">;           // ldsb [r+i], r
 285 def LDSHr : F3_1<3, 0b001010, "ldsh">;           // ldsh [r+r], r
 286 def LDSHi : F3_2<3, 0b001010, "ldsh">;           // ldsh [r+i], r
 287 def LDSWr : F3_1<3, 0b001000, "ldsw">;           // ldsh [r+r], r
 288 def LDSWi : F3_2<3, 0b001000, "ldsw">;           // ldsh [r+i], r
 289 def LDUBr : F3_1<3, 0b000001, "ldub">;           // ldub [r+r], r
 290 def LDUBi : F3_2<3, 0b000001, "ldub">;           // ldub [r+i], r
 291 def LDUHr : F3_1<3, 0b000010, "lduh">;           // lduh [r+r], r
 292 def LDUHi : F3_2<3, 0b000010, "lduh">;           // lduh [r+i], r
 293 // synonym: LD
 294 def LDUWr : F3_1<3, 0b000000, "lduw">;           // lduw [r+r], r
 295 def LDUWi : F3_2<3, 0b000000, "lduw">;           // lduw [r+i], r
 296 // LDD should no longer be used, LDX should be used instead
 297 def LDXr : F3_1<3, 0b001011, "ldx">;              // ldx [r+r], r
 298 def LDXi : F3_2<3, 0b001011, "ldx">;              // ldx [r+i], r
 299 #if 0
 300 set isDeprecated = 1 in {
 301   def LDDr : F3_1<3, 0b000011, "ldd">;            // ldd [r+r], r
 302   def LDDi : F3_2<3, 0b000011, "ldd">;            // ldd [r+i], r
 303 }
 304 #endif
 305
 306 // Section A.31: Logical operations
 307 def ANDr    : F3_1<2, 0b000001, "and">;          // and r, r, r
 308 def ANDi    : F3_2<2, 0b000001, "and">;          // and r, r, i
 309 def ANDccr  : F3_1<2, 0b010001, "andcc">;        // andcc r, r, r
 310 def ANDcci  : F3_2<2, 0b010001, "andcc">;        // andcc r, r, i
 311 def ANDNr   : F3_1<2, 0b000101, "andn">;         // andn r, r, r
 312 def ANDNi   : F3_2<2, 0b000101, "andn">;         // andn r, r, i
 313 def ANDNccr : F3_1<2, 0b010101, "andncc">;       // andncc r, r, r
 314 def ANDNcci : F3_2<2, 0b010101, "andncc">;       // andncc r, r, i
 315
 316 def ORr    : F3_1<2, 0b000010, "or">;            // or r, r, r
 317 def ORi    : F3_2<2, 0b000010, "or">;            // or r, r, i
 318 def ORccr  : F3_1<2, 0b010010, "orcc">;          // orcc r, r, r
 319 def ORcci  : F3_2<2, 0b010010, "orcc">;          // orcc r, r, i
 320 def ORNr   : F3_1<2, 0b000110, "orn">;           // orn r, r, r
 321 def ORNi   : F3_2<2, 0b000110, "orn">;           // orn r, r, i
 322 def ORNccr : F3_1<2, 0b010110, "orncc">;         // orncc r, r, r
 323 def ORNcci : F3_2<2, 0b010110, "orncc">;         // orncc r, r, i
 324
 325 def XORr    : F3_1<2, 0b000011, "xor">;          // xor r, r, r
 326 def XORi    : F3_2<2, 0b000011, "xor">;          // xor r, r, i
 327 def XORccr  : F3_1<2, 0b010011, "xorcc">;        // xorcc r, r, r
 328 def XORcci  : F3_2<2, 0b010011, "xorcc">;        // xorcc r, r, i
 329 def XNORr   : F3_1<2, 0b000111, "xnor">;         // xnor r, r, r
 330 def XNORi   : F3_2<2, 0b000111, "xnor">;         // xnor r, r, i
 331 def XNORccr : F3_1<2, 0b010111, "xnorcc">;       // xnorcc r, r, r
 332 def XNORcci : F3_2<2, 0b010111, "xnorcc">;       // xnorcc r, r, i
 333
 334 // Section A.32: Memory Barrier - p186
 335 // Not currently used in the Sparc backend
 336
 337 // Section A.33: Move Floating-Point Register on Condition (FMOVcc)
 338 #if 0
 339 // For integer condition codes
 340 def FMOVA   : F4_7<2, 0b110101, 0b1000, "fmova">;        // fmova r, r
 341 def FMOVN   : F4_7<2, 0b110101, 0b0000, "fmovn">;        // fmovn r, r
 342 def FMOVNE  : F4_7<2, 0b110101, 0b1001, "fmovne">;       // fmovne r, r
 343 def FMOVE   : F4_7<2, 0b110101, 0b0000, "fmove">;        // fmove r, r
 344 def FMOVG   : F4_7<2, 0b110101, 0b1010, "fmovg">;        // fmovg r, r
 345 def FMOVLE  : F4_7<2, 0b110101, 0b0000, "fmovle">;       // fmovle r, r
 346 def FMOVGE  : F4_7<2, 0b110101, 0b1011, "fmovge">;       // fmovge r, r
 347 def FMOVL   : F4_7<2, 0b110101, 0b0011, "fmovl">;        // fmovl r, r
 348 def FMOVGU  : F4_7<2, 0b110101, 0b1100, "fmovgu">;       // fmovgu r, r
 349 def FMOVLEU : F4_7<2, 0b110101, 0b0100, "fmovleu">;      // fmovleu r, r
 350 def FMOVCC  : F4_7<2, 0b110101, 0b1101, "fmovcc">;       // fmovcc r, r
 351 def FMOVCS  : F4_7<2, 0b110101, 0b0101, "fmovcs">;       // fmovcs r, r
 352 def FMOVPOS : F4_7<2, 0b110101, 0b1110, "fmovpos">;      // fmovpos r, r
 353 def FMOVNEG : F4_7<2, 0b110101, 0b0110, "fmovneg">;      // fmovneg r, r
 354 def FMOVVC  : F4_7<2, 0b110101, 0b1111, "fmovvc">;       // fmovvc r, r
 355 def FMOVVS  : F4_7<2, 0b110101, 0b0111, "fmovvs">;       // fmovvs r, r
 356
 357 // For floating-point condition codes
 358 def FMOVFA   : F4_7<2, 0b110101, 0b0100, "fmovfa">;      // fmovfa r, r
 359 def FMOVFN   : F4_7<2, 0b110101, 0b0000, "fmovfn">;      // fmovfa r, r
 360 def FMOVFU   : F4_7<2, 0b110101, 0b0111, "fmovfu">;      // fmovfu r, r
 361 def FMOVFG   : F4_7<2, 0b110101, 0b0110, "fmovfg">;      // fmovfg r, r
 362 def FMOVFUG  : F4_7<2, 0b110101, 0b0101, "fmovfug">;     // fmovfug r, r
 363 def FMOVFL   : F4_7<2, 0b110101, 0b0100, "fmovfl">;      // fmovfl r, r
 364 def FMOVFUL  : F4_7<2, 0b110101, 0b0011, "fmovful">;     // fmovful r, r
 365 def FMOVFLG  : F4_7<2, 0b110101, 0b0010, "fmovflg">;     // fmovflg r, r
 366 def FMOVFNE  : F4_7<2, 0b110101, 0b0001, "fmovfne">;     // fmovfne r, r
 367 def FMOVFE   : F4_7<2, 0b110101, 0b1001, "fmovfe">;      // fmovfe r, r
 368 def FMOVFUE  : F4_7<2, 0b110101, 0b1010, "fmovfue">;     // fmovfue r, r
 369 def FMOVGE   : F4_7<2, 0b110101, 0b1011, "fmovge">;      // fmovge r, r
 370 def FMOVFUGE : F4_7<2, 0b110101, 0b1100, "fmovfuge">;    // fmovfuge r, r
 371 def FMOVFLE  : F4_7<2, 0b110101, 0b1101, "fmovfle">;     // fmovfle r, r
 372 def FMOVFULE : F4_7<2, 0b110101, 0b1110, "fmovfule">;    // fmovfule r, r
 373 def FMOVFO   : F4_7<2, 0b110101, 0b1111, "fmovfo">;      // fmovfo r, r
 374 #endif
 375
 376 // Section A.34: Move FP Register on Integer Register condition (FMOVr) - p192
 377 def FMOVRSZ   : F4_6<2, 0b110101, 0b001, 0b00101, "fmovrsz">;  //fmovsrz r,r,rd
 378 def FMOVRSLEZ : F4_6<2, 0b110101, 0b010, 0b00101, "fmovrslez">;//fmovsrz r,r,rd
 379 def FMOVRSLZ  : F4_6<2, 0b110101, 0b011, 0b00101, "fmovrslz">; //fmovsrz r,r,rd
 380 def FMOVRSNZ  : F4_6<2, 0b110101, 0b101, 0b00101, "fmovrsne">; //fmovsrz r,r,rd
 381 def FMOVRSGZ  : F4_6<2, 0b110101, 0b110, 0b00101, "fmovrsgz">; //fmovsrz r,r,rd
 382 def FMOVRSGEZ : F4_6<2, 0b110101, 0b111, 0b00101, "fmovrsgez">;//fmovsrz r,r,rd
 383
 384 def FMOVRDZ   : F4_6<2, 0b110101, 0b001, 0b00110, "fmovrdz">;  //fmovsrz r,r,rd
 385 def FMOVRDLEZ : F4_6<2, 0b110101, 0b010, 0b00110, "fmovrdlez">;//fmovsrz r,r,rd
 386 def FMOVRDLZ  : F4_6<2, 0b110101, 0b011, 0b00110, "fmovrdlz">; //fmovsrz r,r,rd
 387 def FMOVRDNZ  : F4_6<2, 0b110101, 0b101, 0b00110, "fmovrdne">; //fmovsrz r,r,rd
 388 def FMOVRDGZ  : F4_6<2, 0b110101, 0b110, 0b00110, "fmovrdgz">; //fmovsrz r,r,rd
 389 def FMOVRDGEZ : F4_6<2, 0b110101, 0b111, 0b00110, "fmovrdgez">;//fmovsrz r,r,rd
 390
 391 def FMOVRQZ   : F4_6<2, 0b110101, 0b001, 0b00111, "fmovrqz">;  //fmovsrz r,r,rd
 392 def FMOVRQLEZ : F4_6<2, 0b110101, 0b010, 0b00111, "fmovrqlez">;//fmovsrz r,r,rd
 393 def FMOVRQLZ  : F4_6<2, 0b110101, 0b011, 0b00111, "fmovrqlz">; //fmovsrz r,r,rd
 394 def FMOVRQNZ  : F4_6<2, 0b110101, 0b101, 0b00111, "fmovrqne">; //fmovsrz r,r,rd
 395 def FMOVRQGZ  : F4_6<2, 0b110101, 0b110, 0b00111, "fmovrqgz">; //fmovsrz r,r,rd
 396 def FMOVRQGEZ : F4_6<2, 0b110101, 0b111, 0b00111, "fmovrqgez">;//fmovsrz r,r,rd
 397
 398
 399 // Section A.35: Move Integer Register on Condition (MOVcc) - p194
 400 // For integer condition codes
 401 def MOVAr    : F4_3<2, 0b101100, 0b1000, "mova">;      // mova i/xcc, rs2, rd
 402 def MOVAi    : F4_4<2, 0b101100, 0b1000, "mova">;      // mova i/xcc, rs2, rd
 403 def MOVNr    : F4_3<2, 0b101100, 0b0000, "movn">;      // mova i/xcc, rs2, rd
 404 def MOVNi    : F4_4<2, 0b101100, 0b0000, "movn">;      // mova i/xcc, rs2, rd
 405 def MOVNEr   : F4_3<2, 0b101100, 0b1001, "movne">;     // mova i/xcc, rs2, rd
 406 def MOVNEi   : F4_4<2, 0b101100, 0b1001, "movne">;     // mova i/xcc, rs2, rd
 407 def MOVEr    : F4_3<2, 0b101100, 0b0001, "move">;      // mova i/xcc, rs2, rd
 408 def MOVEi    : F4_4<2, 0b101100, 0b0001, "move">;      // mova i/xcc, rs2, rd
 409 def MOVGr    : F4_3<2, 0b101100, 0b1010, "movg">;      // mova i/xcc, rs2, rd
 410 def MOVGi    : F4_4<2, 0b101100, 0b1010, "movg">;      // mova i/xcc, rs2, rd
 411 def MOVLEr   : F4_3<2, 0b101100, 0b0010, "movle">;     // mova i/xcc, rs2, rd
 412 def MOVLEi   : F4_4<2, 0b101100, 0b0010, "movle">;     // mova i/xcc, rs2, rd
 413 def MOVGEr   : F4_3<2, 0b101100, 0b1011, "movge">;     // mova i/xcc, rs2, rd
 414 def MOVGEi   : F4_4<2, 0b101100, 0b1011, "movge">;     // mova i/xcc, rs2, rd
 415 def MOVLr    : F4_3<2, 0b101100, 0b0011, "movl">;      // mova i/xcc, rs2, rd
 416 def MOVLi    : F4_4<2, 0b101100, 0b0011, "movl">;      // mova i/xcc, rs2, rd
 417 def MOVGUr   : F4_3<2, 0b101100, 0b1100, "movgu">;     // mova i/xcc, rs2, rd
 418 def MOVGUi   : F4_4<2, 0b101100, 0b1100, "movgu">;     // mova i/xcc, rs2, rd
 419 def MOVLEUr  : F4_3<2, 0b101100, 0b0100, "movleu">;    // mova i/xcc, rs2, rd
 420 def MOVLEUi  : F4_4<2, 0b101100, 0b0100, "movleu">;    // mova i/xcc, rs2, rd
 421 def MOVCCr   : F4_3<2, 0b101100, 0b1101, "movcc">;     // mova i/xcc, rs2, rd
 422 def MOVCCi   : F4_4<2, 0b101100, 0b1101, "movcc">;     // mova i/xcc, rs2, rd
 423 def MOVCSr   : F4_3<2, 0b101100, 0b0101, "movcs">;     // mova i/xcc, rs2, rd
 424 def MOVCSi   : F4_4<2, 0b101100, 0b0101, "movcs">;     // mova i/xcc, rs2, rd
 425 def MOVPOSr  : F4_3<2, 0b101100, 0b1110, "movpos">;    // mova i/xcc, rs2, rd
 426 def MOVPOSi  : F4_4<2, 0b101100, 0b1110, "movpos">;    // mova i/xcc, rs2, rd
 427 def MOVNEGr  : F4_3<2, 0b101100, 0b0110, "movneg">;    // mova i/xcc, rs2, rd
 428 def MOVNEGi  : F4_4<2, 0b101100, 0b0110, "movneg">;    // mova i/xcc, rs2, rd
 429 def MOVVCr   : F4_3<2, 0b101100, 0b1111, "movvc">;     // mova i/xcc, rs2, rd
 430 def MOVVCi   : F4_4<2, 0b101100, 0b1111, "movvc">;     // mova i/xcc, rs2, rd
 431 def MOVVSr   : F4_3<2, 0b101100, 0b0111, "movvs">;     // mova i/xcc, rs2, rd
 432 def MOVVSi   : F4_4<2, 0b101100, 0b0111, "movvs">;     // mova i/xcc, rs2, rd
 433
 434 // For floating-point condition codes
 435 def MOVFAr   : F4_3<2, 0b101100, 0b1000, "movfa">;     // mova i/xcc, rs2, rd
 436 def MOVFAi   : F4_4<2, 0b101100, 0b1000, "movfa">;     // mova i/xcc, rs2, rd
 437 def MOVFNr   : F4_3<2, 0b101100, 0b0000, "movfn">;     // mova i/xcc, rs2, rd
 438 def MOVFNi   : F4_4<2, 0b101100, 0b0000, "movfn">;     // mova i/xcc, rs2, rd
 439 def MOVFUr   : F4_3<2, 0b101100, 0b0111, "movfu">;     // mova i/xcc, rs2, rd
 440 def MOVFUi   : F4_4<2, 0b101100, 0b0111, "movfu">;     // mova i/xcc, rs2, rd
 441 def MOVFGr   : F4_3<2, 0b101100, 0b0110, "movfg">;     // mova i/xcc, rs2, rd
 442 def MOVFGi   : F4_4<2, 0b101100, 0b0110, "movfg">;     // mova i/xcc, rs2, rd
 443 def MOVFUGr  : F4_3<2, 0b101100, 0b0101, "movfug">;    // mova i/xcc, rs2, rd
 444 def MOVFUGi  : F4_4<2, 0b101100, 0b0101, "movfug">;    // mova i/xcc, rs2, rd
 445 def MOVFLr   : F4_3<2, 0b101100, 0b0100, "movfl">;     // mova i/xcc, rs2, rd
 446 def MOVFLi   : F4_4<2, 0b101100, 0b0100, "movfl">;     // mova i/xcc, rs2, rd
 447 def MOVFULr  : F4_3<2, 0b101100, 0b0011, "movful">;    // mova i/xcc, rs2, rd
 448 def MOVFULi  : F4_4<2, 0b101100, 0b0011, "movful">;    // mova i/xcc, rs2, rd
 449 def MOVFLGr  : F4_3<2, 0b101100, 0b0010, "movflg">;    // mova i/xcc, rs2, rd
 450 def MOVFLGi  : F4_4<2, 0b101100, 0b0010, "movflg">;    // mova i/xcc, rs2, rd
 451 def MOVFNEr  : F4_3<2, 0b101100, 0b0001, "movfne">;    // mova i/xcc, rs2, rd
 452 def MOVFNEi  : F4_4<2, 0b101100, 0b0001, "movfne">;    // mova i/xcc, rs2, rd
 453 def MOVFEr   : F4_3<2, 0b101100, 0b1001, "movfe">;     // mova i/xcc, rs2, rd
 454 def MOVFEi   : F4_4<2, 0b101100, 0b1001, "movfe">;     // mova i/xcc, rs2, rd
 455 def MOVFUEr  : F4_3<2, 0b101100, 0b1010, "movfue">;    // mova i/xcc, rs2, rd
 456 def MOVFUEi  : F4_4<2, 0b101100, 0b1010, "movfue">;    // mova i/xcc, rs2, rd
 457 def MOVFGEr  : F4_3<2, 0b101100, 0b1011, "movfge">;    // mova i/xcc, rs2, rd
 458 def MOVFGEi  : F4_4<2, 0b101100, 0b1011, "movfge">;    // mova i/xcc, rs2, rd
 459 def MOVFUGEr : F4_3<2, 0b101100, 0b1100, "movfuge">;   // mova i/xcc, rs2, rd
 460 def MOVFUGEi : F4_4<2, 0b101100, 0b1100, "movfuge">;   // mova i/xcc, rs2, rd
 461 def MOVFLEr  : F4_3<2, 0b101100, 0b1101, "movfle">;    // mova i/xcc, rs2, rd
 462 def MOVFLEi  : F4_4<2, 0b101100, 0b1101, "movfle">;    // mova i/xcc, rs2, rd
 463 def MOVFULEr : F4_3<2, 0b101100, 0b1110, "movfule">;   // mova i/xcc, rs2, rd
 464 def MOVFULEi : F4_4<2, 0b101100, 0b1110, "movfule">;   // mova i/xcc, rs2, rd
 465 def MOVFOr   : F4_3<2, 0b101100, 0b1111, "movfo">;     // mova i/xcc, rs2, rd
 466 def MOVFOi   : F4_4<2, 0b101100, 0b1111, "movfo">;     // mova i/xcc, rs2, rd
 467
 468 // Section A.36: Move Integer Register on Register Condition (MOVR)
 469 def MOVRZr   : F3_5<2, 0b101111, 0b001, "movrz">;      // movrz rs1, rs2, rd
 470 def MOVRZi   : F3_6<2, 0b101111, 0b001, "movrz">;      // movrz rs1, imm, rd
 471 def MOVRLEZr : F3_5<2, 0b101111, 0b010, "movrlez">;    // movrz rs1, rs2, rd
 472 def MOVRLEZi : F3_6<2, 0b101111, 0b010, "movrlez">;    // movrz rs1, imm, rd
 473 def MOVRLZr  : F3_5<2, 0b101111, 0b011, "movrlz">;     // movrz rs1, rs2, rd
 474 def MOVRLZi  : F3_6<2, 0b101111, 0b011, "movrlz">;     // movrz rs1, imm, rd
 475 def MOVRNZr  : F3_5<2, 0b101111, 0b101, "movrnz">;     // movrz rs1, rs2, rd
 476 def MOVRNZi  : F3_6<2, 0b101111, 0b101, "movrnz">;     // movrz rs1, imm, rd
 477 def MOVRGZr  : F3_5<2, 0b101111, 0b110, "movrgz">;     // movrz rs1, rs2, rd
 478 def MOVRGZi  : F3_6<2, 0b101111, 0b110, "movrgz">;     // movrz rs1, imm, rd
 479 def MOVRGEZr : F3_5<2, 0b101111, 0b111, "movrgez">;    // movrz rs1, rs2, rd
 480 def MOVRGEZi : F3_6<2, 0b101111, 0b111, "movrgez">;    // movrz rs1, imm, rd
 481
 482 // Section A.37: Multiply and Divide (64-bit) - p199
 483 def MULXr  : F3_1<2, 0b001001, "mulx">;        // mulx  r, r, r
 484 def SDIVXr : F3_1<2, 0b101101, "sdivx">;       // mulx  r, r, r
 485 def UDIVXr : F3_1<2, 0b001101, "udivx">;       // mulx  r, r, r
 486 def MULXi  : F3_2<2, 0b001001, "mulx">;        // mulx  r, i, r
 487 def SDIVXi : F3_2<2, 0b101101, "sdivx">;       // mulx  r, i, r
 488 def UDIVXi : F3_2<2, 0b001101, "udivx">;       // mulx  r, i, r
 489
 490 // Section A.38: Multiply (32-bit) - p200
 491 // Not used in the Sparc backend
 492 #if 0
 493 set Inst{13} = 0 in {
 494   def UMULr   : F3_1<2, 0b001010, "umul">;        // umul   r, r, r
 495   def SMULr   : F3_1<2, 0b001011, "smul">;        // smul   r, r, r
 496   def UMULCCr : F3_1<2, 0b011010, "umulcc">;      // mulcc  r, r, r
 497   def SMULCCr : F3_1<2, 0b011011, "smulcc">;      // smulcc r, r, r
 498 }
 499 set Inst{13} = 1 in {
 500   def UMULi   : F3_1<2, 0b001010, "umul">;        // umul   r, i, r
 501   def SMULi   : F3_1<2, 0b001011, "smul">;        // smul   r, i, r
 502   def UMULCCi : F3_1<2, 0b011010, "umulcc">;      // umulcc r, i, r
 503   def SMULCCi : F3_1<2, 0b011011, "smulcc">;      // smulcc r, i, r
 504 }
 505 #endif
 506
 507 // Section A.39: Multiply Step - p202
 508 // Not currently used in the Sparc backend
 509
 510 // Section A.40: No operation - p204
 511 // NOP is really a pseudo-instruction (special case of SETHI)
 512 set op2 = 0b100 in {
 513   set rd = 0 in {
 514     set imm = 0 in {
 515       def NOP : F2_1<"nop">;                     // nop
 516     }
 517   }
 518 }
 519
 520 // Section A.41: Population Count - p205
 521 // Not currently used in the Sparc backend
 522
 523 // Section A.42: Prefetch Data - p206
 524 // Not currently used in the Sparc backend
 525
 526 // Section A.43: Read Privileged Register - p211
 527 // Not currently used in the Sparc backend
 528
 529 // Section A.44: Read State Register
 530 // The only instr from this section currently used is RDCCR
 531 set rs1 = 2 in {
 532   def RDCCR : F3_17<2, 0b101000, "rd">;             // rd %ccr, r
 533 }
 534
 535 // Section A.45: RETURN - p216
 536 set isReturn = 1 in {
 537   def RETURNr : F3_3<2, 0b111001, "return">;      // return
 538   def RETURNi : F3_4<2, 0b111001, "return">;      // return
 539 }
 540
 541 // Section A.46: SAVE and RESTORE - p217
 542 def SAVEr    : F3_1<2, 0b111100, "save">;       // save    r, r, r
 543 def SAVEi    : F3_2<2, 0b111100, "save">;       // save    r, i, r
 544 def RESTOREr : F3_1<2, 0b111101, "restore">;    // restore r, r, r
 545 def RESTOREi : F3_2<2, 0b111101, "restore">;    // restore r, i, r
 546
 547 // Section A.47: SAVED and RESTORED - p219
 548 // Not currently used in Sparc backend
 549
 550 // Section A.48: SETHI - p220
 551 set op2 = 0b100 in {
 552   def SETHI : F2_1<"sethi">;                      // sethi
 553 }
 554
 555 // Section A.49: Shift - p221
 556 // Not currently used in the Sparc backend
 557 #if 0
 558  uses 5 least significant bits of rs2
 559 set x = 0 in {
 560   def SLLr5  : F3_11<2, 0b100101, "sll">;                // sll r, r, r
 561   def SRLr5  : F3_11<2, 0b100110, "srl">;                // srl r, r, r
 562   def SRAr5  : F3_11<2, 0b100111, "sra">;                // sra r, r, r
 563   def SLLXr5 : F3_11<2, 0b100101, "sllx">;               // sllx r, r, r
 564   def SRLXr5 : F3_11<2, 0b100110, "srlx">;               // srlx r, r, r
 565   def SRAXr5 : F3_11<2, 0b100111, "srax">;               // srax r, r, r
 566 }
 567 #endif
 568
 569 // uses 6 least significant bits of rs2
 570 set x = 1 in {
 571   def SLLr6  : F3_11<2, 0b100101, "sll">;                // sll r, r, r
 572   def SRLr6  : F3_11<2, 0b100110, "srl">;                // srl r, r, r
 573   def SRAr6  : F3_11<2, 0b100111, "sra">;                // sra r, r, r
 574   def SLLXr6 : F3_11<2, 0b100101, "sllx">;               // sllx r, r, r
 575   def SRLXr6 : F3_11<2, 0b100110, "srlx">;               // srlx r, r, r
 576   def SRAXr6 : F3_11<2, 0b100111, "srax">;               // srax r, r, r
 577 }
 578
 579 // Not currently used in the Sparc backend
 580 #if 0
 581 def SLLi5  : F3_12<2, 0b100101, "sll">;                // sll r, shcnt32, r
 582 def SRLi5  : F3_12<2, 0b100110, "srl">;                // srl r, shcnt32, r
 583 def SRAi5  : F3_12<2, 0b100111, "sra">;                // sra r, shcnt32, r
 584 def SLLXi5 : F3_12<2, 0b100101, "sllx">;               // sllx r, shcnt32, r
 585 def SRLXi5 : F3_12<2, 0b100110, "srlx">;               // srlx r, shcnt32, r
 586 def SRAXi5 : F3_12<2, 0b100111, "srax">;               // srax r, shcnt32, r
 587 #endif
 588
 589 def SLLi6  : F3_13<2, 0b100101, "sll">;                  // sll r, shcnt64, r
 590 def SRLi6  : F3_13<2, 0b100110, "srl">;                  // srl r, shcnt64, r
 591 def SRAi6  : F3_13<2, 0b100111, "sra">;                  // sra r, shcnt64, r
 592 def SLLXi6 : F3_13<2, 0b100101, "sllx">;                 // sllx r, shcnt64, r
 593 def SRLXi6 : F3_13<2, 0b100110, "srlx">;                 // srlx r, shcnt64, r
 594 def SRAXi6 : F3_13<2, 0b100111, "srax">;                 // srax r, shcnt64, r
 595
 596 // Section A.50: Sofware-Initiated Reset - p223
 597 // Not currently used in the Sparc backend
 598
 599 // Section A.51: Store Barrier - p224
 600 // Not currently used in the Sparc backend
 601
 602 // Section A.52: Store Floating-point -p225
 603 def STFr  : F3_1rd<3, 0b100100, "st">;                      // st r, [r+r]
 604 def STFi  : F3_2rd<3, 0b100100, "st">;                      // st r, [r+i]
 605 def STDFr : F3_1rd<3, 0b100111, "std">;                     // std r, [r+r]
 606 def STDFi : F3_2rd<3, 0b100111, "std">;                     // std r, [r+i]
 607
 608 // Not currently used in the Sparc backend
 609 #if 0
 610 def STQFr : F3_1rd<3, 0b100110, "stq">;                     // stq r, [r+r]
 611 def STQFi : F3_2rd<3, 0b100110, "stq">;                     // stq r, [r+i]
 612 #endif
 613
 614 set isDeprecated = 1 in {
 615   def STFSRr : F3_1<3, 0b100101, "st">;                   // st r, [r+r]
 616   def STFSRi : F3_2<3, 0b100101, "st">;                   // st r, [r+i]
 617 }
 618 def STXFSRr : F3_1<3, 0b100101, "stq">;                   // stx r, [r+r]
 619 def STXFSRi : F3_2<3, 0b100101, "stq">;                   // stx r, [r+i]
 620
 621 // Section A.53: Store Floating-Point into Alternate Space - p227
 622 // Not currently used in the Sparc backend
 623
 624 // Section A.54: Store Integer - p229
 625 def STBr : F3_1<3, 0b000101, "stb">;                     // stb r, [r+r]
 626 def STBi : F3_2<3, 0b000101, "stb">;                     // stb r, [r+i]
 627 def STHr : F3_1<3, 0b000110, "stb">;                     // stb r, [r+r]
 628 def STHi : F3_2<3, 0b000110, "stb">;                     // stb r, [r+i]
 629 def STWr : F3_1<3, 0b000100, "stb">;                     // stb r, [r+r]
 630 def STWi : F3_2<3, 0b000100, "stb">;                     // stb r, [r+i]
 631 def STXr : F3_1<3, 0b001110, "stb">;                     // stb r, [r+r]
 632 def STXi : F3_2<3, 0b001110, "stb">;                     // stb r, [r+i]
 633
 634 // Section A.55: Store Integer into Alternate Space - p231
 635 // Not currently used in the Sparc backend
 636
 637 // Section A.56: Subtract - p233
 638 def SUBr    : F3_1<2, 0b000100, "sub">;                   // sub r, r, r
 639 def SUBi    : F3_1<2, 0b000100, "sub">;                   // sub r, i, r
 640 def SUBccr  : F3_1<2, 0b010100, "subcc">;                 // subcc r, r, r
 641 def SUBcci  : F3_1<2, 0b010100, "subcc">;                 // subcc r, i, r
 642 def SUBCr   : F3_1<2, 0b001100, "subc">;                  // subc r, r, r
 643 def SUBCi   : F3_1<2, 0b001100, "subc">;                  // subc r, i, r
 644 def SUBCccr : F3_1<2, 0b011100, "subccc">;                // subccc r, r, r
 645 def SUBCcci : F3_1<2, 0b011100, "subccc">;                // subccc r, i, r
 646
 647 // FIXME: More...?