lib/Target/X86/X86InstrArithmetic.td

   1 //===- X86InstrArithmetic.td - Integer Arithmetic Instrs ---*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the integer arithmetic instructions in the X86
  11 // architecture.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 //===----------------------------------------------------------------------===//
  16 // LEA - Load Effective Address
  17
  18 let neverHasSideEffects = 1 in
  19 def LEA16r   : I<0x8D, MRMSrcMem,
  20                  (outs GR16:$dst), (ins i32mem:$src),
  21                  "lea{w}\t{$src|$dst}, {$dst|$src}", []>, OpSize;
  22 let isReMaterializable = 1 in
  23 def LEA32r   : I<0x8D, MRMSrcMem,
  24                  (outs GR32:$dst), (ins i32mem:$src),
  25                  "lea{l}\t{$src|$dst}, {$dst|$src}",
  26                  [(set GR32:$dst, lea32addr:$src)]>, Requires<[In32BitMode]>;
  27
  28 def LEA64_32r : I<0x8D, MRMSrcMem,
  29                   (outs GR32:$dst), (ins lea64_32mem:$src),
  30                   "lea{l}\t{$src|$dst}, {$dst|$src}",
  31                   [(set GR32:$dst, lea32addr:$src)]>, Requires<[In64BitMode]>;
  32
  33 let isReMaterializable = 1 in
  34 def LEA64r   : RI<0x8D, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
  35                   "lea{q}\t{$src|$dst}, {$dst|$src}",
  36                   [(set GR64:$dst, lea64addr:$src)]>;
  37
  38
  39
  40 //===----------------------------------------------------------------------===//
  41 //  Fixed-Register Multiplication and Division Instructions.
  42 //
  43
  44 // Extra precision multiplication
  45
  46 // AL is really implied by AX, but the registers in Defs must match the
  47 // SDNode results (i8, i32).
  48 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  49 def MUL8r  : I<0xF6, MRM4r, (outs),  (ins GR8:$src), "mul{b}\t$src",
  50                // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
  51                // This probably ought to be moved to a def : Pat<> if the
  52                // syntax can be accepted.
  53                [(set AL, (mul AL, GR8:$src)),
  54                 (implicit EFLAGS)]>;     // AL,AH = AL*GR8
  55
  56 let Defs = [AX,DX,EFLAGS], Uses = [AX], neverHasSideEffects = 1 in
  57 def MUL16r : I<0xF7, MRM4r, (outs),  (ins GR16:$src),
  58                "mul{w}\t$src",
  59                []>, OpSize;    // AX,DX = AX*GR16
  60
  61 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX], neverHasSideEffects = 1 in
  62 def MUL32r : I<0xF7, MRM4r, (outs),  (ins GR32:$src),
  63                "mul{l}\t$src",
  64                []>; // EAX,EDX = EAX*GR32
  65
  66 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  67 def MUL8m  : I<0xF6, MRM4m, (outs), (ins i8mem :$src),
  68                "mul{b}\t$src",
  69                // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
  70                // This probably ought to be moved to a def : Pat<> if the
  71                // syntax can be accepted.
  72                [(set AL, (mul AL, (loadi8 addr:$src))),
  73                 (implicit EFLAGS)]>;   // AL,AH = AL*[mem8]
  74
  75 let mayLoad = 1, neverHasSideEffects = 1 in {
  76 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
  77 def MUL16m : I<0xF7, MRM4m, (outs), (ins i16mem:$src),
  78                "mul{w}\t$src",
  79                []>, OpSize; // AX,DX = AX*[mem16]
  80
  81 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
  82 def MUL32m : I<0xF7, MRM4m, (outs), (ins i32mem:$src),
  83               "mul{l}\t$src",
  84               []>;          // EAX,EDX = EAX*[mem32]
  85 }
  86
  87 let neverHasSideEffects = 1 in {
  88 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  89 def IMUL8r  : I<0xF6, MRM5r, (outs),  (ins GR8:$src), "imul{b}\t$src", []>;
  90               // AL,AH = AL*GR8
  91 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
  92 def IMUL16r : I<0xF7, MRM5r, (outs),  (ins GR16:$src), "imul{w}\t$src", []>,
  93               OpSize;    // AX,DX = AX*GR16
  94 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
  95 def IMUL32r : I<0xF7, MRM5r, (outs),  (ins GR32:$src), "imul{l}\t$src", []>;
  96               // EAX,EDX = EAX*GR32
  97 let mayLoad = 1 in {
  98 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  99 def IMUL8m  : I<0xF6, MRM5m, (outs), (ins i8mem :$src),
 100                 "imul{b}\t$src", []>;    // AL,AH = AL*[mem8]
 101 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
 102 def IMUL16m : I<0xF7, MRM5m, (outs), (ins i16mem:$src),
 103                 "imul{w}\t$src", []>, OpSize; // AX,DX = AX*[mem16]
 104 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
 105 def IMUL32m : I<0xF7, MRM5m, (outs), (ins i32mem:$src),
 106                 "imul{l}\t$src", []>;  // EAX,EDX = EAX*[mem32]
 107 }
 108 } // neverHasSideEffects
 109
 110 // unsigned division/remainder
 111 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 112 def DIV8r  : I<0xF6, MRM6r, (outs),  (ins GR8:$src),    // AX/r8 = AL,AH
 113                "div{b}\t$src", []>;
 114 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 115 def DIV16r : I<0xF7, MRM6r, (outs),  (ins GR16:$src),   // DX:AX/r16 = AX,DX
 116                "div{w}\t$src", []>, OpSize;
 117 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 118 def DIV32r : I<0xF7, MRM6r, (outs),  (ins GR32:$src),   // EDX:EAX/r32 = EAX,EDX
 119                "div{l}\t$src", []>;
 120 let mayLoad = 1 in {
 121 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 122 def DIV8m  : I<0xF6, MRM6m, (outs), (ins i8mem:$src),   // AX/[mem8] = AL,AH
 123                "div{b}\t$src", []>;
 124 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 125 def DIV16m : I<0xF7, MRM6m, (outs), (ins i16mem:$src),  // DX:AX/[mem16] = AX,DX
 126                "div{w}\t$src", []>, OpSize;
 127 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 128                                                     // EDX:EAX/[mem32] = EAX,EDX
 129 def DIV32m : I<0xF7, MRM6m, (outs), (ins i32mem:$src),
 130                "div{l}\t$src", []>;
 131 }
 132
 133 // Signed division/remainder.
 134 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 135 def IDIV8r : I<0xF6, MRM7r, (outs),  (ins GR8:$src),    // AX/r8 = AL,AH
 136                "idiv{b}\t$src", []>;
 137 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 138 def IDIV16r: I<0xF7, MRM7r, (outs),  (ins GR16:$src),   // DX:AX/r16 = AX,DX
 139                "idiv{w}\t$src", []>, OpSize;
 140 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 141 def IDIV32r: I<0xF7, MRM7r, (outs),  (ins GR32:$src),   // EDX:EAX/r32 = EAX,EDX
 142                "idiv{l}\t$src", []>;
 143 let mayLoad = 1, mayLoad = 1 in {
 144 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 145 def IDIV8m : I<0xF6, MRM7m, (outs), (ins i8mem:$src),   // AX/[mem8] = AL,AH
 146                "idiv{b}\t$src", []>;
 147 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 148 def IDIV16m: I<0xF7, MRM7m, (outs), (ins i16mem:$src),  // DX:AX/[mem16] = AX,DX
 149                "idiv{w}\t$src", []>, OpSize;
 150 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 151 def IDIV32m: I<0xF7, MRM7m, (outs), (ins i32mem:$src),
 152                                                     // EDX:EAX/[mem32] = EAX,EDX
 153                "idiv{l}\t$src", []>;
 154 }
 155
 156 //===----------------------------------------------------------------------===//
 157 //  Two address Instructions.
 158 //
 159 let Constraints = "$src1 = $dst" in {
 160
 161 // unary instructions
 162 let CodeSize = 2 in {
 163 let Defs = [EFLAGS] in {
 164 def NEG8r  : I<0xF6, MRM3r, (outs GR8 :$dst), (ins GR8 :$src1),
 165                "neg{b}\t$dst",
 166                [(set GR8:$dst, (ineg GR8:$src1)),
 167                 (implicit EFLAGS)]>;
 168 def NEG16r : I<0xF7, MRM3r, (outs GR16:$dst), (ins GR16:$src1),
 169                "neg{w}\t$dst",
 170                [(set GR16:$dst, (ineg GR16:$src1)),
 171                 (implicit EFLAGS)]>, OpSize;
 172 def NEG32r : I<0xF7, MRM3r, (outs GR32:$dst), (ins GR32:$src1),
 173                "neg{l}\t$dst",
 174                [(set GR32:$dst, (ineg GR32:$src1)),
 175                 (implicit EFLAGS)]>;
 176
 177 let Constraints = "" in {
 178   def NEG8m  : I<0xF6, MRM3m, (outs), (ins i8mem :$dst),
 179                  "neg{b}\t$dst",
 180                  [(store (ineg (loadi8 addr:$dst)), addr:$dst),
 181                   (implicit EFLAGS)]>;
 182   def NEG16m : I<0xF7, MRM3m, (outs), (ins i16mem:$dst),
 183                  "neg{w}\t$dst",
 184                  [(store (ineg (loadi16 addr:$dst)), addr:$dst),
 185                   (implicit EFLAGS)]>, OpSize;
 186   def NEG32m : I<0xF7, MRM3m, (outs), (ins i32mem:$dst),
 187                  "neg{l}\t$dst",
 188                  [(store (ineg (loadi32 addr:$dst)), addr:$dst),
 189                   (implicit EFLAGS)]>;
 190 } // Constraints = ""
 191 } // Defs = [EFLAGS]
 192
 193 // Match xor -1 to not. Favors these over a move imm + xor to save code size.
 194 let AddedComplexity = 15 in {
 195 def NOT8r  : I<0xF6, MRM2r, (outs GR8 :$dst), (ins GR8 :$src1),
 196                "not{b}\t$dst",
 197                [(set GR8:$dst, (not GR8:$src1))]>;
 198 def NOT16r : I<0xF7, MRM2r, (outs GR16:$dst), (ins GR16:$src1),
 199                "not{w}\t$dst",
 200                [(set GR16:$dst, (not GR16:$src1))]>, OpSize;
 201 def NOT32r : I<0xF7, MRM2r, (outs GR32:$dst), (ins GR32:$src1),
 202                "not{l}\t$dst",
 203                [(set GR32:$dst, (not GR32:$src1))]>;
 204 }
 205 let Constraints = "" in {
 206   def NOT8m  : I<0xF6, MRM2m, (outs), (ins i8mem :$dst),
 207                  "not{b}\t$dst",
 208                  [(store (not (loadi8 addr:$dst)), addr:$dst)]>;
 209   def NOT16m : I<0xF7, MRM2m, (outs), (ins i16mem:$dst),
 210                  "not{w}\t$dst",
 211                  [(store (not (loadi16 addr:$dst)), addr:$dst)]>, OpSize;
 212   def NOT32m : I<0xF7, MRM2m, (outs), (ins i32mem:$dst),
 213                  "not{l}\t$dst",
 214                  [(store (not (loadi32 addr:$dst)), addr:$dst)]>;
 215 } // Constraints = ""
 216 } // CodeSize
 217
 218 // TODO: inc/dec is slow for P4, but fast for Pentium-M.
 219 let Defs = [EFLAGS] in {
 220 let CodeSize = 2 in
 221 def INC8r  : I<0xFE, MRM0r, (outs GR8 :$dst), (ins GR8 :$src1),
 222                "inc{b}\t$dst",
 223                [(set GR8:$dst, EFLAGS, (X86inc_flag GR8:$src1))]>;
 224
 225 let isConvertibleToThreeAddress = 1, CodeSize = 1 in {  // Can xform into LEA.
 226 def INC16r : I<0x40, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 227                "inc{w}\t$dst",
 228                [(set GR16:$dst, EFLAGS, (X86inc_flag GR16:$src1))]>,
 229              OpSize, Requires<[In32BitMode]>;
 230 def INC32r : I<0x40, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 231                "inc{l}\t$dst",
 232                [(set GR32:$dst, EFLAGS, (X86inc_flag GR32:$src1))]>,
 233              Requires<[In32BitMode]>;
 234 }
 235 let Constraints = "", CodeSize = 2 in {
 236   def INC8m  : I<0xFE, MRM0m, (outs), (ins i8mem :$dst), "inc{b}\t$dst",
 237                [(store (add (loadi8 addr:$dst), 1), addr:$dst),
 238                 (implicit EFLAGS)]>;
 239   def INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
 240                [(store (add (loadi16 addr:$dst), 1), addr:$dst),
 241                 (implicit EFLAGS)]>,
 242                OpSize, Requires<[In32BitMode]>;
 243   def INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
 244                [(store (add (loadi32 addr:$dst), 1), addr:$dst),
 245                 (implicit EFLAGS)]>,
 246                Requires<[In32BitMode]>;
 247 } // Constraints = "", CodeSize = 2
 248
 249 let CodeSize = 2 in
 250 def DEC8r  : I<0xFE, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
 251                "dec{b}\t$dst",
 252                [(set GR8:$dst, EFLAGS, (X86dec_flag GR8:$src1))]>;
 253 let isConvertibleToThreeAddress = 1, CodeSize = 1 in {   // Can xform into LEA.
 254 def DEC16r : I<0x48, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 255                "dec{w}\t$dst",
 256                [(set GR16:$dst, EFLAGS, (X86dec_flag GR16:$src1))]>,
 257              OpSize, Requires<[In32BitMode]>;
 258 def DEC32r : I<0x48, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 259                "dec{l}\t$dst",
 260                [(set GR32:$dst, EFLAGS, (X86dec_flag GR32:$src1))]>,
 261              Requires<[In32BitMode]>;
 262 } // CodeSize = 2
 263
 264 let Constraints = "", CodeSize = 2 in {
 265   def DEC8m  : I<0xFE, MRM1m, (outs), (ins i8mem :$dst), "dec{b}\t$dst",
 266                [(store (add (loadi8 addr:$dst), -1), addr:$dst),
 267                 (implicit EFLAGS)]>;
 268   def DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
 269                [(store (add (loadi16 addr:$dst), -1), addr:$dst),
 270                 (implicit EFLAGS)]>,
 271                OpSize, Requires<[In32BitMode]>;
 272   def DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
 273                [(store (add (loadi32 addr:$dst), -1), addr:$dst),
 274                 (implicit EFLAGS)]>,
 275                Requires<[In32BitMode]>;
 276 } // Constraints = "", CodeSize = 2
 277 } // Defs = [EFLAGS]
 278
 279 // Logical operators...
 280 let Defs = [EFLAGS] in {
 281 let isCommutable = 1 in {   // X = AND Y, Z   --> X = AND Z, Y
 282 def AND8rr  : I<0x20, MRMDestReg,
 283                (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
 284                "and{b}\t{$src2, $dst|$dst, $src2}",
 285                [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1, GR8:$src2))]>;
 286 def AND16rr : I<0x21, MRMDestReg,
 287                 (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
 288                 "and{w}\t{$src2, $dst|$dst, $src2}",
 289                 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 290                                                       GR16:$src2))]>, OpSize;
 291 def AND32rr : I<0x21, MRMDestReg,
 292                 (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
 293                 "and{l}\t{$src2, $dst|$dst, $src2}",
 294                 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 295                                                       GR32:$src2))]>;
 296 }
 297
 298 // AND instructions with the destination register in REG and the source register
 299 //   in R/M.  Included for the disassembler.
 300 let isCodeGenOnly = 1 in {
 301 def AND8rr_REV : I<0x22, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 302                   "and{b}\t{$src2, $dst|$dst, $src2}", []>;
 303 def AND16rr_REV : I<0x23, MRMSrcReg, (outs GR16:$dst),
 304                     (ins GR16:$src1, GR16:$src2),
 305                    "and{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 306 def AND32rr_REV : I<0x23, MRMSrcReg, (outs GR32:$dst),
 307                     (ins GR32:$src1, GR32:$src2),
 308                    "and{l}\t{$src2, $dst|$dst, $src2}", []>;
 309 }
 310
 311 def AND8rm   : I<0x22, MRMSrcMem,
 312                  (outs GR8 :$dst), (ins GR8 :$src1, i8mem :$src2),
 313                  "and{b}\t{$src2, $dst|$dst, $src2}",
 314                 [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
 315                                                      (loadi8 addr:$src2)))]>;
 316 def AND16rm  : I<0x23, MRMSrcMem,
 317                  (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
 318                  "and{w}\t{$src2, $dst|$dst, $src2}",
 319                 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 320                                                       (loadi16 addr:$src2)))]>,
 321                OpSize;
 322 def AND32rm  : I<0x23, MRMSrcMem,
 323                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
 324                  "and{l}\t{$src2, $dst|$dst, $src2}",
 325                 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 326                                                       (loadi32 addr:$src2)))]>;
 327
 328 def AND8ri   : Ii8<0x80, MRM4r,
 329                    (outs GR8 :$dst), (ins GR8 :$src1, i8imm :$src2),
 330                    "and{b}\t{$src2, $dst|$dst, $src2}",
 331                    [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
 332                                                         imm:$src2))]>;
 333 def AND16ri  : Ii16<0x81, MRM4r,
 334                     (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 335                     "and{w}\t{$src2, $dst|$dst, $src2}",
 336                     [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 337                                                           imm:$src2))]>, OpSize;
 338 def AND32ri  : Ii32<0x81, MRM4r,
 339                     (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 340                     "and{l}\t{$src2, $dst|$dst, $src2}",
 341                     [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 342                                                           imm:$src2))]>;
 343 def AND16ri8 : Ii8<0x83, MRM4r,
 344                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 345                    "and{w}\t{$src2, $dst|$dst, $src2}",
 346                    [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 347                                                          i16immSExt8:$src2))]>,
 348                    OpSize;
 349 def AND32ri8 : Ii8<0x83, MRM4r,
 350                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 351                    "and{l}\t{$src2, $dst|$dst, $src2}",
 352                    [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 353                                                          i32immSExt8:$src2))]>;
 354
 355 let Constraints = "" in {
 356   def AND8mr   : I<0x20, MRMDestMem,
 357                    (outs), (ins i8mem :$dst, GR8 :$src),
 358                    "and{b}\t{$src, $dst|$dst, $src}",
 359                    [(store (and (load addr:$dst), GR8:$src), addr:$dst),
 360                     (implicit EFLAGS)]>;
 361   def AND16mr  : I<0x21, MRMDestMem,
 362                    (outs), (ins i16mem:$dst, GR16:$src),
 363                    "and{w}\t{$src, $dst|$dst, $src}",
 364                    [(store (and (load addr:$dst), GR16:$src), addr:$dst),
 365                     (implicit EFLAGS)]>,
 366                    OpSize;
 367   def AND32mr  : I<0x21, MRMDestMem,
 368                    (outs), (ins i32mem:$dst, GR32:$src),
 369                    "and{l}\t{$src, $dst|$dst, $src}",
 370                    [(store (and (load addr:$dst), GR32:$src), addr:$dst),
 371                     (implicit EFLAGS)]>;
 372   def AND8mi   : Ii8<0x80, MRM4m,
 373                      (outs), (ins i8mem :$dst, i8imm :$src),
 374                      "and{b}\t{$src, $dst|$dst, $src}",
 375                       [(store (and (loadi8 addr:$dst), imm:$src), addr:$dst),
 376                        (implicit EFLAGS)]>;
 377   def AND16mi  : Ii16<0x81, MRM4m,
 378                       (outs), (ins i16mem:$dst, i16imm:$src),
 379                       "and{w}\t{$src, $dst|$dst, $src}",
 380                       [(store (and (loadi16 addr:$dst), imm:$src), addr:$dst),
 381                        (implicit EFLAGS)]>,
 382                       OpSize;
 383   def AND32mi  : Ii32<0x81, MRM4m,
 384                       (outs), (ins i32mem:$dst, i32imm:$src),
 385                       "and{l}\t{$src, $dst|$dst, $src}",
 386                       [(store (and (loadi32 addr:$dst), imm:$src), addr:$dst),
 387                        (implicit EFLAGS)]>;
 388   def AND16mi8 : Ii8<0x83, MRM4m,
 389                      (outs), (ins i16mem:$dst, i16i8imm :$src),
 390                      "and{w}\t{$src, $dst|$dst, $src}",
 391                 [(store (and (load addr:$dst), i16immSExt8:$src), addr:$dst),
 392                  (implicit EFLAGS)]>,
 393                      OpSize;
 394   def AND32mi8 : Ii8<0x83, MRM4m,
 395                      (outs), (ins i32mem:$dst, i32i8imm :$src),
 396                      "and{l}\t{$src, $dst|$dst, $src}",
 397                 [(store (and (load addr:$dst), i32immSExt8:$src), addr:$dst),
 398                  (implicit EFLAGS)]>;
 399
 400   def AND8i8 : Ii8<0x24, RawFrm, (outs), (ins i8imm:$src),
 401                    "and{b}\t{$src, %al|%al, $src}", []>;
 402   def AND16i16 : Ii16<0x25, RawFrm, (outs), (ins i16imm:$src),
 403                       "and{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 404   def AND32i32 : Ii32<0x25, RawFrm, (outs), (ins i32imm:$src),
 405                       "and{l}\t{$src, %eax|%eax, $src}", []>;
 406
 407 } // Constraints = ""
 408
 409
 410 let isCommutable = 1 in {   // X = OR Y, Z   --> X = OR Z, Y
 411 def OR8rr    : I<0x08, MRMDestReg, (outs GR8 :$dst),
 412                  (ins GR8 :$src1, GR8 :$src2),
 413                  "or{b}\t{$src2, $dst|$dst, $src2}",
 414                  [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1, GR8:$src2))]>;
 415 def OR16rr   : I<0x09, MRMDestReg, (outs GR16:$dst),
 416                  (ins GR16:$src1, GR16:$src2),
 417                  "or{w}\t{$src2, $dst|$dst, $src2}",
 418                  [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,GR16:$src2))]>,
 419                OpSize;
 420 def OR32rr   : I<0x09, MRMDestReg, (outs GR32:$dst),
 421                  (ins GR32:$src1, GR32:$src2),
 422                  "or{l}\t{$src2, $dst|$dst, $src2}",
 423                  [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,GR32:$src2))]>;
 424 }
 425
 426 // OR instructions with the destination register in REG and the source register
 427 //   in R/M.  Included for the disassembler.
 428 let isCodeGenOnly = 1 in {
 429 def OR8rr_REV : I<0x0A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 430                   "or{b}\t{$src2, $dst|$dst, $src2}", []>;
 431 def OR16rr_REV : I<0x0B, MRMSrcReg, (outs GR16:$dst),
 432                    (ins GR16:$src1, GR16:$src2),
 433                    "or{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 434 def OR32rr_REV : I<0x0B, MRMSrcReg, (outs GR32:$dst),
 435                    (ins GR32:$src1, GR32:$src2),
 436                    "or{l}\t{$src2, $dst|$dst, $src2}", []>;
 437 }
 438
 439 def OR8rm    : I<0x0A, MRMSrcMem, (outs GR8 :$dst),
 440                  (ins GR8 :$src1, i8mem :$src2),
 441                  "or{b}\t{$src2, $dst|$dst, $src2}",
 442                 [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1,
 443                                                     (load addr:$src2)))]>;
 444 def OR16rm   : I<0x0B, MRMSrcMem, (outs GR16:$dst),
 445                  (ins GR16:$src1, i16mem:$src2),
 446                  "or{w}\t{$src2, $dst|$dst, $src2}",
 447                 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 448                                                      (load addr:$src2)))]>,
 449                OpSize;
 450 def OR32rm   : I<0x0B, MRMSrcMem, (outs GR32:$dst),
 451                  (ins GR32:$src1, i32mem:$src2),
 452                  "or{l}\t{$src2, $dst|$dst, $src2}",
 453                 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 454                                                      (load addr:$src2)))]>;
 455
 456 def OR8ri    : Ii8 <0x80, MRM1r, (outs GR8 :$dst),
 457                     (ins GR8 :$src1, i8imm:$src2),
 458                     "or{b}\t{$src2, $dst|$dst, $src2}",
 459                     [(set GR8:$dst,EFLAGS, (X86or_flag GR8:$src1, imm:$src2))]>;
 460 def OR16ri   : Ii16<0x81, MRM1r, (outs GR16:$dst),
 461                     (ins GR16:$src1, i16imm:$src2),
 462                     "or{w}\t{$src2, $dst|$dst, $src2}",
 463                     [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 464                                                         imm:$src2))]>, OpSize;
 465 def OR32ri   : Ii32<0x81, MRM1r, (outs GR32:$dst),
 466                     (ins GR32:$src1, i32imm:$src2),
 467                     "or{l}\t{$src2, $dst|$dst, $src2}",
 468                     [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 469                                                          imm:$src2))]>;
 470
 471 def OR16ri8  : Ii8<0x83, MRM1r, (outs GR16:$dst),
 472                    (ins GR16:$src1, i16i8imm:$src2),
 473                    "or{w}\t{$src2, $dst|$dst, $src2}",
 474                    [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 475                                                 i16immSExt8:$src2))]>, OpSize;
 476 def OR32ri8  : Ii8<0x83, MRM1r, (outs GR32:$dst),
 477                    (ins GR32:$src1, i32i8imm:$src2),
 478                    "or{l}\t{$src2, $dst|$dst, $src2}",
 479                    [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 480                                                         i32immSExt8:$src2))]>;
 481 let Constraints = "" in {
 482   def OR8mr  : I<0x08, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
 483                  "or{b}\t{$src, $dst|$dst, $src}",
 484                  [(store (or (load addr:$dst), GR8:$src), addr:$dst),
 485                   (implicit EFLAGS)]>;
 486   def OR16mr : I<0x09, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
 487                  "or{w}\t{$src, $dst|$dst, $src}",
 488                  [(store (or (load addr:$dst), GR16:$src), addr:$dst),
 489                   (implicit EFLAGS)]>, OpSize;
 490   def OR32mr : I<0x09, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
 491                  "or{l}\t{$src, $dst|$dst, $src}",
 492                  [(store (or (load addr:$dst), GR32:$src), addr:$dst),
 493                   (implicit EFLAGS)]>;
 494   def OR8mi    : Ii8<0x80, MRM1m, (outs), (ins i8mem :$dst, i8imm:$src),
 495                  "or{b}\t{$src, $dst|$dst, $src}",
 496                  [(store (or (loadi8 addr:$dst), imm:$src), addr:$dst),
 497                   (implicit EFLAGS)]>;
 498   def OR16mi   : Ii16<0x81, MRM1m, (outs), (ins i16mem:$dst, i16imm:$src),
 499                  "or{w}\t{$src, $dst|$dst, $src}",
 500                  [(store (or (loadi16 addr:$dst), imm:$src), addr:$dst),
 501                   (implicit EFLAGS)]>,
 502                  OpSize;
 503   def OR32mi   : Ii32<0x81, MRM1m, (outs), (ins i32mem:$dst, i32imm:$src),
 504                  "or{l}\t{$src, $dst|$dst, $src}",
 505                  [(store (or (loadi32 addr:$dst), imm:$src), addr:$dst),
 506                   (implicit EFLAGS)]>;
 507   def OR16mi8  : Ii8<0x83, MRM1m, (outs), (ins i16mem:$dst, i16i8imm:$src),
 508                  "or{w}\t{$src, $dst|$dst, $src}",
 509                  [(store (or (load addr:$dst), i16immSExt8:$src), addr:$dst),
 510                   (implicit EFLAGS)]>,
 511                      OpSize;
 512   def OR32mi8  : Ii8<0x83, MRM1m, (outs), (ins i32mem:$dst, i32i8imm:$src),
 513                  "or{l}\t{$src, $dst|$dst, $src}",
 514                  [(store (or (load addr:$dst), i32immSExt8:$src), addr:$dst),
 515                   (implicit EFLAGS)]>;
 516
 517   def OR8i8 : Ii8 <0x0C, RawFrm, (outs), (ins i8imm:$src),
 518                    "or{b}\t{$src, %al|%al, $src}", []>;
 519   def OR16i16 : Ii16 <0x0D, RawFrm, (outs), (ins i16imm:$src),
 520                       "or{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 521   def OR32i32 : Ii32 <0x0D, RawFrm, (outs), (ins i32imm:$src),
 522                       "or{l}\t{$src, %eax|%eax, $src}", []>;
 523 } // Constraints = ""
 524
 525
 526 let isCommutable = 1 in { // X = XOR Y, Z --> X = XOR Z, Y
 527   def XOR8rr   : I<0x30, MRMDestReg,
 528                    (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
 529                    "xor{b}\t{$src2, $dst|$dst, $src2}",
 530                    [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
 531                                                         GR8:$src2))]>;
 532   def XOR16rr  : I<0x31, MRMDestReg,
 533                    (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
 534                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 535                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 536                                                          GR16:$src2))]>, OpSize;
 537   def XOR32rr  : I<0x31, MRMDestReg,
 538                    (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
 539                    "xor{l}\t{$src2, $dst|$dst, $src2}",
 540                    [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 541                                                          GR32:$src2))]>;
 542 } // isCommutable = 1
 543
 544 // XOR instructions with the destination register in REG and the source register
 545 //   in R/M.  Included for the disassembler.
 546 let isCodeGenOnly = 1 in {
 547 def XOR8rr_REV : I<0x32, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 548                   "xor{b}\t{$src2, $dst|$dst, $src2}", []>;
 549 def XOR16rr_REV : I<0x33, MRMSrcReg, (outs GR16:$dst),
 550                     (ins GR16:$src1, GR16:$src2),
 551                    "xor{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 552 def XOR32rr_REV : I<0x33, MRMSrcReg, (outs GR32:$dst),
 553                     (ins GR32:$src1, GR32:$src2),
 554                    "xor{l}\t{$src2, $dst|$dst, $src2}", []>;
 555 }
 556
 557 def XOR8rm   : I<0x32, MRMSrcMem,
 558                  (outs GR8 :$dst), (ins GR8:$src1, i8mem :$src2),
 559                  "xor{b}\t{$src2, $dst|$dst, $src2}",
 560                  [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
 561                                                       (load addr:$src2)))]>;
 562 def XOR16rm  : I<0x33, MRMSrcMem,
 563                  (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
 564                  "xor{w}\t{$src2, $dst|$dst, $src2}",
 565                  [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 566                                                        (load addr:$src2)))]>,
 567                  OpSize;
 568 def XOR32rm  : I<0x33, MRMSrcMem,
 569                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
 570                  "xor{l}\t{$src2, $dst|$dst, $src2}",
 571                  [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 572                                                        (load addr:$src2)))]>;
 573
 574 def XOR8ri  : Ii8<0x80, MRM6r,
 575                   (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
 576                   "xor{b}\t{$src2, $dst|$dst, $src2}",
 577                   [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1, imm:$src2))]>;
 578 def XOR16ri : Ii16<0x81, MRM6r,
 579                    (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 580                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 581                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 582                                                          imm:$src2))]>, OpSize;
 583 def XOR32ri  : Ii32<0x81, MRM6r,
 584                     (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 585                     "xor{l}\t{$src2, $dst|$dst, $src2}",
 586                     [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 587                                                           imm:$src2))]>;
 588 def XOR16ri8 : Ii8<0x83, MRM6r,
 589                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 590                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 591                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 592                                                          i16immSExt8:$src2))]>,
 593                    OpSize;
 594 def XOR32ri8 : Ii8<0x83, MRM6r,
 595                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 596                    "xor{l}\t{$src2, $dst|$dst, $src2}",
 597                    [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 598                                                          i32immSExt8:$src2))]>;
 599
 600 let Constraints = "" in {
 601   def XOR8mr   : I<0x30, MRMDestMem,
 602                    (outs), (ins i8mem :$dst, GR8 :$src),
 603                    "xor{b}\t{$src, $dst|$dst, $src}",
 604                    [(store (xor (load addr:$dst), GR8:$src), addr:$dst),
 605                     (implicit EFLAGS)]>;
 606   def XOR16mr  : I<0x31, MRMDestMem,
 607                    (outs), (ins i16mem:$dst, GR16:$src),
 608                    "xor{w}\t{$src, $dst|$dst, $src}",
 609                    [(store (xor (load addr:$dst), GR16:$src), addr:$dst),
 610                     (implicit EFLAGS)]>,
 611                    OpSize;
 612   def XOR32mr  : I<0x31, MRMDestMem,
 613                    (outs), (ins i32mem:$dst, GR32:$src),
 614                    "xor{l}\t{$src, $dst|$dst, $src}",
 615                    [(store (xor (load addr:$dst), GR32:$src), addr:$dst),
 616                     (implicit EFLAGS)]>;
 617   def XOR8mi   : Ii8<0x80, MRM6m,
 618                      (outs), (ins i8mem :$dst, i8imm :$src),
 619                      "xor{b}\t{$src, $dst|$dst, $src}",
 620                     [(store (xor (loadi8 addr:$dst), imm:$src), addr:$dst),
 621                      (implicit EFLAGS)]>;
 622   def XOR16mi  : Ii16<0x81, MRM6m,
 623                       (outs), (ins i16mem:$dst, i16imm:$src),
 624                       "xor{w}\t{$src, $dst|$dst, $src}",
 625                    [(store (xor (loadi16 addr:$dst), imm:$src), addr:$dst),
 626                     (implicit EFLAGS)]>,
 627                       OpSize;
 628   def XOR32mi  : Ii32<0x81, MRM6m,
 629                       (outs), (ins i32mem:$dst, i32imm:$src),
 630                       "xor{l}\t{$src, $dst|$dst, $src}",
 631                    [(store (xor (loadi32 addr:$dst), imm:$src), addr:$dst),
 632                     (implicit EFLAGS)]>;
 633   def XOR16mi8 : Ii8<0x83, MRM6m,
 634                      (outs), (ins i16mem:$dst, i16i8imm :$src),
 635                      "xor{w}\t{$src, $dst|$dst, $src}",
 636                  [(store (xor (load addr:$dst), i16immSExt8:$src), addr:$dst),
 637                   (implicit EFLAGS)]>,
 638                      OpSize;
 639   def XOR32mi8 : Ii8<0x83, MRM6m,
 640                      (outs), (ins i32mem:$dst, i32i8imm :$src),
 641                      "xor{l}\t{$src, $dst|$dst, $src}",
 642                  [(store (xor (load addr:$dst), i32immSExt8:$src), addr:$dst),
 643                   (implicit EFLAGS)]>;
 644
 645   def XOR8i8   : Ii8 <0x34, RawFrm, (outs), (ins i8imm:$src),
 646                       "xor{b}\t{$src, %al|%al, $src}", []>;
 647   def XOR16i16 : Ii16<0x35, RawFrm, (outs), (ins i16imm:$src),
 648                       "xor{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 649   def XOR32i32 : Ii32<0x35, RawFrm, (outs), (ins i32imm:$src),
 650                       "xor{l}\t{$src, %eax|%eax, $src}", []>;
 651 } // Constraints = ""
 652 } // Defs = [EFLAGS]
 653
 654
 655 // Arithmetic.
 656 let Defs = [EFLAGS] in {
 657 let isCommutable = 1 in {   // X = ADD Y, Z   --> X = ADD Z, Y
 658 // Register-Register Addition
 659 def ADD8rr    : I<0x00, MRMDestReg, (outs GR8 :$dst),
 660                                     (ins GR8 :$src1, GR8 :$src2),
 661                   "add{b}\t{$src2, $dst|$dst, $src2}",
 662                   [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1, GR8:$src2))]>;
 663
 664 let isConvertibleToThreeAddress = 1 in {   // Can transform into LEA.
 665 // Register-Register Addition
 666 def ADD16rr  : I<0x01, MRMDestReg, (outs GR16:$dst),
 667                                    (ins GR16:$src1, GR16:$src2),
 668                  "add{w}\t{$src2, $dst|$dst, $src2}",
 669                  [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
 670                                                        GR16:$src2))]>, OpSize;
 671 def ADD32rr  : I<0x01, MRMDestReg, (outs GR32:$dst),
 672                                    (ins GR32:$src1, GR32:$src2),
 673                  "add{l}\t{$src2, $dst|$dst, $src2}",
 674                  [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
 675                                                        GR32:$src2))]>;
 676 } // end isConvertibleToThreeAddress
 677 } // end isCommutable
 678
 679 // These are alternate spellings for use by the disassembler, we mark them as
 680 // code gen only to ensure they aren't matched by the assembler.
 681 let isCodeGenOnly = 1 in {
 682   def ADD8rr_alt: I<0x02, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 683                    "add{b}\t{$src2, $dst|$dst, $src2}", []>;
 684   def ADD16rr_alt: I<0x03, MRMSrcReg,(outs GR16:$dst),(ins GR16:$src1, GR16:$src2),
 685                     "add{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 686   def ADD32rr_alt: I<0x03, MRMSrcReg,(outs GR32:$dst),(ins GR32:$src1, GR32:$src2),
 687                     "add{l}\t{$src2, $dst|$dst, $src2}", []>;
 688 }
 689
 690 // Register-Memory Addition
 691 def ADD8rm   : I<0x02, MRMSrcMem, (outs GR8 :$dst),
 692                                   (ins GR8 :$src1, i8mem :$src2),
 693                  "add{b}\t{$src2, $dst|$dst, $src2}",
 694                  [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1,
 695                                                       (load addr:$src2)))]>;
 696 def ADD16rm  : I<0x03, MRMSrcMem, (outs GR16:$dst),
 697                                   (ins GR16:$src1, i16mem:$src2),
 698                  "add{w}\t{$src2, $dst|$dst, $src2}",
 699                  [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
 700                                                   (load addr:$src2)))]>, OpSize;
 701 def ADD32rm  : I<0x03, MRMSrcMem, (outs GR32:$dst),
 702                                   (ins GR32:$src1, i32mem:$src2),
 703                  "add{l}\t{$src2, $dst|$dst, $src2}",
 704                  [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
 705                                                        (load addr:$src2)))]>;
 706
 707 // Register-Integer Addition
 708 def ADD8ri    : Ii8<0x80, MRM0r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
 709                     "add{b}\t{$src2, $dst|$dst, $src2}",
 710                     [(set GR8:$dst, EFLAGS,
 711                           (X86add_flag GR8:$src1, imm:$src2))]>;
 712
 713 let isConvertibleToThreeAddress = 1 in {   // Can transform into LEA.
 714 // Register-Integer Addition
 715 def ADD16ri  : Ii16<0x81, MRM0r, (outs GR16:$dst),
 716                                  (ins GR16:$src1, i16imm:$src2),
 717                     "add{w}\t{$src2, $dst|$dst, $src2}",
 718                     [(set GR16:$dst, EFLAGS,
 719                           (X86add_flag GR16:$src1, imm:$src2))]>, OpSize;
 720 def ADD32ri  : Ii32<0x81, MRM0r, (outs GR32:$dst),
 721                                  (ins GR32:$src1, i32imm:$src2),
 722                     "add{l}\t{$src2, $dst|$dst, $src2}",
 723                     [(set GR32:$dst, EFLAGS,
 724                           (X86add_flag GR32:$src1, imm:$src2))]>;
 725 def ADD16ri8 : Ii8<0x83, MRM0r, (outs GR16:$dst),
 726                                 (ins GR16:$src1, i16i8imm:$src2),
 727                    "add{w}\t{$src2, $dst|$dst, $src2}",
 728                    [(set GR16:$dst, EFLAGS,
 729                          (X86add_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
 730 def ADD32ri8 : Ii8<0x83, MRM0r, (outs GR32:$dst),
 731                                 (ins GR32:$src1, i32i8imm:$src2),
 732                    "add{l}\t{$src2, $dst|$dst, $src2}",
 733                    [(set GR32:$dst, EFLAGS,
 734                          (X86add_flag GR32:$src1, i32immSExt8:$src2))]>;
 735 }
 736
 737 let Constraints = "" in {
 738   // Memory-Register Addition
 739   def ADD8mr   : I<0x00, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
 740                    "add{b}\t{$src2, $dst|$dst, $src2}",
 741                    [(store (add (load addr:$dst), GR8:$src2), addr:$dst),
 742                     (implicit EFLAGS)]>;
 743   def ADD16mr  : I<0x01, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
 744                    "add{w}\t{$src2, $dst|$dst, $src2}",
 745                    [(store (add (load addr:$dst), GR16:$src2), addr:$dst),
 746                     (implicit EFLAGS)]>, OpSize;
 747   def ADD32mr  : I<0x01, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
 748                    "add{l}\t{$src2, $dst|$dst, $src2}",
 749                    [(store (add (load addr:$dst), GR32:$src2), addr:$dst),
 750                     (implicit EFLAGS)]>;
 751   def ADD8mi   : Ii8<0x80, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src2),
 752                      "add{b}\t{$src2, $dst|$dst, $src2}",
 753                    [(store (add (loadi8 addr:$dst), imm:$src2), addr:$dst),
 754                     (implicit EFLAGS)]>;
 755   def ADD16mi  : Ii16<0x81, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src2),
 756                       "add{w}\t{$src2, $dst|$dst, $src2}",
 757                   [(store (add (loadi16 addr:$dst), imm:$src2), addr:$dst),
 758                    (implicit EFLAGS)]>, OpSize;
 759   def ADD32mi  : Ii32<0x81, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src2),
 760                       "add{l}\t{$src2, $dst|$dst, $src2}",
 761                       [(store (add (loadi32 addr:$dst), imm:$src2), addr:$dst),
 762                        (implicit EFLAGS)]>;
 763   def ADD16mi8 : Ii8<0x83, MRM0m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
 764                      "add{w}\t{$src2, $dst|$dst, $src2}",
 765                      [(store (add (load addr:$dst), i16immSExt8:$src2),
 766                                   addr:$dst),
 767                       (implicit EFLAGS)]>, OpSize;
 768   def ADD32mi8 : Ii8<0x83, MRM0m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
 769                      "add{l}\t{$src2, $dst|$dst, $src2}",
 770                   [(store (add (load addr:$dst), i32immSExt8:$src2),
 771                                addr:$dst),
 772                    (implicit EFLAGS)]>;
 773
 774   // addition to rAX
 775   def ADD8i8 : Ii8<0x04, RawFrm, (outs), (ins i8imm:$src),
 776                    "add{b}\t{$src, %al|%al, $src}", []>;
 777   def ADD16i16 : Ii16<0x05, RawFrm, (outs), (ins i16imm:$src),
 778                       "add{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 779   def ADD32i32 : Ii32<0x05, RawFrm, (outs), (ins i32imm:$src),
 780                       "add{l}\t{$src, %eax|%eax, $src}", []>;
 781 } // Constraints = ""
 782
 783 let Uses = [EFLAGS] in {
 784 let isCommutable = 1 in {  // X = ADC Y, Z --> X = ADC Z, Y
 785 def ADC8rr   : I<0x10, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 786                  "adc{b}\t{$src2, $dst|$dst, $src2}",
 787                  [(set GR8:$dst, (adde GR8:$src1, GR8:$src2))]>;
 788 def ADC16rr  : I<0x11, MRMDestReg, (outs GR16:$dst),
 789                                    (ins GR16:$src1, GR16:$src2),
 790                  "adc{w}\t{$src2, $dst|$dst, $src2}",
 791                  [(set GR16:$dst, (adde GR16:$src1, GR16:$src2))]>, OpSize;
 792 def ADC32rr  : I<0x11, MRMDestReg, (outs GR32:$dst),
 793                                    (ins GR32:$src1, GR32:$src2),
 794                  "adc{l}\t{$src2, $dst|$dst, $src2}",
 795                  [(set GR32:$dst, (adde GR32:$src1, GR32:$src2))]>;
 796 }
 797
 798 let isCodeGenOnly = 1 in {
 799 def ADC8rr_REV : I<0x12, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 800                  "adc{b}\t{$src2, $dst|$dst, $src2}", []>;
 801 def ADC16rr_REV : I<0x13, MRMSrcReg, (outs GR16:$dst),
 802                     (ins GR16:$src1, GR16:$src2),
 803                     "adc{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 804 def ADC32rr_REV : I<0x13, MRMSrcReg, (outs GR32:$dst),
 805                     (ins GR32:$src1, GR32:$src2),
 806                     "adc{l}\t{$src2, $dst|$dst, $src2}", []>;
 807 }
 808
 809 def ADC8rm   : I<0x12, MRMSrcMem , (outs GR8:$dst),
 810                                    (ins GR8:$src1, i8mem:$src2),
 811                  "adc{b}\t{$src2, $dst|$dst, $src2}",
 812                  [(set GR8:$dst, (adde GR8:$src1, (load addr:$src2)))]>;
 813 def ADC16rm  : I<0x13, MRMSrcMem , (outs GR16:$dst),
 814                                    (ins GR16:$src1, i16mem:$src2),
 815                  "adc{w}\t{$src2, $dst|$dst, $src2}",
 816                  [(set GR16:$dst, (adde GR16:$src1, (load addr:$src2)))]>,
 817                  OpSize;
 818 def ADC32rm  : I<0x13, MRMSrcMem , (outs GR32:$dst),
 819                                    (ins GR32:$src1, i32mem:$src2),
 820                  "adc{l}\t{$src2, $dst|$dst, $src2}",
 821                  [(set GR32:$dst, (adde GR32:$src1, (load addr:$src2)))]>;
 822 def ADC8ri   : Ii8<0x80, MRM2r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
 823                     "adc{b}\t{$src2, $dst|$dst, $src2}",
 824                  [(set GR8:$dst, (adde GR8:$src1, imm:$src2))]>;
 825 def ADC16ri  : Ii16<0x81, MRM2r, (outs GR16:$dst),
 826                                  (ins GR16:$src1, i16imm:$src2),
 827                     "adc{w}\t{$src2, $dst|$dst, $src2}",
 828                  [(set GR16:$dst, (adde GR16:$src1, imm:$src2))]>, OpSize;
 829 def ADC16ri8 : Ii8<0x83, MRM2r, (outs GR16:$dst),
 830                                 (ins GR16:$src1, i16i8imm:$src2),
 831                    "adc{w}\t{$src2, $dst|$dst, $src2}",
 832                  [(set GR16:$dst, (adde GR16:$src1, i16immSExt8:$src2))]>,
 833                  OpSize;
 834 def ADC32ri  : Ii32<0x81, MRM2r, (outs GR32:$dst),
 835                                  (ins GR32:$src1, i32imm:$src2),
 836                     "adc{l}\t{$src2, $dst|$dst, $src2}",
 837                  [(set GR32:$dst, (adde GR32:$src1, imm:$src2))]>;
 838 def ADC32ri8 : Ii8<0x83, MRM2r, (outs GR32:$dst),
 839                                 (ins GR32:$src1, i32i8imm:$src2),
 840                    "adc{l}\t{$src2, $dst|$dst, $src2}",
 841                  [(set GR32:$dst, (adde GR32:$src1, i32immSExt8:$src2))]>;
 842
 843 let Constraints = "" in {
 844   def ADC8mr   : I<0x10, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
 845                    "adc{b}\t{$src2, $dst|$dst, $src2}",
 846                    [(store (adde (load addr:$dst), GR8:$src2), addr:$dst)]>;
 847   def ADC16mr  : I<0x11, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
 848                    "adc{w}\t{$src2, $dst|$dst, $src2}",
 849                    [(store (adde (load addr:$dst), GR16:$src2), addr:$dst)]>,
 850                    OpSize;
 851   def ADC32mr  : I<0x11, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
 852                    "adc{l}\t{$src2, $dst|$dst, $src2}",
 853                    [(store (adde (load addr:$dst), GR32:$src2), addr:$dst)]>;
 854   def ADC8mi   : Ii8<0x80, MRM2m, (outs), (ins i8mem:$dst, i8imm:$src2),
 855                       "adc{b}\t{$src2, $dst|$dst, $src2}",
 856                   [(store (adde (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
 857   def ADC16mi  : Ii16<0x81, MRM2m, (outs), (ins i16mem:$dst, i16imm:$src2),
 858                       "adc{w}\t{$src2, $dst|$dst, $src2}",
 859                   [(store (adde (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
 860                   OpSize;
 861   def ADC16mi8 : Ii8<0x83, MRM2m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
 862                      "adc{w}\t{$src2, $dst|$dst, $src2}",
 863                [(store (adde (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
 864                OpSize;
 865   def ADC32mi  : Ii32<0x81, MRM2m, (outs), (ins i32mem:$dst, i32imm:$src2),
 866                       "adc{l}\t{$src2, $dst|$dst, $src2}",
 867                   [(store (adde (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
 868   def ADC32mi8 : Ii8<0x83, MRM2m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
 869                      "adc{l}\t{$src2, $dst|$dst, $src2}",
 870                [(store (adde (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
 871
 872   def ADC8i8 : Ii8<0x14, RawFrm, (outs), (ins i8imm:$src),
 873                    "adc{b}\t{$src, %al|%al, $src}", []>;
 874   def ADC16i16 : Ii16<0x15, RawFrm, (outs), (ins i16imm:$src),
 875                       "adc{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 876   def ADC32i32 : Ii32<0x15, RawFrm, (outs), (ins i32imm:$src),
 877                       "adc{l}\t{$src, %eax|%eax, $src}", []>;
 878 } // Constraints = ""
 879 } // Uses = [EFLAGS]
 880
 881 // Register-Register Subtraction
 882 def SUB8rr  : I<0x28, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 883                 "sub{b}\t{$src2, $dst|$dst, $src2}",
 884                 [(set GR8:$dst, EFLAGS,
 885                       (X86sub_flag GR8:$src1, GR8:$src2))]>;
 886 def SUB16rr : I<0x29, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
 887                 "sub{w}\t{$src2, $dst|$dst, $src2}",
 888                 [(set GR16:$dst, EFLAGS,
 889                       (X86sub_flag GR16:$src1, GR16:$src2))]>, OpSize;
 890 def SUB32rr : I<0x29, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
 891                 "sub{l}\t{$src2, $dst|$dst, $src2}",
 892                 [(set GR32:$dst, EFLAGS,
 893                       (X86sub_flag GR32:$src1, GR32:$src2))]>;
 894
 895 let isCodeGenOnly = 1 in {
 896 def SUB8rr_REV : I<0x2A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 897                    "sub{b}\t{$src2, $dst|$dst, $src2}", []>;
 898 def SUB16rr_REV : I<0x2B, MRMSrcReg, (outs GR16:$dst),
 899                     (ins GR16:$src1, GR16:$src2),
 900                     "sub{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 901 def SUB32rr_REV : I<0x2B, MRMSrcReg, (outs GR32:$dst),
 902                     (ins GR32:$src1, GR32:$src2),
 903                     "sub{l}\t{$src2, $dst|$dst, $src2}", []>;
 904 }
 905
 906 // Register-Memory Subtraction
 907 def SUB8rm  : I<0x2A, MRMSrcMem, (outs GR8 :$dst),
 908                                  (ins GR8 :$src1, i8mem :$src2),
 909                 "sub{b}\t{$src2, $dst|$dst, $src2}",
 910                 [(set GR8:$dst, EFLAGS,
 911                       (X86sub_flag GR8:$src1, (load addr:$src2)))]>;
 912 def SUB16rm : I<0x2B, MRMSrcMem, (outs GR16:$dst),
 913                                  (ins GR16:$src1, i16mem:$src2),
 914                 "sub{w}\t{$src2, $dst|$dst, $src2}",
 915                 [(set GR16:$dst, EFLAGS,
 916                       (X86sub_flag GR16:$src1, (load addr:$src2)))]>, OpSize;
 917 def SUB32rm : I<0x2B, MRMSrcMem, (outs GR32:$dst),
 918                                  (ins GR32:$src1, i32mem:$src2),
 919                 "sub{l}\t{$src2, $dst|$dst, $src2}",
 920                 [(set GR32:$dst, EFLAGS,
 921                       (X86sub_flag GR32:$src1, (load addr:$src2)))]>;
 922
 923 // Register-Integer Subtraction
 924 def SUB8ri   : Ii8 <0x80, MRM5r, (outs GR8:$dst),
 925                                  (ins GR8:$src1, i8imm:$src2),
 926                     "sub{b}\t{$src2, $dst|$dst, $src2}",
 927                     [(set GR8:$dst, EFLAGS,
 928                           (X86sub_flag GR8:$src1, imm:$src2))]>;
 929 def SUB16ri  : Ii16<0x81, MRM5r, (outs GR16:$dst),
 930                                  (ins GR16:$src1, i16imm:$src2),
 931                     "sub{w}\t{$src2, $dst|$dst, $src2}",
 932                     [(set GR16:$dst, EFLAGS,
 933                           (X86sub_flag GR16:$src1, imm:$src2))]>, OpSize;
 934 def SUB32ri  : Ii32<0x81, MRM5r, (outs GR32:$dst),
 935                                  (ins GR32:$src1, i32imm:$src2),
 936                     "sub{l}\t{$src2, $dst|$dst, $src2}",
 937                     [(set GR32:$dst, EFLAGS,
 938                           (X86sub_flag GR32:$src1, imm:$src2))]>;
 939 def SUB16ri8 : Ii8<0x83, MRM5r, (outs GR16:$dst),
 940                                 (ins GR16:$src1, i16i8imm:$src2),
 941                    "sub{w}\t{$src2, $dst|$dst, $src2}",
 942                    [(set GR16:$dst, EFLAGS,
 943                          (X86sub_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
 944 def SUB32ri8 : Ii8<0x83, MRM5r, (outs GR32:$dst),
 945                                 (ins GR32:$src1, i32i8imm:$src2),
 946                    "sub{l}\t{$src2, $dst|$dst, $src2}",
 947                    [(set GR32:$dst, EFLAGS,
 948                          (X86sub_flag GR32:$src1, i32immSExt8:$src2))]>;
 949
 950 let Constraints = "" in {
 951   // Memory-Register Subtraction
 952   def SUB8mr   : I<0x28, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src2),
 953                    "sub{b}\t{$src2, $dst|$dst, $src2}",
 954                    [(store (sub (load addr:$dst), GR8:$src2), addr:$dst),
 955                     (implicit EFLAGS)]>;
 956   def SUB16mr  : I<0x29, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
 957                    "sub{w}\t{$src2, $dst|$dst, $src2}",
 958                    [(store (sub (load addr:$dst), GR16:$src2), addr:$dst),
 959                     (implicit EFLAGS)]>, OpSize;
 960   def SUB32mr  : I<0x29, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
 961                    "sub{l}\t{$src2, $dst|$dst, $src2}",
 962                    [(store (sub (load addr:$dst), GR32:$src2), addr:$dst),
 963                     (implicit EFLAGS)]>;
 964
 965   // Memory-Integer Subtraction
 966   def SUB8mi   : Ii8<0x80, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src2),
 967                      "sub{b}\t{$src2, $dst|$dst, $src2}",
 968                      [(store (sub (loadi8 addr:$dst), imm:$src2), addr:$dst),
 969                       (implicit EFLAGS)]>;
 970   def SUB16mi  : Ii16<0x81, MRM5m, (outs), (ins i16mem:$dst, i16imm:$src2),
 971                       "sub{w}\t{$src2, $dst|$dst, $src2}",
 972                       [(store (sub (loadi16 addr:$dst), imm:$src2),addr:$dst),
 973                        (implicit EFLAGS)]>, OpSize;
 974   def SUB32mi  : Ii32<0x81, MRM5m, (outs), (ins i32mem:$dst, i32imm:$src2),
 975                       "sub{l}\t{$src2, $dst|$dst, $src2}",
 976                       [(store (sub (loadi32 addr:$dst), imm:$src2),addr:$dst),
 977                        (implicit EFLAGS)]>;
 978   def SUB16mi8 : Ii8<0x83, MRM5m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
 979                      "sub{w}\t{$src2, $dst|$dst, $src2}",
 980                      [(store (sub (load addr:$dst), i16immSExt8:$src2),
 981                              addr:$dst),
 982                       (implicit EFLAGS)]>, OpSize;
 983   def SUB32mi8 : Ii8<0x83, MRM5m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
 984                      "sub{l}\t{$src2, $dst|$dst, $src2}",
 985                      [(store (sub (load addr:$dst), i32immSExt8:$src2),
 986                              addr:$dst),
 987                       (implicit EFLAGS)]>;
 988
 989   def SUB8i8 : Ii8<0x2C, RawFrm, (outs), (ins i8imm:$src),
 990                    "sub{b}\t{$src, %al|%al, $src}", []>;
 991   def SUB16i16 : Ii16<0x2D, RawFrm, (outs), (ins i16imm:$src),
 992                       "sub{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 993   def SUB32i32 : Ii32<0x2D, RawFrm, (outs), (ins i32imm:$src),
 994                       "sub{l}\t{$src, %eax|%eax, $src}", []>;
 995 } // Constraints = ""
 996
 997 let Uses = [EFLAGS] in {
 998 def SBB8rr     : I<0x18, MRMDestReg, (outs GR8:$dst),
 999                                      (ins GR8:$src1, GR8:$src2),
1000                   "sbb{b}\t{$src2, $dst|$dst, $src2}",
1001                  [(set GR8:$dst, (sube GR8:$src1, GR8:$src2))]>;
1002 def SBB16rr    : I<0x19, MRMDestReg, (outs GR16:$dst),
1003                                      (ins GR16:$src1, GR16:$src2),
1004                   "sbb{w}\t{$src2, $dst|$dst, $src2}",
1005                  [(set GR16:$dst, (sube GR16:$src1, GR16:$src2))]>, OpSize;
1006 def SBB32rr    : I<0x19, MRMDestReg, (outs GR32:$dst),
1007                                       (ins GR32:$src1, GR32:$src2),
1008                   "sbb{l}\t{$src2, $dst|$dst, $src2}",
1009                  [(set GR32:$dst, (sube GR32:$src1, GR32:$src2))]>;
1010
1011 let Constraints = "" in {
1012   def SBB8mr   : I<0x18, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1013                    "sbb{b}\t{$src2, $dst|$dst, $src2}",
1014                    [(store (sube (load addr:$dst), GR8:$src2), addr:$dst)]>;
1015   def SBB16mr  : I<0x19, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1016                    "sbb{w}\t{$src2, $dst|$dst, $src2}",
1017                    [(store (sube (load addr:$dst), GR16:$src2), addr:$dst)]>,
1018                    OpSize;
1019   def SBB32mr  : I<0x19, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1020                    "sbb{l}\t{$src2, $dst|$dst, $src2}",
1021                    [(store (sube (load addr:$dst), GR32:$src2), addr:$dst)]>;
1022   def SBB8mi  : Ii8<0x80, MRM3m, (outs), (ins i8mem:$dst, i8imm:$src2),
1023                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1024                    [(store (sube (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1025   def SBB16mi  : Ii16<0x81, MRM3m, (outs), (ins i16mem:$dst, i16imm:$src2),
1026                       "sbb{w}\t{$src2, $dst|$dst, $src2}",
1027                   [(store (sube (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1028                   OpSize;
1029   def SBB16mi8 : Ii8<0x83, MRM3m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1030                      "sbb{w}\t{$src2, $dst|$dst, $src2}",
1031                [(store (sube (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1032                OpSize;
1033   def SBB32mi  : Ii32<0x81, MRM3m, (outs), (ins i32mem:$dst, i32imm:$src2),
1034                       "sbb{l}\t{$src2, $dst|$dst, $src2}",
1035                   [(store (sube (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1036   def SBB32mi8 : Ii8<0x83, MRM3m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1037                      "sbb{l}\t{$src2, $dst|$dst, $src2}",
1038                [(store (sube (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1039
1040   def SBB8i8 : Ii8<0x1C, RawFrm, (outs), (ins i8imm:$src),
1041                    "sbb{b}\t{$src, %al|%al, $src}", []>;
1042   def SBB16i16 : Ii16<0x1D, RawFrm, (outs), (ins i16imm:$src),
1043                       "sbb{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1044   def SBB32i32 : Ii32<0x1D, RawFrm, (outs), (ins i32imm:$src),
1045                       "sbb{l}\t{$src, %eax|%eax, $src}", []>;
1046 } // Constraints = ""
1047
1048 let isCodeGenOnly = 1 in {
1049 def SBB8rr_REV : I<0x1A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1050                    "sbb{b}\t{$src2, $dst|$dst, $src2}", []>;
1051 def SBB16rr_REV : I<0x1B, MRMSrcReg, (outs GR16:$dst),
1052                     (ins GR16:$src1, GR16:$src2),
1053                     "sbb{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1054 def SBB32rr_REV : I<0x1B, MRMSrcReg, (outs GR32:$dst),
1055                     (ins GR32:$src1, GR32:$src2),
1056                     "sbb{l}\t{$src2, $dst|$dst, $src2}", []>;
1057 }
1058
1059 def SBB8rm   : I<0x1A, MRMSrcMem, (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1060                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1061                     [(set GR8:$dst, (sube GR8:$src1, (load addr:$src2)))]>;
1062 def SBB16rm  : I<0x1B, MRMSrcMem, (outs GR16:$dst),
1063                                   (ins GR16:$src1, i16mem:$src2),
1064                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1065                     [(set GR16:$dst, (sube GR16:$src1, (load addr:$src2)))]>,
1066                     OpSize;
1067 def SBB32rm  : I<0x1B, MRMSrcMem, (outs GR32:$dst),
1068                                   (ins GR32:$src1, i32mem:$src2),
1069                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1070                     [(set GR32:$dst, (sube GR32:$src1, (load addr:$src2)))]>;
1071 def SBB8ri   : Ii8<0x80, MRM3r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1072                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1073                     [(set GR8:$dst, (sube GR8:$src1, imm:$src2))]>;
1074 def SBB16ri  : Ii16<0x81, MRM3r, (outs GR16:$dst),
1075                                  (ins GR16:$src1, i16imm:$src2),
1076                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1077                     [(set GR16:$dst, (sube GR16:$src1, imm:$src2))]>, OpSize;
1078 def SBB16ri8 : Ii8<0x83, MRM3r, (outs GR16:$dst),
1079                                 (ins GR16:$src1, i16i8imm:$src2),
1080                    "sbb{w}\t{$src2, $dst|$dst, $src2}",
1081                    [(set GR16:$dst, (sube GR16:$src1, i16immSExt8:$src2))]>,
1082                    OpSize;
1083 def SBB32ri  : Ii32<0x81, MRM3r, (outs GR32:$dst),
1084                                  (ins GR32:$src1, i32imm:$src2),
1085                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1086                     [(set GR32:$dst, (sube GR32:$src1, imm:$src2))]>;
1087 def SBB32ri8 : Ii8<0x83, MRM3r, (outs GR32:$dst),
1088                                 (ins GR32:$src1, i32i8imm:$src2),
1089                    "sbb{l}\t{$src2, $dst|$dst, $src2}",
1090                    [(set GR32:$dst, (sube GR32:$src1, i32immSExt8:$src2))]>;
1091 } // Uses = [EFLAGS]
1092 } // Defs = [EFLAGS]
1093
1094 let Defs = [EFLAGS] in {
1095 let isCommutable = 1 in {  // X = IMUL Y, Z --> X = IMUL Z, Y
1096 // Register-Register Signed Integer Multiply
1097 def IMUL16rr : I<0xAF, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
1098                  "imul{w}\t{$src2, $dst|$dst, $src2}",
1099                  [(set GR16:$dst, EFLAGS,
1100                        (X86smul_flag GR16:$src1, GR16:$src2))]>, TB, OpSize;
1101 def IMUL32rr : I<0xAF, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
1102                  "imul{l}\t{$src2, $dst|$dst, $src2}",
1103                  [(set GR32:$dst, EFLAGS,
1104                        (X86smul_flag GR32:$src1, GR32:$src2))]>, TB;
1105 }
1106
1107 // Register-Memory Signed Integer Multiply
1108 def IMUL16rm : I<0xAF, MRMSrcMem, (outs GR16:$dst),
1109                                   (ins GR16:$src1, i16mem:$src2),
1110                  "imul{w}\t{$src2, $dst|$dst, $src2}",
1111                  [(set GR16:$dst, EFLAGS,
1112                        (X86smul_flag GR16:$src1, (load addr:$src2)))]>,
1113                TB, OpSize;
1114 def IMUL32rm : I<0xAF, MRMSrcMem, (outs GR32:$dst),
1115                  (ins GR32:$src1, i32mem:$src2),
1116                  "imul{l}\t{$src2, $dst|$dst, $src2}",
1117                  [(set GR32:$dst, EFLAGS,
1118                        (X86smul_flag GR32:$src1, (load addr:$src2)))]>, TB;
1119 } // Defs = [EFLAGS]
1120 } // end Two Address instructions
1121
1122 // Suprisingly enough, these are not two address instructions!
1123 let Defs = [EFLAGS] in {
1124 // Register-Integer Signed Integer Multiply
1125 def IMUL16rri  : Ii16<0x69, MRMSrcReg,                      // GR16 = GR16*I16
1126                       (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
1127                       "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1128                       [(set GR16:$dst, EFLAGS,
1129                             (X86smul_flag GR16:$src1, imm:$src2))]>, OpSize;
1130 def IMUL32rri  : Ii32<0x69, MRMSrcReg,                      // GR32 = GR32*I32
1131                       (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
1132                       "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1133                       [(set GR32:$dst, EFLAGS,
1134                             (X86smul_flag GR32:$src1, imm:$src2))]>;
1135 def IMUL16rri8 : Ii8<0x6B, MRMSrcReg,                       // GR16 = GR16*I8
1136                      (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
1137                      "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1138                      [(set GR16:$dst, EFLAGS,
1139                            (X86smul_flag GR16:$src1, i16immSExt8:$src2))]>,
1140                  OpSize;
1141 def IMUL32rri8 : Ii8<0x6B, MRMSrcReg,                       // GR32 = GR32*I8
1142                      (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
1143                      "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1144                      [(set GR32:$dst, EFLAGS,
1145                            (X86smul_flag GR32:$src1, i32immSExt8:$src2))]>;
1146
1147 // Memory-Integer Signed Integer Multiply
1148 def IMUL16rmi  : Ii16<0x69, MRMSrcMem,                     // GR16 = [mem16]*I16
1149                       (outs GR16:$dst), (ins i16mem:$src1, i16imm:$src2),
1150                       "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1151                       [(set GR16:$dst, EFLAGS,
1152                             (X86smul_flag (load addr:$src1), imm:$src2))]>,
1153                  OpSize;
1154 def IMUL32rmi  : Ii32<0x69, MRMSrcMem,                     // GR32 = [mem32]*I32
1155                       (outs GR32:$dst), (ins i32mem:$src1, i32imm:$src2),
1156                       "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1157                       [(set GR32:$dst, EFLAGS,
1158                             (X86smul_flag (load addr:$src1), imm:$src2))]>;
1159 def IMUL16rmi8 : Ii8<0x6B, MRMSrcMem,                       // GR16 = [mem16]*I8
1160                      (outs GR16:$dst), (ins i16mem:$src1, i16i8imm :$src2),
1161                      "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1162                      [(set GR16:$dst, EFLAGS,
1163                            (X86smul_flag (load addr:$src1),
1164                                          i16immSExt8:$src2))]>, OpSize;
1165 def IMUL32rmi8 : Ii8<0x6B, MRMSrcMem,                       // GR32 = [mem32]*I8
1166                      (outs GR32:$dst), (ins i32mem:$src1, i32i8imm: $src2),
1167                      "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
1168                      [(set GR32:$dst, EFLAGS,
1169                            (X86smul_flag (load addr:$src1),
1170                                          i32immSExt8:$src2))]>;
1171 } // Defs = [EFLAGS]
1172
1173 //===----------------------------------------------------------------------===//
1174 // Test instructions are just like AND, except they don't generate a result.
1175 //
1176 let Defs = [EFLAGS] in {
1177 let isCommutable = 1 in {   // TEST X, Y   --> TEST Y, X
1178 def TEST8rr  : I<0x84, MRMSrcReg, (outs),  (ins GR8:$src1, GR8:$src2),
1179                      "test{b}\t{$src2, $src1|$src1, $src2}",
1180                      [(set EFLAGS, (X86cmp (and_su GR8:$src1, GR8:$src2), 0))]>;
1181 def TEST16rr : I<0x85, MRMSrcReg, (outs),  (ins GR16:$src1, GR16:$src2),
1182                      "test{w}\t{$src2, $src1|$src1, $src2}",
1183                      [(set EFLAGS, (X86cmp (and_su GR16:$src1, GR16:$src2),
1184                       0))]>,
1185                  OpSize;
1186 def TEST32rr : I<0x85, MRMSrcReg, (outs),  (ins GR32:$src1, GR32:$src2),
1187                      "test{l}\t{$src2, $src1|$src1, $src2}",
1188                      [(set EFLAGS, (X86cmp (and_su GR32:$src1, GR32:$src2),
1189                       0))]>;
1190 }
1191
1192 def TEST8i8  : Ii8<0xA8, RawFrm, (outs), (ins i8imm:$src),
1193                    "test{b}\t{$src, %al|%al, $src}", []>;
1194 def TEST16i16 : Ii16<0xA9, RawFrm, (outs), (ins i16imm:$src),
1195                      "test{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1196 def TEST32i32 : Ii32<0xA9, RawFrm, (outs), (ins i32imm:$src),
1197                      "test{l}\t{$src, %eax|%eax, $src}", []>;
1198
1199 def TEST8rm  : I<0x84, MRMSrcMem, (outs),  (ins GR8 :$src1, i8mem :$src2),
1200                      "test{b}\t{$src2, $src1|$src1, $src2}",
1201                      [(set EFLAGS, (X86cmp (and GR8:$src1, (loadi8 addr:$src2)),
1202                        0))]>;
1203 def TEST16rm : I<0x85, MRMSrcMem, (outs),  (ins GR16:$src1, i16mem:$src2),
1204                      "test{w}\t{$src2, $src1|$src1, $src2}",
1205                      [(set EFLAGS, (X86cmp (and GR16:$src1,
1206                                          (loadi16 addr:$src2)), 0))]>, OpSize;
1207 def TEST32rm : I<0x85, MRMSrcMem, (outs),  (ins GR32:$src1, i32mem:$src2),
1208                      "test{l}\t{$src2, $src1|$src1, $src2}",
1209                      [(set EFLAGS, (X86cmp (and GR32:$src1,
1210                                                 (loadi32 addr:$src2)), 0))]>;
1211
1212 def TEST8ri  : Ii8 <0xF6, MRM0r,                     // flags = GR8  & imm8
1213                     (outs),  (ins GR8:$src1, i8imm:$src2),
1214                     "test{b}\t{$src2, $src1|$src1, $src2}",
1215                     [(set EFLAGS, (X86cmp (and_su GR8:$src1, imm:$src2), 0))]>;
1216 def TEST16ri : Ii16<0xF7, MRM0r,                     // flags = GR16 & imm16
1217                     (outs),  (ins GR16:$src1, i16imm:$src2),
1218                     "test{w}\t{$src2, $src1|$src1, $src2}",
1219                     [(set EFLAGS, (X86cmp (and_su GR16:$src1, imm:$src2), 0))]>,
1220                     OpSize;
1221 def TEST32ri : Ii32<0xF7, MRM0r,                     // flags = GR32 & imm32
1222                     (outs),  (ins GR32:$src1, i32imm:$src2),
1223                     "test{l}\t{$src2, $src1|$src1, $src2}",
1224                     [(set EFLAGS, (X86cmp (and_su GR32:$src1, imm:$src2), 0))]>;
1225
1226 def TEST8mi  : Ii8 <0xF6, MRM0m,                   // flags = [mem8]  & imm8
1227                     (outs), (ins i8mem:$src1, i8imm:$src2),
1228                     "test{b}\t{$src2, $src1|$src1, $src2}",
1229                     [(set EFLAGS, (X86cmp (and (loadi8 addr:$src1), imm:$src2),
1230                      0))]>;
1231 def TEST16mi : Ii16<0xF7, MRM0m,                   // flags = [mem16] & imm16
1232                     (outs), (ins i16mem:$src1, i16imm:$src2),
1233                     "test{w}\t{$src2, $src1|$src1, $src2}",
1234                     [(set EFLAGS, (X86cmp (and (loadi16 addr:$src1), imm:$src2),
1235                      0))]>, OpSize;
1236 def TEST32mi : Ii32<0xF7, MRM0m,                   // flags = [mem32] & imm32
1237                     (outs), (ins i32mem:$src1, i32imm:$src2),
1238                     "test{l}\t{$src2, $src1|$src1, $src2}",
1239                     [(set EFLAGS, (X86cmp (and (loadi32 addr:$src1), imm:$src2),
1240                      0))]>;
1241 } // Defs = [EFLAGS]
1242