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: Branch on Floating-Point Condition Codes (FBfcc) p140
  56 // The following deprecated instructions don't seem to play nice on Sparc
  57 #if 0
  58 set isDeprecated = 1 in {
  59   set op2 = 0b110 in {
  60     def FBA     : F2_2<0b1000, "fba">;              // Branch always
  61     def FBN     : F2_2<0b0000, "fbn">;              // Branch never
  62     def FBU     : F2_2<0b0111, "fbu">;              // Branch on unordered
  63     def FBG     : F2_2<0b0110, "fbg">;              // Branch >
  64     def FBUG    : F2_2<0b0101, "fbug">;             // Branch on unordered or >
  65     def FBL     : F2_2<0b0100, "fbl">;              // Branch <
  66     def FBUL    : F2_2<0b0011, "fbul">;             // Branch on unordered or <
  67     def FBLG    : F2_2<0b0010, "fblg">;             // Branch < or >
  68     def FBNE    : F2_2<0b0001, "fbne">;             // Branch !=
  69     def FBE     : F2_2<0b1001, "fbe">;              // Branch ==
  70     def FBUE    : F2_2<0b1010, "fbue">;             // Branch on unordered or ==
  71     def FBGE    : F2_2<0b1011, "fbge">;             // Branch > or ==
  72     def FBUGE   : F2_2<0b1100, "fbuge">;            // Branch unord or > or ==
  73     def FBLE    : F2_2<0b1101, "fble">;             // Branch < or ==
  74     def FBULE   : F2_2<0b1110, "fbule">;            // Branch unord or < or ==
  75     def FBO     : F2_2<0b1111, "fbo">;              // Branch on ordered
  76   }
  77 }
  78 #endif
  79
  80 // These instructions are hacked to really represent A.5 instructions,
  81 // but with cc hardcoded to be %fcc0. Hence, they behave like FBPfcc instrs.
  82 set op2 = 0b101 in {
  83   set cc = 0b00 in {
  84     def FBA     : F2_3<0b1000, "fba">;              // Branch always
  85     def FBN     : F2_3<0b0000, "fbn">;              // Branch never
  86     def FBU     : F2_3<0b0111, "fbu">;              // Branch on unordered
  87     def FBG     : F2_3<0b0110, "fbg">;              // Branch >
  88     def FBUG    : F2_3<0b0101, "fbug">;             // Branch on unordered or >
  89     def FBL     : F2_3<0b0100, "fbl">;              // Branch <
  90     def FBUL    : F2_3<0b0011, "fbul">;             // Branch on unordered or <
  91     def FBLG    : F2_3<0b0010, "fblg">;             // Branch < or >
  92     def FBNE    : F2_3<0b0001, "fbne">;             // Branch !=
  93     def FBE     : F2_3<0b1001, "fbe">;              // Branch ==
  94     def FBUE    : F2_3<0b1010, "fbue">;             // Branch on unordered or ==
  95     def FBGE    : F2_3<0b1011, "fbge">;             // Branch > or ==
  96     def FBUGE   : F2_3<0b1100, "fbuge">;            // Branch unord or > or ==
  97     def FBLE    : F2_3<0b1101, "fble">;             // Branch < or ==
  98     def FBULE   : F2_3<0b1110, "fbule">;            // Branch unord or < or ==
  99     def FBO     : F2_3<0b1111, "fbo">;              // Branch on ordered
 100   }
 101 }
 102
 103 // Section A.5: Branch on FP condition codes with prediction - p143
 104 // Not used in the Sparc backend
 105 #if 0
 106 set op2 = 0b101 in {
 107   def FBPA     : F2_3<0b1000, "fba">;              // Branch always
 108   def FBPN     : F2_3<0b0000, "fbn">;              // Branch never
 109   def FBPU     : F2_3<0b0111, "fbu">;              // Branch on unordered
 110   def FBPG     : F2_3<0b0110, "fbg">;              // Branch >
 111   def FBPUG    : F2_3<0b0101, "fbug">;             // Branch on unordered or >
 112   def FBPL     : F2_3<0b0100, "fbl">;              // Branch <
 113   def FBPUL    : F2_3<0b0011, "fbul">;             // Branch on unordered or <
 114   def FBPLG    : F2_3<0b0010, "fblg">;             // Branch < or >
 115   def FBPNE    : F2_3<0b0001, "fbne">;             // Branch !=
 116   def FBPE     : F2_3<0b1001, "fbe">;              // Branch ==
 117   def FBPUE    : F2_3<0b1010, "fbue">;             // Branch on unordered or ==
 118   def FBPGE    : F2_3<0b1011, "fbge">;             // Branch > or ==
 119   def FBPUGE   : F2_3<0b1100, "fbuge">;            // Branch unord or > or ==
 120   def FBPLE    : F2_3<0b1101, "fble">;             // Branch < or ==
 121   def FBPULE   : F2_3<0b1110, "fbule">;            // Branch unord or < or ==
 122   def FBPO     : F2_3<0b1111, "fbo">;              // Branch on ordered
 123 }
 124 #endif
 125
 126 // Section A.6: Branch on Integer condition codes (Bicc) - p146
 127 set isDeprecated = 1 in {
 128   set op2 = 0b010 in {
 129     def BA     : F2_2<0b1000, "ba">;              // Branch always
 130     def BN     : F2_2<0b0000, "bn">;              // Branch never
 131     def BNE    : F2_2<0b1001, "bne">;             // Branch !=
 132     def BE     : F2_2<0b0001, "be">;              // Branch ==
 133     def BG     : F2_2<0b1010, "bg">;              // Branch >
 134     def BLE    : F2_2<0b0010, "ble">;             // Branch <=
 135     def BGE    : F2_2<0b1011, "bge">;             // Branch >=
 136     def BL     : F2_2<0b0011, "bl">;              // Branch <
 137     def BGU    : F2_2<0b1100, "bgu">;             // Branch unsigned >
 138     def BLEU   : F2_2<0b0100, "bleu">;            // Branch unsigned <=
 139     def BCC    : F2_2<0b1101, "bcc">;             // Branch unsigned >=
 140     def BCS    : F2_2<0b0101, "bcs">;             // Branch unsigned <=
 141     def BPOS   : F2_2<0b1110, "bpos">;            // Branch on positive
 142     def BNEG   : F2_2<0b0110, "bneg">;            // Branch on negative
 143     def BVC    : F2_2<0b1111, "bvc">;             // Branch on overflow clear
 144     def BVS    : F2_2<0b0111, "bvs">;             // Branch on overflow set
 145   }
 146 }
 147
 148 // Section A.7: Branch on integer condition codes with prediction - p148
 149 // Not used in the Sparc backend
 150 #if 0
 151 set op2 = 0b001 in {
 152   def BPA     : F2_3<0b1000, "bpa">;              // Branch always
 153   def BPN     : F2_3<0b0000, "bpn">;              // Branch never
 154   def BPNE    : F2_3<0b1001, "bpne">;             // Branch !=
 155   def BPE     : F2_3<0b0001, "bpe">;              // Branch ==
 156   def BPG     : F2_3<0b1010, "bpg">;              // Branch >
 157   def BPLE    : F2_3<0b0010, "bple">;             // Branch <=
 158   def BPGE    : F2_3<0b1011, "bpge">;             // Branch >=
 159   def BPL     : F2_3<0b0011, "bpl">;              // Branch <
 160   def BPGU    : F2_3<0b1100, "bpgu">;             // Branch unsigned >
 161   def BPLEU   : F2_3<0b0100, "bpleu">;            // Branch unsigned <=
 162   def BPCC    : F2_3<0b1101, "bpcc">;             // Branch unsigned >=
 163   def BPCS    : F2_3<0b0101, "bpcs">;             // Branch unsigned <=
 164   def BPPOS   : F2_3<0b1110, "bppos">;            // Branch on positive
 165   def BPNEG   : F2_3<0b0110, "bpneg">;            // Branch on negative
 166   def BPVC    : F2_3<0b1111, "bpvc">;             // Branch on overflow clear
 167   def BPVS    : F2_3<0b0111, "bpvs">;             // Branch on overflow set
 168 }
 169 #endif
 170
 171 // Section A.8: CALL - p151, the only Format #1 instruction
 172 def CALL : InstV9 {
 173   bits<30> disp;
 174   set op = 1;
 175   set Inst{29-0} = disp;
 176   set Name = "call";
 177   set isCall = 1;
 178 }
 179
 180 // Section A.9: Compare and Swap - p176
 181 // CASA/CASXA: are for alternate address spaces!  Ignore them
 182
 183
 184 // Section A.10: Divide (64-bit / 32-bit) - p178
 185 // Not used in the Sparc backend
 186 #if 0
 187 set isDeprecated = 1 in {
 188   def UDIVr   : F3_1<2, 0b001110, "udiv">;        // udiv r, r, r
 189   def UDIVi   : F3_2<2, 0b001110, "udiv">;        // udiv r, r, i
 190   def SDIVr   : F3_1<2, 0b001111, "sdiv">;        // sdiv r, r, r
 191   def SDIVi   : F3_2<2, 0b001111, "sdiv">;        // sdiv r, r, i
 192   def UDIVCCr : F3_1<2, 0b011110, "udivcc">;      // udivcc r, r, r
 193   def UDIVCCi : F3_2<2, 0b011110, "udivcc">;      // udivcc r, r, i
 194   def SDIVCCr : F3_1<2, 0b011111, "sdivcc">;      // sdivcc r, r, r
 195   def SDIVCCi : F3_2<2, 0b011111, "sdivcc">;      // sdivcc r, r, i
 196 }
 197 #endif
 198
 199 // Section A.11: DONE and RETRY - p181
 200 // Not used in the Sparc backend
 201 #if 0
 202 set isPrivileged = 1 in {
 203   def DONE    : F3_18<0, "done">;                 // done
 204   def RETRY   : F3_18<1, "retry">;                // retry
 205 }
 206 #endif
 207
 208 // Section A.12: Floating-Point Add and Subtract - p182
 209 def FADDS : F3_16<2, 0b110100, 0x41, "fadds">;    // fadds f, f, f
 210 def FADDD : F3_16<2, 0b110100, 0x42, "faddd">;    // faddd f, f, f
 211 def FADDQ : F3_16<2, 0b110100, 0x43, "faddq">;    // faddq f, f, f
 212 def FSUBS : F3_16<2, 0b110100, 0x45, "fsubs">;    // fsubs f, f, f
 213 def FSUBD : F3_16<2, 0b110100, 0x46, "fsubd">;    // fsubd f, f, f
 214 def FSUBQ : F3_16<2, 0b110100, 0x47, "fsubq">;    // fsubq f, f, f
 215
 216 // Section A.13: Floating-point compare - p159
 217 def FCMPS  : F3_15<2, 0b110101, 0b001010001, "fcmps">;   // fcmps  %fcc, r1, r2
 218 def FCMPD  : F3_15<2, 0b110101, 0b001010010, "fcmpd">;   // fcmpd  %fcc, r1, r2
 219 def FCMPQ  : F3_15<2, 0b110101, 0b001010011, "fcmpq">;   // fcmpq  %fcc, r1, r2
 220 // Currently unused in the Sparc backend
 221 #if 0
 222 def FCMPES : F3_15<2, 0b110101, 0b001010101, "fcmpes">;  // fcmpes %fcc, r1, r2
 223 def FCMPED : F3_15<2, 0b110101, 0b001010110, "fcmped">;  // fcmped %fcc, r1, r2
 224 def FCMPEQ : F3_15<2, 0b110101, 0b001010111, "fcmpeq">;  // fcmpeq %fcc, r1, r2
 225 #endif
 226
 227 // Section A.14: Convert floating-point to integer - p161
 228 def FSTOX : F3_14<2, 0b110100, 0b010000001, "fstox">;   // fstox rs2, rd
 229 def FDTOX : F3_14<2, 0b110100, 0b010000010, "fstox">;   // fstox rs2, rd
 230 def FQTOX : F3_14<2, 0b110100, 0b010000011, "fstox">;   // fstox rs2, rd
 231 def FSTOI : F3_14<2, 0b110100, 0b011010001, "fstoi">;   // fstoi rs2, rd
 232 def FDTOI : F3_14<2, 0b110100, 0b011010010, "fdtoi">;   // fdtoi rs2, rd
 233 def FQTOI : F3_14<2, 0b110100, 0b011010011, "fqtoi">;   // fqtoi rs2, rd
 234
 235 // Section A.15: Convert between floating-point formats - p162
 236 def FSTOD : F3_14<2, 0b110100, 0b011001001, "fstod">;   // fstod rs2, rd
 237 def FSTOQ : F3_14<2, 0b110100, 0b011001101, "fstoq">;   // fstoq rs2, rd
 238 def FDTOS : F3_14<2, 0b110100, 0b011000110, "fstos">;   // fstos rs2, rd
 239 def FDTOQ : F3_14<2, 0b110100, 0b011001110, "fdtoq">;   // fdtoq rs2, rd
 240 def FQTOS : F3_14<2, 0b110100, 0b011000111, "fqtos">;   // fqtos rs2, rd
 241 def FQTOD : F3_14<2, 0b110100, 0b011001011, "fqtod">;   // fqtod rs2, rd
 242
 243 // Section A.16: Convert integer to floating-point - p163
 244 def FXTOS : F3_14<2, 0b110100, 0b010000100, "fxtos">;   // fxtos rs2, rd
 245 def FXTOD : F3_14<2, 0b110100, 0b010001000, "fxtod">;   // fxtod rs2, rd
 246 def FXTOQ : F3_14<2, 0b110100, 0b010001100, "fxtoq">;   // fxtoq rs2, rd
 247 def FITOS : F3_14<2, 0b110100, 0b011000100, "fitos">;   // fitos rs2, rd
 248 def FITOD : F3_14<2, 0b110100, 0b011001000, "fitod">;   // fitod rs2, rd
 249 def FITOQ : F3_14<2, 0b110100, 0b011001100, "fitoq">;   // fitoq rs2, rd
 250
 251 // Section A.17: Floating-Point Move - p164
 252 def FMOVS : F3_14<2, 0b110100, 0b000000001, "fmovs">;   // fmovs r, r
 253 def FMOVD : F3_14<2, 0b110100, 0b000000010, "fmovs">;   // fmovd r, r
 254 //def FMOVQ : F3_14<2, 0b110100, 0b000000011, "fmovs">;   // fmovq r, r
 255 def FNEGS : F3_14<2, 0b110100, 0b000000101, "fnegs">;   // fnegs r, r
 256 def FNEGD : F3_14<2, 0b110100, 0b000000110, "fnegs">;   // fnegs r, r
 257 //def FNEGQ : F3_14<2, 0b110100, 0b000000111, "fnegs">;   // fnegs r, r
 258 def FABSS : F3_14<2, 0b110100, 0b000001001, "fabss">;   // fabss r, r
 259 def FABSD : F3_14<2, 0b110100, 0b000001010, "fabss">;   // fabss r, r
 260 //def FABSQ : F3_14<2, 0b110100, 0b000001011, "fabss">;   // fabss r, r
 261
 262 // Section A.18: Floating-Point Multiply and Divide - p165
 263 def FMULS  : F3_16<2, 0b110100, 0b001001001, "fmuls">;   // fmuls r, r, r
 264 def FMULD  : F3_16<2, 0b110100, 0b001001010, "fmuld">;   // fmuld r, r, r
 265 def FMULQ  : F3_16<2, 0b110100, 0b001001011, "fmulq">;   // fmulq r, r, r
 266 def FSMULD : F3_16<2, 0b110100, 0b001101001, "fsmuld">;  // fsmuls r, r, r
 267 def FDMULQ : F3_16<2, 0b110100, 0b001101110, "fdmulq">;  // fdmuls r, r, r
 268 def FDIVS  : F3_16<2, 0b110100, 0b001001101, "fdivs">;   // fdivs r, r, r
 269 def FDIVD  : F3_16<2, 0b110100, 0b001001110, "fdivs">;   // fdivd r, r, r
 270 def FDIVQ  : F3_16<2, 0b110100, 0b001001111, "fdivs">;   // fdivq r, r, r
 271
 272 // Section A.19: Floating-Point Square Root - p166
 273 def FSQRTS : F3_14<2, 0b110100, 0b000101001, "fsqrts">;  // fsqrts r, r
 274 def FSQRTD : F3_14<2, 0b110100, 0b000101010, "fsqrts">;  // fsqrts r, r
 275 def FSQRTQ : F3_14<2, 0b110100, 0b000101011, "fsqrts">;  // fsqrts r, r
 276
 277 // A.20: Flush Instruction Memory - p167
 278 // Not currently used
 279
 280 // A.21: Flush Register Windows - p169
 281 // Not currently used
 282
 283 // A.22: Illegal instruction Trap - p170
 284 // Not currently used
 285
 286 // A.23: Implementation-Dependent Instructions - p171
 287 // Not currently used
 288
 289 // Section A.24: Jump and Link - p172
 290 // Mimicking the Sparc's instr def...
 291 def JMPLCALLr : F3_1<2, 0b111000, "jmpl">;              // jmpl [r+r], r
 292 def JMPLCALLi : F3_2<2, 0b111000, "jmpl">;              // jmpl [r+i], r
 293 def JMPLRETr  : F3_1<2, 0b111000, "jmpl">;              // jmpl [r+r], r
 294 def JMPLRETi  : F3_2<2, 0b111000, "jmpl">;              // jmpl [r+i], r
 295
 296 // Section A.25: Load Floating-Point - p173
 297 def LDFr  : F3_1<3, 0b100000, "ld">;             // ld [r+r], r
 298 def LDFi  : F3_2<3, 0b100000, "ld">;             // ld [r+i], r
 299 def LDDFr : F3_1<3, 0b100011, "ldd">;            // ldd [r+r], r
 300 def LDDFi : F3_2<3, 0b100011, "ldd">;            // ldd [r+i], r
 301 def LDQFr : F3_1<3, 0b100010, "ldq">;            // ldq [r+r], r
 302 def LDQFi : F3_2<3, 0b100010, "ldq">;            // ldq [r+i], r
 303 set isDeprecated = 1 in {
 304   set rd = 0 in {
 305     def LDFSRr : F3_1<3, 0b100001, "ld">;        // ld [r+r], r
 306     def LDFSRi : F3_2<3, 0b100001, "ld">;        // ld [r+i], r
 307   }
 308 }
 309 set rd = 1 in {
 310   def LDXFSRr : F3_1<3, 0b100001, "ldx">;         // ldx [r+r], r
 311   def LDXFSRi : F3_2<3, 0b100001, "ldx">;         // ldx [r+i], r
 312 }
 313
 314 // Section A.27: Load Integer - p178
 315 def LDSBr : F3_1<3, 0b001001, "ldsb">;           // ldsb [r+r], r
 316 def LDSBi : F3_2<3, 0b001001, "ldsb">;           // ldsb [r+i], r
 317 def LDSHr : F3_1<3, 0b001010, "ldsh">;           // ldsh [r+r], r
 318 def LDSHi : F3_2<3, 0b001010, "ldsh">;           // ldsh [r+i], r
 319 def LDSWr : F3_1<3, 0b001000, "ldsw">;           // ldsh [r+r], r
 320 def LDSWi : F3_2<3, 0b001000, "ldsw">;           // ldsh [r+i], r
 321 def LDUBr : F3_1<3, 0b000001, "ldub">;           // ldub [r+r], r
 322 def LDUBi : F3_2<3, 0b000001, "ldub">;           // ldub [r+i], r
 323 def LDUHr : F3_1<3, 0b000010, "lduh">;           // lduh [r+r], r
 324 def LDUHi : F3_2<3, 0b000010, "lduh">;           // lduh [r+i], r
 325 // synonym: LD
 326 def LDUWr : F3_1<3, 0b000000, "lduw">;           // lduw [r+r], r
 327 def LDUWi : F3_2<3, 0b000000, "lduw">;           // lduw [r+i], r
 328 // LDD should no longer be used, LDX should be used instead
 329 def LDXr : F3_1<3, 0b001011, "ldx">;              // ldx [r+r], r
 330 def LDXi : F3_2<3, 0b001011, "ldx">;              // ldx [r+i], r
 331 #if 0
 332 set isDeprecated = 1 in {
 333   def LDDr : F3_1<3, 0b000011, "ldd">;            // ldd [r+r], r
 334   def LDDi : F3_2<3, 0b000011, "ldd">;            // ldd [r+i], r
 335 }
 336 #endif
 337
 338 // Section A.31: Logical operations
 339 def ANDr    : F3_1<2, 0b000001, "and">;          // and r, r, r
 340 def ANDi    : F3_2<2, 0b000001, "and">;          // and r, r, i
 341 def ANDccr  : F3_1<2, 0b010001, "andcc">;        // andcc r, r, r
 342 def ANDcci  : F3_2<2, 0b010001, "andcc">;        // andcc r, r, i
 343 def ANDNr   : F3_1<2, 0b000101, "andn">;         // andn r, r, r
 344 def ANDNi   : F3_2<2, 0b000101, "andn">;         // andn r, r, i
 345 def ANDNccr : F3_1<2, 0b010101, "andncc">;       // andncc r, r, r
 346 def ANDNcci : F3_2<2, 0b010101, "andncc">;       // andncc r, r, i
 347
 348 def ORr    : F3_1<2, 0b000010, "or">;            // or r, r, r
 349 def ORi    : F3_2<2, 0b000010, "or">;            // or r, r, i
 350 def ORccr  : F3_1<2, 0b010010, "orcc">;          // orcc r, r, r
 351 def ORcci  : F3_2<2, 0b010010, "orcc">;          // orcc r, r, i
 352 def ORNr   : F3_1<2, 0b000110, "orn">;           // orn r, r, r
 353 def ORNi   : F3_2<2, 0b000110, "orn">;           // orn r, r, i
 354 def ORNccr : F3_1<2, 0b010110, "orncc">;         // orncc r, r, r
 355 def ORNcci : F3_2<2, 0b010110, "orncc">;         // orncc r, r, i
 356
 357 def XORr    : F3_1<2, 0b000011, "xor">;          // xor r, r, r
 358 def XORi    : F3_2<2, 0b000011, "xor">;          // xor r, r, i
 359 def XORccr  : F3_1<2, 0b010011, "xorcc">;        // xorcc r, r, r
 360 def XORcci  : F3_2<2, 0b010011, "xorcc">;        // xorcc r, r, i
 361 def XNORr   : F3_1<2, 0b000111, "xnor">;         // xnor r, r, r
 362 def XNORi   : F3_2<2, 0b000111, "xnor">;         // xnor r, r, i
 363 def XNORccr : F3_1<2, 0b010111, "xnorcc">;       // xnorcc r, r, r
 364 def XNORcci : F3_2<2, 0b010111, "xnorcc">;       // xnorcc r, r, i
 365
 366 // Section A.32: Memory Barrier - p186
 367 // Not currently used in the Sparc backend
 368
 369 // Section A.33: Move Floating-Point Register on Condition (FMOVcc)
 370 // ======================= Single Floating Point ======================
 371 // For integer condition codes
 372 def FMOVSA   : F4_7<2, 0b110101, 0b1000, 0b000001, "fmovsa">;   // fmovsa   cc, r, r
 373 def FMOVSN   : F4_7<2, 0b110101, 0b0000, 0b000001, "fmovsn">;   // fmovsn   cc, r, r
 374 def FMOVSNE  : F4_7<2, 0b110101, 0b1001, 0b000001, "fmovsne">;  // fmovsne  cc, r, r
 375 def FMOVSE   : F4_7<2, 0b110101, 0b0000, 0b000001, "fmovse">;   // fmovse   cc, r, r
 376 def FMOVSG   : F4_7<2, 0b110101, 0b1010, 0b000001, "fmovsg">;   // fmovsg   cc, r, r
 377 def FMOVSLE  : F4_7<2, 0b110101, 0b0000, 0b000001, "fmovsle">;  // fmovsle  cc, r, r
 378 def FMOVSGE  : F4_7<2, 0b110101, 0b1011, 0b000001, "fmovsge">;  // fmovsge  cc, r, r
 379 def FMOVSL   : F4_7<2, 0b110101, 0b0011, 0b000001, "fmovsl">;   // fmovsl   cc, r, r
 380 def FMOVSGU  : F4_7<2, 0b110101, 0b1100, 0b000001, "fmovsgu">;  // fmovsgu  cc, r, r
 381 def FMOVSLEU : F4_7<2, 0b110101, 0b0100, 0b000001, "fmovsleu">; // fmovsleu cc, r, r
 382 def FMOVSCC  : F4_7<2, 0b110101, 0b1101, 0b000001, "fmovscc">;  // fmovscc  cc, r, r
 383 def FMOVSCS  : F4_7<2, 0b110101, 0b0101, 0b000001, "fmovscs">;  // fmovscs  cc, r, r
 384 def FMOVSPOS : F4_7<2, 0b110101, 0b1110, 0b000001, "fmovspos">; // fmovspos cc, r, r
 385 def FMOVSNEG : F4_7<2, 0b110101, 0b0110, 0b000001, "fmovsneg">; // fmovsneg cc, r, r
 386 def FMOVSVC  : F4_7<2, 0b110101, 0b1111, 0b000001, "fmovsvc">;  // fmovsvc  cc, r, r
 387 def FMOVSVS  : F4_7<2, 0b110101, 0b0111, 0b000001, "fmovsvs">;  // fmovsvs  cc, r, r
 388
 389 // For floating-point condition codes
 390 def FMOVSFA   : F4_7<2, 0b110101, 0b0100, 0b000001, "fmovsfa">;  // fmovsfa   cc,r,r
 391 def FMOVSFN   : F4_7<2, 0b110101, 0b0000, 0b000001, "fmovsfn">;  // fmovsfa   cc,r,r
 392 def FMOVSFU   : F4_7<2, 0b110101, 0b0111, 0b000001, "fmovsfu">;  // fmovsfu   cc,r,r
 393 def FMOVSFG   : F4_7<2, 0b110101, 0b0110, 0b000001, "fmovsfg">;  // fmovsfg   cc,r,r
 394 def FMOVSFUG  : F4_7<2, 0b110101, 0b0101, 0b000001, "fmovsfug">; // fmovsfug  cc,r,r
 395 def FMOVSFL   : F4_7<2, 0b110101, 0b0100, 0b000001, "fmovsfl">;  // fmovsfl   cc,r,r
 396 def FMOVSFUL  : F4_7<2, 0b110101, 0b0011, 0b000001, "fmovsful">; // fmovsful  cc,r,r
 397 def FMOVSFLG  : F4_7<2, 0b110101, 0b0010, 0b000001, "fmovsflg">; // fmovsflg  cc,r,r
 398 def FMOVSFNE  : F4_7<2, 0b110101, 0b0001, 0b000001, "fmovsfne">; // fmovsfne  cc,r,r
 399 def FMOVSFE   : F4_7<2, 0b110101, 0b1001, 0b000001, "fmovsfe">;  // fmovsfe   cc,r,r
 400 def FMOVSFUE  : F4_7<2, 0b110101, 0b1010, 0b000001, "fmovsfue">; // fmovsfue  cc,r,r
 401 def FMOVSFGE  : F4_7<2, 0b110101, 0b1011, 0b000001, "fmovsge">;  // fmovsge   cc,r,r
 402 def FMOVSFUGE : F4_7<2, 0b110101, 0b1100, 0b000001, "fmovsfuge">;// fmovsfuge cc,r,r
 403 def FMOVSFLE  : F4_7<2, 0b110101, 0b1101, 0b000001, "fmovsfle">; // fmovsfle  cc,r,r
 404 def FMOVSFULE : F4_7<2, 0b110101, 0b1110, 0b000001, "fmovsfule">;// fmovsfule cc,r,r
 405 def FMOVSFO   : F4_7<2, 0b110101, 0b1111, 0b000001, "fmovsfo">;  // fmovsfo   cc,r,r
 406
 407 // ======================= Double Floating Point ======================
 408 // For integer condition codes
 409 def FMOVDA   : F4_7<2, 0b110101, 0b1000, 0b000010, "fmovda">;   // fmovda   cc, r, r
 410 def FMOVDN   : F4_7<2, 0b110101, 0b0000, 0b000010, "fmovdn">;   // fmovdn   cc, r, r
 411 def FMOVDNE  : F4_7<2, 0b110101, 0b1001, 0b000010, "fmovdne">;  // fmovdne  cc, r, r
 412 def FMOVDE   : F4_7<2, 0b110101, 0b0000, 0b000010, "fmovde">;   // fmovde   cc, r, r
 413 def FMOVDG   : F4_7<2, 0b110101, 0b1010, 0b000010, "fmovdg">;   // fmovdg   cc, r, r
 414 def FMOVDLE  : F4_7<2, 0b110101, 0b0000, 0b000010, "fmovdle">;  // fmovdle  cc, r, r
 415 def FMOVDGE  : F4_7<2, 0b110101, 0b1011, 0b000010, "fmovdge">;  // fmovdge  cc, r, r
 416 def FMOVDL   : F4_7<2, 0b110101, 0b0011, 0b000010, "fmovdl">;   // fmovdl   cc, r, r
 417 def FMOVDGU  : F4_7<2, 0b110101, 0b1100, 0b000010, "fmovdgu">;  // fmovdgu  cc, r, r
 418 def FMOVDLEU : F4_7<2, 0b110101, 0b0100, 0b000010, "fmovdleu">; // fmovdleu cc, r, r
 419 def FMOVDCC  : F4_7<2, 0b110101, 0b1101, 0b000010, "fmovdcc">;  // fmovdcc  cc, r, r
 420 def FMOVDCS  : F4_7<2, 0b110101, 0b0101, 0b000010, "fmovdcs">;  // fmovdcs  cc, r, r
 421 def FMOVDPOS : F4_7<2, 0b110101, 0b1110, 0b000010, "fmovdpos">; // fmovdpos cc, r, r
 422 def FMOVDNEG : F4_7<2, 0b110101, 0b0110, 0b000010, "fmovdneg">; // fmovdneg cc, r, r
 423 def FMOVDVC  : F4_7<2, 0b110101, 0b1111, 0b000010, "fmovdvc">;  // fmovdvc  cc, r, r
 424 def FMOVDVS  : F4_7<2, 0b110101, 0b0111, 0b000010, "fmovdvs">;  // fmovdvs  cc, r, r
 425
 426 // For floating-point condition codes
 427 def FMOVDFA   : F4_7<2, 0b110101, 0b0100, 0b000010, "fmovdfa">;  // fmovdfa   cc,r,r
 428 def FMOVDFN   : F4_7<2, 0b110101, 0b0000, 0b000010, "fmovdfn">;  // fmovdfa   cc,r,r
 429 def FMOVDFU   : F4_7<2, 0b110101, 0b0111, 0b000010, "fmovdfu">;  // fmovdfu   cc,r,r
 430 def FMOVDFG   : F4_7<2, 0b110101, 0b0110, 0b000010, "fmovdfg">;  // fmovdfg   cc,r,r
 431 def FMOVDFUG  : F4_7<2, 0b110101, 0b0101, 0b000010, "fmovdfug">; // fmovdfug  cc,r,r
 432 def FMOVDFL   : F4_7<2, 0b110101, 0b0100, 0b000010, "fmovdfl">;  // fmovdfl   cc,r,r
 433 def FMOVDFUL  : F4_7<2, 0b110101, 0b0011, 0b000010, "fmovdful">; // fmovdful  cc,r,r
 434 def FMOVDFLG  : F4_7<2, 0b110101, 0b0010, 0b000010, "fmovdflg">; // fmovdflg  cc,r,r
 435 def FMOVDFNE  : F4_7<2, 0b110101, 0b0001, 0b000010, "fmovdfne">; // fmovdfne  cc,r,r
 436 def FMOVDFE   : F4_7<2, 0b110101, 0b1001, 0b000010, "fmovdfe">;  // fmovdfe   cc,r,r
 437 def FMOVDFUE  : F4_7<2, 0b110101, 0b1010, 0b000010, "fmovdfue">; // fmovdfue  cc,r,r
 438 def FMOVDFGE  : F4_7<2, 0b110101, 0b1011, 0b000010, "fmovdge">;  // fmovdge   cc,r,r
 439 def FMOVDFUGE : F4_7<2, 0b110101, 0b1100, 0b000010, "fmovdfuge">;// fmovdfuge cc,r,r
 440 def FMOVDFLE  : F4_7<2, 0b110101, 0b1101, 0b000010, "fmovdfle">; // fmovdfle  cc,r,r
 441 def FMOVDFULE : F4_7<2, 0b110101, 0b1110, 0b000010, "fmovdfule">;// fmovdfule cc,r,r
 442 def FMOVDFO   : F4_7<2, 0b110101, 0b1111, 0b000010, "fmovdfo">;  // fmovdfo   cc,r,r
 443
 444 // ======================= Quad Floating Point ======================
 445 // For integer condition codes
 446 def FMOVQA   : F4_7<2, 0b110101, 0b1000, 0b000011, "fmovqa">;   // fmovqa   cc, r, r
 447 def FMOVQN   : F4_7<2, 0b110101, 0b0000, 0b000011, "fmovqn">;   // fmovqn   cc, r, r
 448 def FMOVQNE  : F4_7<2, 0b110101, 0b1001, 0b000011, "fmovqne">;  // fmovqne  cc, r, r
 449 def FMOVQE   : F4_7<2, 0b110101, 0b0000, 0b000011, "fmovqe">;   // fmovqe   cc, r, r
 450 def FMOVQG   : F4_7<2, 0b110101, 0b1010, 0b000011, "fmovqg">;   // fmovqg   cc, r, r
 451 def FMOVQLE  : F4_7<2, 0b110101, 0b0000, 0b000011, "fmovqle">;  // fmovqle  cc, r, r
 452 def FMOVQGE  : F4_7<2, 0b110101, 0b1011, 0b000011, "fmovqge">;  // fmovqge  cc, r, r
 453 def FMOVQL   : F4_7<2, 0b110101, 0b0011, 0b000011, "fmovql">;   // fmovql   cc, r, r
 454 def FMOVQGU  : F4_7<2, 0b110101, 0b1100, 0b000011, "fmovqgu">;  // fmovqgu  cc, r, r
 455 def FMOVQLEU : F4_7<2, 0b110101, 0b0100, 0b000011, "fmovqleu">; // fmovqleu cc, r, r
 456 def FMOVQCC  : F4_7<2, 0b110101, 0b1101, 0b000011, "fmovqcc">;  // fmovqcc  cc, r, r
 457 def FMOVQCS  : F4_7<2, 0b110101, 0b0101, 0b000011, "fmovqcs">;  // fmovqcs  cc, r, r
 458 def FMOVQPOS : F4_7<2, 0b110101, 0b1110, 0b000011, "fmovqpos">; // fmovqpos cc, r, r
 459 def FMOVQNEG : F4_7<2, 0b110101, 0b0110, 0b000011, "fmovqneg">; // fmovqneg cc, r, r
 460 def FMOVQVC  : F4_7<2, 0b110101, 0b1111, 0b000011, "fmovqvc">;  // fmovqvc  cc, r, r
 461 def FMOVQVS  : F4_7<2, 0b110101, 0b0111, 0b000011, "fmovqvs">;  // fmovqvs  cc, r, r
 462
 463 // For floating-point condition codes
 464 def FMOVQFA   : F4_7<2, 0b110101, 0b0100, 0b000011, "fmovqfa">;  // fmovqfa   cc,r,r
 465 def FMOVQFN   : F4_7<2, 0b110101, 0b0000, 0b000011, "fmovqfn">;  // fmovqfa   cc,r,r
 466 def FMOVQFU   : F4_7<2, 0b110101, 0b0111, 0b000011, "fmovqfu">;  // fmovqfu   cc,r,r
 467 def FMOVQFG   : F4_7<2, 0b110101, 0b0110, 0b000011, "fmovqfg">;  // fmovqfg   cc,r,r
 468 def FMOVQFUG  : F4_7<2, 0b110101, 0b0101, 0b000011, "fmovqfug">; // fmovqfug  cc,r,r
 469 def FMOVQFL   : F4_7<2, 0b110101, 0b0100, 0b000011, "fmovqfl">;  // fmovqfl   cc,r,r
 470 def FMOVQFUL  : F4_7<2, 0b110101, 0b0011, 0b000011, "fmovqful">; // fmovqful  cc,r,r
 471 def FMOVQFLG  : F4_7<2, 0b110101, 0b0010, 0b000011, "fmovqflg">; // fmovqflg  cc,r,r
 472 def FMOVQFNE  : F4_7<2, 0b110101, 0b0001, 0b000011, "fmovqfne">; // fmovqfne  cc,r,r
 473 def FMOVQFE   : F4_7<2, 0b110101, 0b1001, 0b000011, "fmovqfe">;  // fmovqfe   cc,r,r
 474 def FMOVQFUE  : F4_7<2, 0b110101, 0b1010, 0b000011, "fmovqfue">; // fmovqfue  cc,r,r
 475 def FMOVQFGE  : F4_7<2, 0b110101, 0b1011, 0b000011, "fmovqge">;  // fmovqge   cc,r,r
 476 def FMOVQFUGE : F4_7<2, 0b110101, 0b1100, 0b000011, "fmovqfuge">;// fmovqfuge cc,r,r
 477 def FMOVQFLE  : F4_7<2, 0b110101, 0b1101, 0b000011, "fmovqfle">; // fmovqfle  cc,r,r
 478 def FMOVQFULE : F4_7<2, 0b110101, 0b1110, 0b000011, "fmovqfule">;// fmovqfule cc,r,r
 479 def FMOVQFO   : F4_7<2, 0b110101, 0b1111, 0b000011, "fmovqfo">;  // fmovqfo   cc,r,r
 480
 481 // Section A.34: Move FP Register on Integer Register condition (FMOVr) - p192
 482 def FMOVRSZ   : F4_6<2, 0b110101, 0b001, 0b00101, "fmovrsz">;  //fmovsrz r,r,rd
 483 def FMOVRSLEZ : F4_6<2, 0b110101, 0b010, 0b00101, "fmovrslez">;//fmovsrz r,r,rd
 484 def FMOVRSLZ  : F4_6<2, 0b110101, 0b011, 0b00101, "fmovrslz">; //fmovsrz r,r,rd
 485 def FMOVRSNZ  : F4_6<2, 0b110101, 0b101, 0b00101, "fmovrsne">; //fmovsrz r,r,rd
 486 def FMOVRSGZ  : F4_6<2, 0b110101, 0b110, 0b00101, "fmovrsgz">; //fmovsrz r,r,rd
 487 def FMOVRSGEZ : F4_6<2, 0b110101, 0b111, 0b00101, "fmovrsgez">;//fmovsrz r,r,rd
 488
 489 def FMOVRDZ   : F4_6<2, 0b110101, 0b001, 0b00110, "fmovrdz">;  //fmovsrz r,r,rd
 490 def FMOVRDLEZ : F4_6<2, 0b110101, 0b010, 0b00110, "fmovrdlez">;//fmovsrz r,r,rd
 491 def FMOVRDLZ  : F4_6<2, 0b110101, 0b011, 0b00110, "fmovrdlz">; //fmovsrz r,r,rd
 492 def FMOVRDNZ  : F4_6<2, 0b110101, 0b101, 0b00110, "fmovrdne">; //fmovsrz r,r,rd
 493 def FMOVRDGZ  : F4_6<2, 0b110101, 0b110, 0b00110, "fmovrdgz">; //fmovsrz r,r,rd
 494 def FMOVRDGEZ : F4_6<2, 0b110101, 0b111, 0b00110, "fmovrdgez">;//fmovsrz r,r,rd
 495
 496 def FMOVRQZ   : F4_6<2, 0b110101, 0b001, 0b00111, "fmovrqz">;  //fmovsrz r,r,rd
 497 def FMOVRQLEZ : F4_6<2, 0b110101, 0b010, 0b00111, "fmovrqlez">;//fmovsrz r,r,rd
 498 def FMOVRQLZ  : F4_6<2, 0b110101, 0b011, 0b00111, "fmovrqlz">; //fmovsrz r,r,rd
 499 def FMOVRQNZ  : F4_6<2, 0b110101, 0b101, 0b00111, "fmovrqne">; //fmovsrz r,r,rd
 500 def FMOVRQGZ  : F4_6<2, 0b110101, 0b110, 0b00111, "fmovrqgz">; //fmovsrz r,r,rd
 501 def FMOVRQGEZ : F4_6<2, 0b110101, 0b111, 0b00111, "fmovrqgez">;//fmovsrz r,r,rd
 502
 503
 504 // Section A.35: Move Integer Register on Condition (MOVcc) - p194
 505 // For integer condition codes
 506 def MOVAr    : F4_3<2, 0b101100, 0b1000, "mova">;      // mova i/xcc, rs2, rd
 507 def MOVAi    : F4_4<2, 0b101100, 0b1000, "mova">;      // mova i/xcc, rs2, rd
 508 def MOVNr    : F4_3<2, 0b101100, 0b0000, "movn">;      // mova i/xcc, rs2, rd
 509 def MOVNi    : F4_4<2, 0b101100, 0b0000, "movn">;      // mova i/xcc, rs2, rd
 510 def MOVNEr   : F4_3<2, 0b101100, 0b1001, "movne">;     // mova i/xcc, rs2, rd
 511 def MOVNEi   : F4_4<2, 0b101100, 0b1001, "movne">;     // mova i/xcc, rs2, rd
 512 def MOVEr    : F4_3<2, 0b101100, 0b0001, "move">;      // mova i/xcc, rs2, rd
 513 def MOVEi    : F4_4<2, 0b101100, 0b0001, "move">;      // mova i/xcc, rs2, rd
 514 def MOVGr    : F4_3<2, 0b101100, 0b1010, "movg">;      // mova i/xcc, rs2, rd
 515 def MOVGi    : F4_4<2, 0b101100, 0b1010, "movg">;      // mova i/xcc, rs2, rd
 516 def MOVLEr   : F4_3<2, 0b101100, 0b0010, "movle">;     // mova i/xcc, rs2, rd
 517 def MOVLEi   : F4_4<2, 0b101100, 0b0010, "movle">;     // mova i/xcc, rs2, rd
 518 def MOVGEr   : F4_3<2, 0b101100, 0b1011, "movge">;     // mova i/xcc, rs2, rd
 519 def MOVGEi   : F4_4<2, 0b101100, 0b1011, "movge">;     // mova i/xcc, rs2, rd
 520 def MOVLr    : F4_3<2, 0b101100, 0b0011, "movl">;      // mova i/xcc, rs2, rd
 521 def MOVLi    : F4_4<2, 0b101100, 0b0011, "movl">;      // mova i/xcc, rs2, rd
 522 def MOVGUr   : F4_3<2, 0b101100, 0b1100, "movgu">;     // mova i/xcc, rs2, rd
 523 def MOVGUi   : F4_4<2, 0b101100, 0b1100, "movgu">;     // mova i/xcc, rs2, rd
 524 def MOVLEUr  : F4_3<2, 0b101100, 0b0100, "movleu">;    // mova i/xcc, rs2, rd
 525 def MOVLEUi  : F4_4<2, 0b101100, 0b0100, "movleu">;    // mova i/xcc, rs2, rd
 526 def MOVCCr   : F4_3<2, 0b101100, 0b1101, "movcc">;     // mova i/xcc, rs2, rd
 527 def MOVCCi   : F4_4<2, 0b101100, 0b1101, "movcc">;     // mova i/xcc, rs2, rd
 528 def MOVCSr   : F4_3<2, 0b101100, 0b0101, "movcs">;     // mova i/xcc, rs2, rd
 529 def MOVCSi   : F4_4<2, 0b101100, 0b0101, "movcs">;     // mova i/xcc, rs2, rd
 530 def MOVPOSr  : F4_3<2, 0b101100, 0b1110, "movpos">;    // mova i/xcc, rs2, rd
 531 def MOVPOSi  : F4_4<2, 0b101100, 0b1110, "movpos">;    // mova i/xcc, rs2, rd
 532 def MOVNEGr  : F4_3<2, 0b101100, 0b0110, "movneg">;    // mova i/xcc, rs2, rd
 533 def MOVNEGi  : F4_4<2, 0b101100, 0b0110, "movneg">;    // mova i/xcc, rs2, rd
 534 def MOVVCr   : F4_3<2, 0b101100, 0b1111, "movvc">;     // mova i/xcc, rs2, rd
 535 def MOVVCi   : F4_4<2, 0b101100, 0b1111, "movvc">;     // mova i/xcc, rs2, rd
 536 def MOVVSr   : F4_3<2, 0b101100, 0b0111, "movvs">;     // mova i/xcc, rs2, rd
 537 def MOVVSi   : F4_4<2, 0b101100, 0b0111, "movvs">;     // mova i/xcc, rs2, rd
 538
 539 // For floating-point condition codes
 540 def MOVFAr   : F4_3<2, 0b101100, 0b1000, "movfa">;     // mova i/xcc, rs2, rd
 541 def MOVFAi   : F4_4<2, 0b101100, 0b1000, "movfa">;     // mova i/xcc, rs2, rd
 542 def MOVFNr   : F4_3<2, 0b101100, 0b0000, "movfn">;     // mova i/xcc, rs2, rd
 543 def MOVFNi   : F4_4<2, 0b101100, 0b0000, "movfn">;     // mova i/xcc, rs2, rd
 544 def MOVFUr   : F4_3<2, 0b101100, 0b0111, "movfu">;     // mova i/xcc, rs2, rd
 545 def MOVFUi   : F4_4<2, 0b101100, 0b0111, "movfu">;     // mova i/xcc, rs2, rd
 546 def MOVFGr   : F4_3<2, 0b101100, 0b0110, "movfg">;     // mova i/xcc, rs2, rd
 547 def MOVFGi   : F4_4<2, 0b101100, 0b0110, "movfg">;     // mova i/xcc, rs2, rd
 548 def MOVFUGr  : F4_3<2, 0b101100, 0b0101, "movfug">;    // mova i/xcc, rs2, rd
 549 def MOVFUGi  : F4_4<2, 0b101100, 0b0101, "movfug">;    // mova i/xcc, rs2, rd
 550 def MOVFLr   : F4_3<2, 0b101100, 0b0100, "movfl">;     // mova i/xcc, rs2, rd
 551 def MOVFLi   : F4_4<2, 0b101100, 0b0100, "movfl">;     // mova i/xcc, rs2, rd
 552 def MOVFULr  : F4_3<2, 0b101100, 0b0011, "movful">;    // mova i/xcc, rs2, rd
 553 def MOVFULi  : F4_4<2, 0b101100, 0b0011, "movful">;    // mova i/xcc, rs2, rd
 554 def MOVFLGr  : F4_3<2, 0b101100, 0b0010, "movflg">;    // mova i/xcc, rs2, rd
 555 def MOVFLGi  : F4_4<2, 0b101100, 0b0010, "movflg">;    // mova i/xcc, rs2, rd
 556 def MOVFNEr  : F4_3<2, 0b101100, 0b0001, "movfne">;    // mova i/xcc, rs2, rd
 557 def MOVFNEi  : F4_4<2, 0b101100, 0b0001, "movfne">;    // mova i/xcc, rs2, rd
 558 def MOVFEr   : F4_3<2, 0b101100, 0b1001, "movfe">;     // mova i/xcc, rs2, rd
 559 def MOVFEi   : F4_4<2, 0b101100, 0b1001, "movfe">;     // mova i/xcc, rs2, rd
 560 def MOVFUEr  : F4_3<2, 0b101100, 0b1010, "movfue">;    // mova i/xcc, rs2, rd
 561 def MOVFUEi  : F4_4<2, 0b101100, 0b1010, "movfue">;    // mova i/xcc, rs2, rd
 562 def MOVFGEr  : F4_3<2, 0b101100, 0b1011, "movfge">;    // mova i/xcc, rs2, rd
 563 def MOVFGEi  : F4_4<2, 0b101100, 0b1011, "movfge">;    // mova i/xcc, rs2, rd
 564 def MOVFUGEr : F4_3<2, 0b101100, 0b1100, "movfuge">;   // mova i/xcc, rs2, rd
 565 def MOVFUGEi : F4_4<2, 0b101100, 0b1100, "movfuge">;   // mova i/xcc, rs2, rd
 566 def MOVFLEr  : F4_3<2, 0b101100, 0b1101, "movfle">;    // mova i/xcc, rs2, rd
 567 def MOVFLEi  : F4_4<2, 0b101100, 0b1101, "movfle">;    // mova i/xcc, rs2, rd
 568 def MOVFULEr : F4_3<2, 0b101100, 0b1110, "movfule">;   // mova i/xcc, rs2, rd
 569 def MOVFULEi : F4_4<2, 0b101100, 0b1110, "movfule">;   // mova i/xcc, rs2, rd
 570 def MOVFOr   : F4_3<2, 0b101100, 0b1111, "movfo">;     // mova i/xcc, rs2, rd
 571 def MOVFOi   : F4_4<2, 0b101100, 0b1111, "movfo">;     // mova i/xcc, rs2, rd
 572
 573 // Section A.36: Move Integer Register on Register Condition (MOVR)
 574 def MOVRZr   : F3_5<2, 0b101111, 0b001, "movrz">;      // movrz rs1, rs2, rd
 575 def MOVRZi   : F3_6<2, 0b101111, 0b001, "movrz">;      // movrz rs1, imm, rd
 576 def MOVRLEZr : F3_5<2, 0b101111, 0b010, "movrlez">;    // movrz rs1, rs2, rd
 577 def MOVRLEZi : F3_6<2, 0b101111, 0b010, "movrlez">;    // movrz rs1, imm, rd
 578 def MOVRLZr  : F3_5<2, 0b101111, 0b011, "movrlz">;     // movrz rs1, rs2, rd
 579 def MOVRLZi  : F3_6<2, 0b101111, 0b011, "movrlz">;     // movrz rs1, imm, rd
 580 def MOVRNZr  : F3_5<2, 0b101111, 0b101, "movrnz">;     // movrz rs1, rs2, rd
 581 def MOVRNZi  : F3_6<2, 0b101111, 0b101, "movrnz">;     // movrz rs1, imm, rd
 582 def MOVRGZr  : F3_5<2, 0b101111, 0b110, "movrgz">;     // movrz rs1, rs2, rd
 583 def MOVRGZi  : F3_6<2, 0b101111, 0b110, "movrgz">;     // movrz rs1, imm, rd
 584 def MOVRGEZr : F3_5<2, 0b101111, 0b111, "movrgez">;    // movrz rs1, rs2, rd
 585 def MOVRGEZi : F3_6<2, 0b101111, 0b111, "movrgez">;    // movrz rs1, imm, rd
 586
 587 // Section A.37: Multiply and Divide (64-bit) - p199
 588 def MULXr  : F3_1<2, 0b001001, "mulx">;        // mulx  r, r, r
 589 def SDIVXr : F3_1<2, 0b101101, "sdivx">;       // mulx  r, r, r
 590 def UDIVXr : F3_1<2, 0b001101, "udivx">;       // mulx  r, r, r
 591 def MULXi  : F3_2<2, 0b001001, "mulx">;        // mulx  r, i, r
 592 def SDIVXi : F3_2<2, 0b101101, "sdivx">;       // mulx  r, i, r
 593 def UDIVXi : F3_2<2, 0b001101, "udivx">;       // mulx  r, i, r
 594
 595 // Section A.38: Multiply (32-bit) - p200
 596 // Not used in the Sparc backend
 597 #if 0
 598 set Inst{13} = 0 in {
 599   def UMULr   : F3_1<2, 0b001010, "umul">;        // umul   r, r, r
 600   def SMULr   : F3_1<2, 0b001011, "smul">;        // smul   r, r, r
 601   def UMULCCr : F3_1<2, 0b011010, "umulcc">;      // mulcc  r, r, r
 602   def SMULCCr : F3_1<2, 0b011011, "smulcc">;      // smulcc r, r, r
 603 }
 604 set Inst{13} = 1 in {
 605   def UMULi   : F3_1<2, 0b001010, "umul">;        // umul   r, i, r
 606   def SMULi   : F3_1<2, 0b001011, "smul">;        // smul   r, i, r
 607   def UMULCCi : F3_1<2, 0b011010, "umulcc">;      // umulcc r, i, r
 608   def SMULCCi : F3_1<2, 0b011011, "smulcc">;      // smulcc r, i, r
 609 }
 610 #endif
 611
 612 // Section A.39: Multiply Step - p202
 613 // Not currently used in the Sparc backend
 614
 615 // Section A.40: No operation - p204
 616 // NOP is really a pseudo-instruction (special case of SETHI)
 617 set op2 = 0b100 in {
 618   set rd = 0 in {
 619     set imm = 0 in {
 620       def NOP : F2_1<"nop">;                     // nop
 621     }
 622   }
 623 }
 624
 625 // Section A.41: Population Count - p205
 626 // Not currently used in the Sparc backend
 627
 628 // Section A.42: Prefetch Data - p206
 629 // Not currently used in the Sparc backend
 630
 631 // Section A.43: Read Privileged Register - p211
 632 // Not currently used in the Sparc backend
 633
 634 // Section A.44: Read State Register
 635 // The only instr from this section currently used is RDCCR
 636 set rs1 = 2 in {
 637   def RDCCR : F3_17<2, 0b101000, "rd">;             // rd %ccr, r
 638 }
 639
 640 // Section A.45: RETURN - p216
 641 set isReturn = 1 in {
 642   def RETURNr : F3_3<2, 0b111001, "return">;      // return
 643   def RETURNi : F3_4<2, 0b111001, "return">;      // return
 644 }
 645
 646 // Section A.46: SAVE and RESTORE - p217
 647 def SAVEr    : F3_1<2, 0b111100, "save">;       // save    r, r, r
 648 def SAVEi    : F3_2<2, 0b111100, "save">;       // save    r, i, r
 649 def RESTOREr : F3_1<2, 0b111101, "restore">;    // restore r, r, r
 650 def RESTOREi : F3_2<2, 0b111101, "restore">;    // restore r, i, r
 651
 652 // Section A.47: SAVED and RESTORED - p219
 653 // Not currently used in Sparc backend
 654
 655 // Section A.48: SETHI - p220
 656 set op2 = 0b100 in {
 657   def SETHI : F2_1<"sethi">;                      // sethi
 658 }
 659
 660 // Section A.49: Shift - p221
 661 // Not currently used in the Sparc backend
 662 #if 0
 663  uses 5 least significant bits of rs2
 664 set x = 0 in {
 665   def SLLr5  : F3_11<2, 0b100101, "sll">;                // sll r, r, r
 666   def SRLr5  : F3_11<2, 0b100110, "srl">;                // srl r, r, r
 667   def SRAr5  : F3_11<2, 0b100111, "sra">;                // sra r, r, r
 668   def SLLXr5 : F3_11<2, 0b100101, "sllx">;               // sllx r, r, r
 669   def SRLXr5 : F3_11<2, 0b100110, "srlx">;               // srlx r, r, r
 670   def SRAXr5 : F3_11<2, 0b100111, "srax">;               // srax r, r, r
 671 }
 672 #endif
 673
 674 // uses 6 least significant bits of rs2
 675 set x = 1 in {
 676   def SLLr6  : F3_11<2, 0b100101, "sll">;                // sll r, r, r
 677   def SRLr6  : F3_11<2, 0b100110, "srl">;                // srl r, r, r
 678   def SRAr6  : F3_11<2, 0b100111, "sra">;                // sra r, r, r
 679   def SLLXr6 : F3_11<2, 0b100101, "sllx">;               // sllx r, r, r
 680   def SRLXr6 : F3_11<2, 0b100110, "srlx">;               // srlx r, r, r
 681   def SRAXr6 : F3_11<2, 0b100111, "srax">;               // srax r, r, r
 682 }
 683
 684 // Not currently used in the Sparc backend
 685 #if 0
 686 def SLLi5  : F3_12<2, 0b100101, "sll">;                // sll r, shcnt32, r
 687 def SRLi5  : F3_12<2, 0b100110, "srl">;                // srl r, shcnt32, r
 688 def SRAi5  : F3_12<2, 0b100111, "sra">;                // sra r, shcnt32, r
 689 def SLLXi5 : F3_12<2, 0b100101, "sllx">;               // sllx r, shcnt32, r
 690 def SRLXi5 : F3_12<2, 0b100110, "srlx">;               // srlx r, shcnt32, r
 691 def SRAXi5 : F3_12<2, 0b100111, "srax">;               // srax r, shcnt32, r
 692 #endif
 693
 694 def SLLi6  : F3_13<2, 0b100101, "sll">;                  // sll r, shcnt64, r
 695 def SRLi6  : F3_13<2, 0b100110, "srl">;                  // srl r, shcnt64, r
 696 def SRAi6  : F3_13<2, 0b100111, "sra">;                  // sra r, shcnt64, r
 697 def SLLXi6 : F3_13<2, 0b100101, "sllx">;                 // sllx r, shcnt64, r
 698 def SRLXi6 : F3_13<2, 0b100110, "srlx">;                 // srlx r, shcnt64, r
 699 def SRAXi6 : F3_13<2, 0b100111, "srax">;                 // srax r, shcnt64, r
 700
 701 // Section A.50: Sofware-Initiated Reset - p223
 702 // Not currently used in the Sparc backend
 703
 704 // Section A.51: Store Barrier - p224
 705 // Not currently used in the Sparc backend
 706
 707 // Section A.52: Store Floating-point - p225
 708 // Store instructions all want their rd register first
 709 def STFr  : F3_1rd<3, 0b100100, "st">;                      // st r, [r+r]
 710 def STFi  : F3_2rd<3, 0b100100, "st">;                      // st r, [r+i]
 711 def STDFr : F3_1rd<3, 0b100111, "std">;                     // std r, [r+r]
 712 def STDFi : F3_2rd<3, 0b100111, "std">;                     // std r, [r+i]
 713
 714 // Not currently used in the Sparc backend
 715 #if 0
 716 def STQFr : F3_1rd<3, 0b100110, "stq">;                     // stq r, [r+r]
 717 def STQFi : F3_2rd<3, 0b100110, "stq">;                     // stq r, [r+i]
 718 #endif
 719
 720 // FIXME: An encoding needs to be chosen here, because STFSRx expect rd=0,
 721 // while STXFSRx expect rd=1, but assembly syntax dictates %fsr as first arg.
 722 // These are being disabled because they aren't used in the Sparc backend.
 723 #if 0
 724 set isDeprecated = 1 in {
 725   def STFSRr : F3_1<3, 0b100101, "st">;                   // st  %fsr, [r+r]
 726   def STFSRi : F3_2<3, 0b100101, "st">;                   // st  %fsr, [r+i]
 727 }
 728 def STXFSRr : F3_1<3, 0b100101, "stx">;                   // stx %fsr, [r+r]
 729 def STXFSRi : F3_2<3, 0b100101, "stx">;                   // stx %fsr, [r+i]
 730 #endif
 731
 732 // Section A.53: Store Floating-Point into Alternate Space - p227
 733 // Not currently used in the Sparc backend
 734
 735 // Section A.54: Store Integer - p229
 736 // Store instructions all want their rd register first
 737 def STBr : F3_1rd<3, 0b000101, "stb">;                     // stb r, [r+r]
 738 def STBi : F3_2rd<3, 0b000101, "stb">;                     // stb r, [r+i]
 739 def STHr : F3_1rd<3, 0b000110, "sth">;                     // stb r, [r+r]
 740 def STHi : F3_2rd<3, 0b000110, "sth">;                     // stb r, [r+i]
 741 def STWr : F3_1rd<3, 0b000100, "stw">;                     // stb r, [r+r]
 742 def STWi : F3_2rd<3, 0b000100, "stw">;                     // stb r, [r+i]
 743 def STXr : F3_1rd<3, 0b001110, "stx">;                     // stb r, [r+r]
 744 def STXi : F3_2rd<3, 0b001110, "stx">;                     // stb r, [r+i]
 745
 746 // Section A.55: Store Integer into Alternate Space - p231
 747 // Not currently used in the Sparc backend
 748
 749 // Section A.56: Subtract - p233
 750 def SUBr    : F3_1<2, 0b000100, "sub">;                   // sub r, r, r
 751 def SUBi    : F3_1<2, 0b000100, "sub">;                   // sub r, i, r
 752 def SUBccr  : F3_1<2, 0b010100, "subcc">;                 // subcc r, r, r
 753 def SUBcci  : F3_1<2, 0b010100, "subcc">;                 // subcc r, i, r
 754 def SUBCr   : F3_1<2, 0b001100, "subc">;                  // subc r, r, r
 755 def SUBCi   : F3_1<2, 0b001100, "subc">;                  // subc r, i, r
 756 def SUBCccr : F3_1<2, 0b011100, "subccc">;                // subccc r, r, r
 757 def SUBCcci : F3_1<2, 0b011100, "subccc">;                // subccc r, i, r
 758
 759 // FIXME: More...?