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 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX], neverHasSideEffects = 1 in
  66 def MUL64r : RI<0xF7, MRM4r, (outs), (ins GR64:$src),
  67                 "mul{q}\t$src", []>;         // RAX,RDX = RAX*GR64
  68
  69 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  70 def MUL8m  : I<0xF6, MRM4m, (outs), (ins i8mem :$src),
  71                "mul{b}\t$src",
  72                // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
  73                // This probably ought to be moved to a def : Pat<> if the
  74                // syntax can be accepted.
  75                [(set AL, (mul AL, (loadi8 addr:$src))),
  76                 (implicit EFLAGS)]>;   // AL,AH = AL*[mem8]
  77
  78 let mayLoad = 1, neverHasSideEffects = 1 in {
  79 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
  80 def MUL16m : I<0xF7, MRM4m, (outs), (ins i16mem:$src),
  81                "mul{w}\t$src",
  82                []>, OpSize; // AX,DX = AX*[mem16]
  83
  84 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
  85 def MUL32m : I<0xF7, MRM4m, (outs), (ins i32mem:$src),
  86               "mul{l}\t$src",
  87               []>;          // EAX,EDX = EAX*[mem32]
  88 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX], neverHasSideEffects = 1 in
  89 def MUL64m : RI<0xF7, MRM4m, (outs), (ins i64mem:$src),
  90                 "mul{q}\t$src", []>;         // RAX,RDX = RAX*[mem64]
  91 }
  92
  93 let neverHasSideEffects = 1 in {
  94 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  95 def IMUL8r  : I<0xF6, MRM5r, (outs),  (ins GR8:$src), "imul{b}\t$src", []>;
  96               // AL,AH = AL*GR8
  97 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
  98 def IMUL16r : I<0xF7, MRM5r, (outs),  (ins GR16:$src), "imul{w}\t$src", []>,
  99               OpSize;    // AX,DX = AX*GR16
 100 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
 101 def IMUL32r : I<0xF7, MRM5r, (outs),  (ins GR32:$src), "imul{l}\t$src", []>;
 102               // EAX,EDX = EAX*GR32
 103 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX], neverHasSideEffects = 1 in
 104 def IMUL64r : RI<0xF7, MRM5r, (outs), (ins GR64:$src), "imul{q}\t$src", []>;
 105               // RAX,RDX = RAX*GR64
 106
 107 let mayLoad = 1 in {
 108 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
 109 def IMUL8m  : I<0xF6, MRM5m, (outs), (ins i8mem :$src),
 110                 "imul{b}\t$src", []>;    // AL,AH = AL*[mem8]
 111 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
 112 def IMUL16m : I<0xF7, MRM5m, (outs), (ins i16mem:$src),
 113                 "imul{w}\t$src", []>, OpSize; // AX,DX = AX*[mem16]
 114 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
 115 def IMUL32m : I<0xF7, MRM5m, (outs), (ins i32mem:$src),
 116                 "imul{l}\t$src", []>;  // EAX,EDX = EAX*[mem32]
 117 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX], neverHasSideEffects = 1 in
 118 def IMUL64m : RI<0xF7, MRM5m, (outs), (ins i64mem:$src),
 119                  "imul{q}\t$src", []>;         // RAX,RDX = RAX*[mem64]
 120 }
 121 } // neverHasSideEffects
 122
 123
 124 let Defs = [EFLAGS] in {
 125 let Constraints = "$src1 = $dst" in {
 126
 127 let isCommutable = 1 in {  // X = IMUL Y, Z --> X = IMUL Z, Y
 128 // Register-Register Signed Integer Multiply
 129 def IMUL16rr : I<0xAF, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
 130                  "imul{w}\t{$src2, $dst|$dst, $src2}",
 131                  [(set GR16:$dst, EFLAGS,
 132                        (X86smul_flag GR16:$src1, GR16:$src2))]>, TB, OpSize;
 133 def IMUL32rr : I<0xAF, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
 134                  "imul{l}\t{$src2, $dst|$dst, $src2}",
 135                  [(set GR32:$dst, EFLAGS,
 136                        (X86smul_flag GR32:$src1, GR32:$src2))]>, TB;
 137 def IMUL64rr : RI<0xAF, MRMSrcReg, (outs GR64:$dst),
 138                                    (ins GR64:$src1, GR64:$src2),
 139                   "imul{q}\t{$src2, $dst|$dst, $src2}",
 140                   [(set GR64:$dst, EFLAGS,
 141                         (X86smul_flag GR64:$src1, GR64:$src2))]>, TB;
 142 }
 143
 144 // Register-Memory Signed Integer Multiply
 145 def IMUL16rm : I<0xAF, MRMSrcMem, (outs GR16:$dst),
 146                                   (ins GR16:$src1, i16mem:$src2),
 147                  "imul{w}\t{$src2, $dst|$dst, $src2}",
 148                  [(set GR16:$dst, EFLAGS,
 149                        (X86smul_flag GR16:$src1, (load addr:$src2)))]>,
 150                TB, OpSize;
 151 def IMUL32rm : I<0xAF, MRMSrcMem, (outs GR32:$dst),
 152                  (ins GR32:$src1, i32mem:$src2),
 153                  "imul{l}\t{$src2, $dst|$dst, $src2}",
 154                  [(set GR32:$dst, EFLAGS,
 155                        (X86smul_flag GR32:$src1, (load addr:$src2)))]>, TB;
 156 def IMUL64rm : RI<0xAF, MRMSrcMem, (outs GR64:$dst),
 157                                    (ins GR64:$src1, i64mem:$src2),
 158                   "imul{q}\t{$src2, $dst|$dst, $src2}",
 159                   [(set GR64:$dst, EFLAGS,
 160                         (X86smul_flag GR64:$src1, (load addr:$src2)))]>, TB;
 161 } // Constraints = "$src1 = $dst"
 162
 163 } // Defs = [EFLAGS]
 164
 165 // Suprisingly enough, these are not two address instructions!
 166 let Defs = [EFLAGS] in {
 167 // Register-Integer Signed Integer Multiply
 168 def IMUL16rri  : Ii16<0x69, MRMSrcReg,                      // GR16 = GR16*I16
 169                       (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 170                       "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 171                       [(set GR16:$dst, EFLAGS,
 172                             (X86smul_flag GR16:$src1, imm:$src2))]>, OpSize;
 173 def IMUL16rri8 : Ii8<0x6B, MRMSrcReg,                       // GR16 = GR16*I8
 174                      (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 175                      "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 176                      [(set GR16:$dst, EFLAGS,
 177                            (X86smul_flag GR16:$src1, i16immSExt8:$src2))]>,
 178                  OpSize;
 179 def IMUL32rri  : Ii32<0x69, MRMSrcReg,                      // GR32 = GR32*I32
 180                       (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 181                       "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 182                       [(set GR32:$dst, EFLAGS,
 183                             (X86smul_flag GR32:$src1, imm:$src2))]>;
 184 def IMUL32rri8 : Ii8<0x6B, MRMSrcReg,                       // GR32 = GR32*I8
 185                      (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 186                      "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 187                      [(set GR32:$dst, EFLAGS,
 188                            (X86smul_flag GR32:$src1, i32immSExt8:$src2))]>;
 189 def IMUL64rri32 : RIi32<0x69, MRMSrcReg,                    // GR64 = GR64*I32
 190                         (outs GR64:$dst), (ins GR64:$src1, i64i32imm:$src2),
 191                         "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 192                        [(set GR64:$dst, EFLAGS,
 193                              (X86smul_flag GR64:$src1, i64immSExt32:$src2))]>;
 194 def IMUL64rri8 : RIi8<0x6B, MRMSrcReg,                      // GR64 = GR64*I8
 195                       (outs GR64:$dst), (ins GR64:$src1, i64i8imm:$src2),
 196                       "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 197                       [(set GR64:$dst, EFLAGS,
 198                             (X86smul_flag GR64:$src1, i64immSExt8:$src2))]>;
 199
 200
 201 // Memory-Integer Signed Integer Multiply
 202 def IMUL16rmi  : Ii16<0x69, MRMSrcMem,                     // GR16 = [mem16]*I16
 203                       (outs GR16:$dst), (ins i16mem:$src1, i16imm:$src2),
 204                       "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 205                       [(set GR16:$dst, EFLAGS,
 206                             (X86smul_flag (load addr:$src1), imm:$src2))]>,
 207                  OpSize;
 208 def IMUL16rmi8 : Ii8<0x6B, MRMSrcMem,                       // GR16 = [mem16]*I8
 209                      (outs GR16:$dst), (ins i16mem:$src1, i16i8imm :$src2),
 210                      "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 211                      [(set GR16:$dst, EFLAGS,
 212                            (X86smul_flag (load addr:$src1),
 213                                          i16immSExt8:$src2))]>, OpSize;
 214 def IMUL32rmi  : Ii32<0x69, MRMSrcMem,                     // GR32 = [mem32]*I32
 215                       (outs GR32:$dst), (ins i32mem:$src1, i32imm:$src2),
 216                       "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 217                       [(set GR32:$dst, EFLAGS,
 218                             (X86smul_flag (load addr:$src1), imm:$src2))]>;
 219 def IMUL32rmi8 : Ii8<0x6B, MRMSrcMem,                       // GR32 = [mem32]*I8
 220                      (outs GR32:$dst), (ins i32mem:$src1, i32i8imm: $src2),
 221                      "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 222                      [(set GR32:$dst, EFLAGS,
 223                            (X86smul_flag (load addr:$src1),
 224                                          i32immSExt8:$src2))]>;
 225 def IMUL64rmi32 : RIi32<0x69, MRMSrcMem,                   // GR64 = [mem64]*I32
 226                         (outs GR64:$dst), (ins i64mem:$src1, i64i32imm:$src2),
 227                         "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 228                         [(set GR64:$dst, EFLAGS,
 229                               (X86smul_flag (load addr:$src1),
 230                                             i64immSExt32:$src2))]>;
 231 def IMUL64rmi8 : RIi8<0x6B, MRMSrcMem,                      // GR64 = [mem64]*I8
 232                       (outs GR64:$dst), (ins i64mem:$src1, i64i8imm: $src2),
 233                       "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 234                       [(set GR64:$dst, EFLAGS,
 235                             (X86smul_flag (load addr:$src1),
 236                                           i64immSExt8:$src2))]>;
 237 } // Defs = [EFLAGS]
 238
 239
 240
 241
 242 // unsigned division/remainder
 243 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 244 def DIV8r  : I<0xF6, MRM6r, (outs),  (ins GR8:$src),    // AX/r8 = AL,AH
 245                "div{b}\t$src", []>;
 246 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 247 def DIV16r : I<0xF7, MRM6r, (outs),  (ins GR16:$src),   // DX:AX/r16 = AX,DX
 248                "div{w}\t$src", []>, OpSize;
 249 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 250 def DIV32r : I<0xF7, MRM6r, (outs),  (ins GR32:$src),   // EDX:EAX/r32 = EAX,EDX
 251                "div{l}\t$src", []>;
 252 // RDX:RAX/r64 = RAX,RDX
 253 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in
 254 def DIV64r : RI<0xF7, MRM6r, (outs), (ins GR64:$src),
 255                 "div{q}\t$src", []>;
 256
 257 let mayLoad = 1 in {
 258 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 259 def DIV8m  : I<0xF6, MRM6m, (outs), (ins i8mem:$src),   // AX/[mem8] = AL,AH
 260                "div{b}\t$src", []>;
 261 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 262 def DIV16m : I<0xF7, MRM6m, (outs), (ins i16mem:$src),  // DX:AX/[mem16] = AX,DX
 263                "div{w}\t$src", []>, OpSize;
 264 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in    // EDX:EAX/[mem32] = EAX,EDX
 265 def DIV32m : I<0xF7, MRM6m, (outs), (ins i32mem:$src),
 266                "div{l}\t$src", []>;
 267 // RDX:RAX/[mem64] = RAX,RDX
 268 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in
 269 def DIV64m : RI<0xF7, MRM6m, (outs), (ins i64mem:$src),
 270                 "div{q}\t$src", []>;
 271 }
 272
 273 // Signed division/remainder.
 274 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 275 def IDIV8r : I<0xF6, MRM7r, (outs),  (ins GR8:$src),    // AX/r8 = AL,AH
 276                "idiv{b}\t$src", []>;
 277 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 278 def IDIV16r: I<0xF7, MRM7r, (outs),  (ins GR16:$src),   // DX:AX/r16 = AX,DX
 279                "idiv{w}\t$src", []>, OpSize;
 280 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 281 def IDIV32r: I<0xF7, MRM7r, (outs),  (ins GR32:$src),   // EDX:EAX/r32 = EAX,EDX
 282                "idiv{l}\t$src", []>;
 283 // RDX:RAX/r64 = RAX,RDX
 284 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in
 285 def IDIV64r: RI<0xF7, MRM7r, (outs), (ins GR64:$src),
 286                 "idiv{q}\t$src", []>;
 287
 288 let mayLoad = 1, mayLoad = 1 in {
 289 let Defs = [AL,EFLAGS,AX], Uses = [AX] in
 290 def IDIV8m : I<0xF6, MRM7m, (outs), (ins i8mem:$src),   // AX/[mem8] = AL,AH
 291                "idiv{b}\t$src", []>;
 292 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 293 def IDIV16m: I<0xF7, MRM7m, (outs), (ins i16mem:$src),  // DX:AX/[mem16] = AX,DX
 294                "idiv{w}\t$src", []>, OpSize;
 295 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in    // EDX:EAX/[mem32] = EAX,EDX
 296 def IDIV32m: I<0xF7, MRM7m, (outs), (ins i32mem:$src),
 297                "idiv{l}\t$src", []>;
 298 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in // RDX:RAX/[mem64] = RAX,RDX
 299 def IDIV64m: RI<0xF7, MRM7m, (outs), (ins i64mem:$src),
 300                 "idiv{q}\t$src", []>;
 301 }
 302
 303 //===----------------------------------------------------------------------===//
 304 //  Two address Instructions.
 305 //
 306
 307 // unary instructions
 308 let CodeSize = 2 in {
 309 let Defs = [EFLAGS] in {
 310 let Constraints = "$src1 = $dst" in {
 311 def NEG8r  : I<0xF6, MRM3r, (outs GR8 :$dst), (ins GR8 :$src1),
 312                "neg{b}\t$dst",
 313                [(set GR8:$dst, (ineg GR8:$src1)),
 314                 (implicit EFLAGS)]>;
 315 def NEG16r : I<0xF7, MRM3r, (outs GR16:$dst), (ins GR16:$src1),
 316                "neg{w}\t$dst",
 317                [(set GR16:$dst, (ineg GR16:$src1)),
 318                 (implicit EFLAGS)]>, OpSize;
 319 def NEG32r : I<0xF7, MRM3r, (outs GR32:$dst), (ins GR32:$src1),
 320                "neg{l}\t$dst",
 321                [(set GR32:$dst, (ineg GR32:$src1)),
 322                 (implicit EFLAGS)]>;
 323 def NEG64r : RI<0xF7, MRM3r, (outs GR64:$dst), (ins GR64:$src1), "neg{q}\t$dst",
 324                 [(set GR64:$dst, (ineg GR64:$src1)),
 325                  (implicit EFLAGS)]>;
 326 } // Constraints = "$src1 = $dst"
 327
 328 def NEG8m  : I<0xF6, MRM3m, (outs), (ins i8mem :$dst),
 329                "neg{b}\t$dst",
 330                [(store (ineg (loadi8 addr:$dst)), addr:$dst),
 331                 (implicit EFLAGS)]>;
 332 def NEG16m : I<0xF7, MRM3m, (outs), (ins i16mem:$dst),
 333                "neg{w}\t$dst",
 334                [(store (ineg (loadi16 addr:$dst)), addr:$dst),
 335                 (implicit EFLAGS)]>, OpSize;
 336 def NEG32m : I<0xF7, MRM3m, (outs), (ins i32mem:$dst),
 337                "neg{l}\t$dst",
 338                [(store (ineg (loadi32 addr:$dst)), addr:$dst),
 339                 (implicit EFLAGS)]>;
 340 def NEG64m : RI<0xF7, MRM3m, (outs), (ins i64mem:$dst), "neg{q}\t$dst",
 341                 [(store (ineg (loadi64 addr:$dst)), addr:$dst),
 342                  (implicit EFLAGS)]>;
 343 } // Defs = [EFLAGS]
 344
 345
 346 // FIXME: NOT sets EFLAGS!
 347
 348 let Constraints = "$src1 = $dst" in {
 349 // Match xor -1 to not. Favors these over a move imm + xor to save code size.
 350 let AddedComplexity = 15 in {
 351 def NOT8r  : I<0xF6, MRM2r, (outs GR8 :$dst), (ins GR8 :$src1),
 352                "not{b}\t$dst",
 353                [(set GR8:$dst, (not GR8:$src1))]>;
 354 def NOT16r : I<0xF7, MRM2r, (outs GR16:$dst), (ins GR16:$src1),
 355                "not{w}\t$dst",
 356                [(set GR16:$dst, (not GR16:$src1))]>, OpSize;
 357 def NOT32r : I<0xF7, MRM2r, (outs GR32:$dst), (ins GR32:$src1),
 358                "not{l}\t$dst",
 359                [(set GR32:$dst, (not GR32:$src1))]>;
 360 def NOT64r : RI<0xF7, MRM2r, (outs GR64:$dst), (ins GR64:$src1), "not{q}\t$dst",
 361                 [(set GR64:$dst, (not GR64:$src1))]>;
 362 }
 363 } // Constraints = "$src1 = $dst"
 364
 365 def NOT8m  : I<0xF6, MRM2m, (outs), (ins i8mem :$dst),
 366                "not{b}\t$dst",
 367                [(store (not (loadi8 addr:$dst)), addr:$dst)]>;
 368 def NOT16m : I<0xF7, MRM2m, (outs), (ins i16mem:$dst),
 369                "not{w}\t$dst",
 370                [(store (not (loadi16 addr:$dst)), addr:$dst)]>, OpSize;
 371 def NOT32m : I<0xF7, MRM2m, (outs), (ins i32mem:$dst),
 372                "not{l}\t$dst",
 373                [(store (not (loadi32 addr:$dst)), addr:$dst)]>;
 374 def NOT64m : RI<0xF7, MRM2m, (outs), (ins i64mem:$dst), "not{q}\t$dst",
 375                 [(store (not (loadi64 addr:$dst)), addr:$dst)]>;
 376 } // CodeSize
 377
 378 // TODO: inc/dec is slow for P4, but fast for Pentium-M.
 379 let Defs = [EFLAGS] in {
 380 let Constraints = "$src1 = $dst" in {
 381 let CodeSize = 2 in
 382 def INC8r  : I<0xFE, MRM0r, (outs GR8 :$dst), (ins GR8 :$src1),
 383                "inc{b}\t$dst",
 384                [(set GR8:$dst, EFLAGS, (X86inc_flag GR8:$src1))]>;
 385
 386 let isConvertibleToThreeAddress = 1, CodeSize = 1 in {  // Can xform into LEA.
 387 def INC16r : I<0x40, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 388                "inc{w}\t$dst",
 389                [(set GR16:$dst, EFLAGS, (X86inc_flag GR16:$src1))]>,
 390              OpSize, Requires<[In32BitMode]>;
 391 def INC32r : I<0x40, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 392                "inc{l}\t$dst",
 393                [(set GR32:$dst, EFLAGS, (X86inc_flag GR32:$src1))]>,
 394              Requires<[In32BitMode]>;
 395 def INC64r : RI<0xFF, MRM0r, (outs GR64:$dst), (ins GR64:$src1), "inc{q}\t$dst",
 396                 [(set GR64:$dst, EFLAGS, (X86inc_flag GR64:$src1))]>;
 397 }
 398 } // Constraints = "$src1 = $dst"
 399
 400 let CodeSize = 2 in {
 401   def INC8m  : I<0xFE, MRM0m, (outs), (ins i8mem :$dst), "inc{b}\t$dst",
 402                [(store (add (loadi8 addr:$dst), 1), addr:$dst),
 403                 (implicit EFLAGS)]>;
 404   def INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
 405                [(store (add (loadi16 addr:$dst), 1), addr:$dst),
 406                 (implicit EFLAGS)]>,
 407                OpSize, Requires<[In32BitMode]>;
 408   def INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
 409                [(store (add (loadi32 addr:$dst), 1), addr:$dst),
 410                 (implicit EFLAGS)]>,
 411                Requires<[In32BitMode]>;
 412   def INC64m : RI<0xFF, MRM0m, (outs), (ins i64mem:$dst), "inc{q}\t$dst",
 413                   [(store (add (loadi64 addr:$dst), 1), addr:$dst),
 414                    (implicit EFLAGS)]>;
 415 } // CodeSize = 2
 416
 417 let Constraints = "$src1 = $dst" in {
 418 let CodeSize = 2 in
 419 def DEC8r  : I<0xFE, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
 420                "dec{b}\t$dst",
 421                [(set GR8:$dst, EFLAGS, (X86dec_flag GR8:$src1))]>;
 422 let isConvertibleToThreeAddress = 1, CodeSize = 1 in {   // Can xform into LEA.
 423 def DEC16r : I<0x48, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 424                "dec{w}\t$dst",
 425                [(set GR16:$dst, EFLAGS, (X86dec_flag GR16:$src1))]>,
 426              OpSize, Requires<[In32BitMode]>;
 427 def DEC32r : I<0x48, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 428                "dec{l}\t$dst",
 429                [(set GR32:$dst, EFLAGS, (X86dec_flag GR32:$src1))]>,
 430              Requires<[In32BitMode]>;
 431 def DEC64r : RI<0xFF, MRM1r, (outs GR64:$dst), (ins GR64:$src1), "dec{q}\t$dst",
 432                 [(set GR64:$dst, EFLAGS, (X86dec_flag GR64:$src1))]>;
 433 } // CodeSize = 2
 434 } // Constraints = "$src1 = $dst"
 435
 436
 437 let CodeSize = 2 in {
 438   def DEC8m  : I<0xFE, MRM1m, (outs), (ins i8mem :$dst), "dec{b}\t$dst",
 439                [(store (add (loadi8 addr:$dst), -1), addr:$dst),
 440                 (implicit EFLAGS)]>;
 441   def DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
 442                [(store (add (loadi16 addr:$dst), -1), addr:$dst),
 443                 (implicit EFLAGS)]>,
 444                OpSize, Requires<[In32BitMode]>;
 445   def DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
 446                [(store (add (loadi32 addr:$dst), -1), addr:$dst),
 447                 (implicit EFLAGS)]>,
 448                Requires<[In32BitMode]>;
 449   def DEC64m : RI<0xFF, MRM1m, (outs), (ins i64mem:$dst), "dec{q}\t$dst",
 450                   [(store (add (loadi64 addr:$dst), -1), addr:$dst),
 451                    (implicit EFLAGS)]>;
 452 } // CodeSize = 2
 453 } // Defs = [EFLAGS]
 454
 455 // Logical operators.
 456 let Defs = [EFLAGS] in {
 457 let Constraints = "$src1 = $dst" in {
 458 let isCommutable = 1 in {   // X = AND Y, Z   --> X = AND Z, Y
 459 def AND8rr  : I<0x20, MRMDestReg,
 460                (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
 461                "and{b}\t{$src2, $dst|$dst, $src2}",
 462                [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1, GR8:$src2))]>;
 463 def AND16rr : I<0x21, MRMDestReg,
 464                 (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
 465                 "and{w}\t{$src2, $dst|$dst, $src2}",
 466                 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 467                                                       GR16:$src2))]>, OpSize;
 468 def AND32rr : I<0x21, MRMDestReg,
 469                 (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
 470                 "and{l}\t{$src2, $dst|$dst, $src2}",
 471                 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 472                                                       GR32:$src2))]>;
 473 } // isCommutable
 474
 475
 476 // AND instructions with the destination register in REG and the source register
 477 //   in R/M.  Included for the disassembler.
 478 let isCodeGenOnly = 1 in {
 479 def AND8rr_REV : I<0x22, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 480                   "and{b}\t{$src2, $dst|$dst, $src2}", []>;
 481 def AND16rr_REV : I<0x23, MRMSrcReg, (outs GR16:$dst),
 482                     (ins GR16:$src1, GR16:$src2),
 483                    "and{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 484 def AND32rr_REV : I<0x23, MRMSrcReg, (outs GR32:$dst),
 485                     (ins GR32:$src1, GR32:$src2),
 486                    "and{l}\t{$src2, $dst|$dst, $src2}", []>;
 487 }
 488
 489 def AND8rm   : I<0x22, MRMSrcMem,
 490                  (outs GR8 :$dst), (ins GR8 :$src1, i8mem :$src2),
 491                  "and{b}\t{$src2, $dst|$dst, $src2}",
 492                 [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
 493                                                      (loadi8 addr:$src2)))]>;
 494 def AND16rm  : I<0x23, MRMSrcMem,
 495                  (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
 496                  "and{w}\t{$src2, $dst|$dst, $src2}",
 497                 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 498                                                       (loadi16 addr:$src2)))]>,
 499                OpSize;
 500 def AND32rm  : I<0x23, MRMSrcMem,
 501                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
 502                  "and{l}\t{$src2, $dst|$dst, $src2}",
 503                 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 504                                                       (loadi32 addr:$src2)))]>;
 505
 506 def AND8ri   : Ii8<0x80, MRM4r,
 507                    (outs GR8 :$dst), (ins GR8 :$src1, i8imm :$src2),
 508                    "and{b}\t{$src2, $dst|$dst, $src2}",
 509                    [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
 510                                                         imm:$src2))]>;
 511 def AND16ri  : Ii16<0x81, MRM4r,
 512                     (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 513                     "and{w}\t{$src2, $dst|$dst, $src2}",
 514                     [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 515                                                           imm:$src2))]>, OpSize;
 516 def AND32ri  : Ii32<0x81, MRM4r,
 517                     (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 518                     "and{l}\t{$src2, $dst|$dst, $src2}",
 519                     [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 520                                                           imm:$src2))]>;
 521 def AND16ri8 : Ii8<0x83, MRM4r,
 522                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 523                    "and{w}\t{$src2, $dst|$dst, $src2}",
 524                    [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 525                                                          i16immSExt8:$src2))]>,
 526                    OpSize;
 527 def AND32ri8 : Ii8<0x83, MRM4r,
 528                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 529                    "and{l}\t{$src2, $dst|$dst, $src2}",
 530                    [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 531                                                          i32immSExt8:$src2))]>;
 532 } // Constraints = "$src1 = $dst"
 533
 534 def AND8mr   : I<0x20, MRMDestMem,
 535                  (outs), (ins i8mem :$dst, GR8 :$src),
 536                  "and{b}\t{$src, $dst|$dst, $src}",
 537                  [(store (and (load addr:$dst), GR8:$src), addr:$dst),
 538                   (implicit EFLAGS)]>;
 539 def AND16mr  : I<0x21, MRMDestMem,
 540                  (outs), (ins i16mem:$dst, GR16:$src),
 541                  "and{w}\t{$src, $dst|$dst, $src}",
 542                  [(store (and (load addr:$dst), GR16:$src), addr:$dst),
 543                   (implicit EFLAGS)]>,
 544                  OpSize;
 545 def AND32mr  : I<0x21, MRMDestMem,
 546                  (outs), (ins i32mem:$dst, GR32:$src),
 547                  "and{l}\t{$src, $dst|$dst, $src}",
 548                  [(store (and (load addr:$dst), GR32:$src), addr:$dst),
 549                   (implicit EFLAGS)]>;
 550 def AND8mi   : Ii8<0x80, MRM4m,
 551                    (outs), (ins i8mem :$dst, i8imm :$src),
 552                    "and{b}\t{$src, $dst|$dst, $src}",
 553                     [(store (and (loadi8 addr:$dst), imm:$src), addr:$dst),
 554                      (implicit EFLAGS)]>;
 555 def AND16mi  : Ii16<0x81, MRM4m,
 556                     (outs), (ins i16mem:$dst, i16imm:$src),
 557                     "and{w}\t{$src, $dst|$dst, $src}",
 558                     [(store (and (loadi16 addr:$dst), imm:$src), addr:$dst),
 559                      (implicit EFLAGS)]>,
 560                     OpSize;
 561 def AND32mi  : Ii32<0x81, MRM4m,
 562                     (outs), (ins i32mem:$dst, i32imm:$src),
 563                     "and{l}\t{$src, $dst|$dst, $src}",
 564                     [(store (and (loadi32 addr:$dst), imm:$src), addr:$dst),
 565                      (implicit EFLAGS)]>;
 566 def AND16mi8 : Ii8<0x83, MRM4m,
 567                    (outs), (ins i16mem:$dst, i16i8imm :$src),
 568                    "and{w}\t{$src, $dst|$dst, $src}",
 569               [(store (and (load addr:$dst), i16immSExt8:$src), addr:$dst),
 570                (implicit EFLAGS)]>,
 571                    OpSize;
 572 def AND32mi8 : Ii8<0x83, MRM4m,
 573                    (outs), (ins i32mem:$dst, i32i8imm :$src),
 574                    "and{l}\t{$src, $dst|$dst, $src}",
 575               [(store (and (load addr:$dst), i32immSExt8:$src), addr:$dst),
 576                (implicit EFLAGS)]>;
 577
 578 // FIXME: Implicitly modifiers AL.
 579 def AND8i8 : Ii8<0x24, RawFrm, (outs), (ins i8imm:$src),
 580                  "and{b}\t{$src, %al|%al, $src}", []>;
 581 def AND16i16 : Ii16<0x25, RawFrm, (outs), (ins i16imm:$src),
 582                     "and{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 583 def AND32i32 : Ii32<0x25, RawFrm, (outs), (ins i32imm:$src),
 584                     "and{l}\t{$src, %eax|%eax, $src}", []>;
 585
 586 let Constraints = "$src1 = $dst" in {
 587
 588 let isCommutable = 1 in {   // X = OR Y, Z   --> X = OR Z, Y
 589 def OR8rr    : I<0x08, MRMDestReg, (outs GR8 :$dst),
 590                  (ins GR8 :$src1, GR8 :$src2),
 591                  "or{b}\t{$src2, $dst|$dst, $src2}",
 592                  [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1, GR8:$src2))]>;
 593 def OR16rr   : I<0x09, MRMDestReg, (outs GR16:$dst),
 594                  (ins GR16:$src1, GR16:$src2),
 595                  "or{w}\t{$src2, $dst|$dst, $src2}",
 596                  [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,GR16:$src2))]>,
 597                OpSize;
 598 def OR32rr   : I<0x09, MRMDestReg, (outs GR32:$dst),
 599                  (ins GR32:$src1, GR32:$src2),
 600                  "or{l}\t{$src2, $dst|$dst, $src2}",
 601                  [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,GR32:$src2))]>;
 602 }
 603
 604 // OR instructions with the destination register in REG and the source register
 605 //   in R/M.  Included for the disassembler.
 606 let isCodeGenOnly = 1 in {
 607 def OR8rr_REV : I<0x0A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 608                   "or{b}\t{$src2, $dst|$dst, $src2}", []>;
 609 def OR16rr_REV : I<0x0B, MRMSrcReg, (outs GR16:$dst),
 610                    (ins GR16:$src1, GR16:$src2),
 611                    "or{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 612 def OR32rr_REV : I<0x0B, MRMSrcReg, (outs GR32:$dst),
 613                    (ins GR32:$src1, GR32:$src2),
 614                    "or{l}\t{$src2, $dst|$dst, $src2}", []>;
 615 }
 616
 617 def OR8rm    : I<0x0A, MRMSrcMem, (outs GR8 :$dst),
 618                  (ins GR8 :$src1, i8mem :$src2),
 619                  "or{b}\t{$src2, $dst|$dst, $src2}",
 620                 [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1,
 621                                                     (load addr:$src2)))]>;
 622 def OR16rm   : I<0x0B, MRMSrcMem, (outs GR16:$dst),
 623                  (ins GR16:$src1, i16mem:$src2),
 624                  "or{w}\t{$src2, $dst|$dst, $src2}",
 625                 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 626                                                      (load addr:$src2)))]>,
 627                OpSize;
 628 def OR32rm   : I<0x0B, MRMSrcMem, (outs GR32:$dst),
 629                  (ins GR32:$src1, i32mem:$src2),
 630                  "or{l}\t{$src2, $dst|$dst, $src2}",
 631                 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 632                                                      (load addr:$src2)))]>;
 633
 634 def OR8ri    : Ii8 <0x80, MRM1r, (outs GR8 :$dst),
 635                     (ins GR8 :$src1, i8imm:$src2),
 636                     "or{b}\t{$src2, $dst|$dst, $src2}",
 637                     [(set GR8:$dst,EFLAGS, (X86or_flag GR8:$src1, imm:$src2))]>;
 638 def OR16ri   : Ii16<0x81, MRM1r, (outs GR16:$dst),
 639                     (ins GR16:$src1, i16imm:$src2),
 640                     "or{w}\t{$src2, $dst|$dst, $src2}",
 641                     [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 642                                                         imm:$src2))]>, OpSize;
 643 def OR32ri   : Ii32<0x81, MRM1r, (outs GR32:$dst),
 644                     (ins GR32:$src1, i32imm:$src2),
 645                     "or{l}\t{$src2, $dst|$dst, $src2}",
 646                     [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 647                                                          imm:$src2))]>;
 648
 649 def OR16ri8  : Ii8<0x83, MRM1r, (outs GR16:$dst),
 650                    (ins GR16:$src1, i16i8imm:$src2),
 651                    "or{w}\t{$src2, $dst|$dst, $src2}",
 652                    [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 653                                                 i16immSExt8:$src2))]>, OpSize;
 654 def OR32ri8  : Ii8<0x83, MRM1r, (outs GR32:$dst),
 655                    (ins GR32:$src1, i32i8imm:$src2),
 656                    "or{l}\t{$src2, $dst|$dst, $src2}",
 657                    [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 658                                                         i32immSExt8:$src2))]>;
 659 } // Constraints = "$src1 = $dst"
 660
 661 def OR8mr  : I<0x08, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
 662                "or{b}\t{$src, $dst|$dst, $src}",
 663                [(store (or (load addr:$dst), GR8:$src), addr:$dst),
 664                 (implicit EFLAGS)]>;
 665 def OR16mr : I<0x09, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
 666                "or{w}\t{$src, $dst|$dst, $src}",
 667                [(store (or (load addr:$dst), GR16:$src), addr:$dst),
 668                 (implicit EFLAGS)]>, OpSize;
 669 def OR32mr : I<0x09, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
 670                "or{l}\t{$src, $dst|$dst, $src}",
 671                [(store (or (load addr:$dst), GR32:$src), addr:$dst),
 672                 (implicit EFLAGS)]>;
 673 def OR8mi    : Ii8<0x80, MRM1m, (outs), (ins i8mem :$dst, i8imm:$src),
 674                "or{b}\t{$src, $dst|$dst, $src}",
 675                [(store (or (loadi8 addr:$dst), imm:$src), addr:$dst),
 676                 (implicit EFLAGS)]>;
 677 def OR16mi   : Ii16<0x81, MRM1m, (outs), (ins i16mem:$dst, i16imm:$src),
 678                "or{w}\t{$src, $dst|$dst, $src}",
 679                [(store (or (loadi16 addr:$dst), imm:$src), addr:$dst),
 680                 (implicit EFLAGS)]>,
 681                OpSize;
 682 def OR32mi   : Ii32<0x81, MRM1m, (outs), (ins i32mem:$dst, i32imm:$src),
 683                "or{l}\t{$src, $dst|$dst, $src}",
 684                [(store (or (loadi32 addr:$dst), imm:$src), addr:$dst),
 685                 (implicit EFLAGS)]>;
 686 def OR16mi8  : Ii8<0x83, MRM1m, (outs), (ins i16mem:$dst, i16i8imm:$src),
 687                "or{w}\t{$src, $dst|$dst, $src}",
 688                [(store (or (load addr:$dst), i16immSExt8:$src), addr:$dst),
 689                 (implicit EFLAGS)]>,
 690                    OpSize;
 691 def OR32mi8  : Ii8<0x83, MRM1m, (outs), (ins i32mem:$dst, i32i8imm:$src),
 692                "or{l}\t{$src, $dst|$dst, $src}",
 693                [(store (or (load addr:$dst), i32immSExt8:$src), addr:$dst),
 694                 (implicit EFLAGS)]>;
 695
 696 def OR8i8 : Ii8 <0x0C, RawFrm, (outs), (ins i8imm:$src),
 697                  "or{b}\t{$src, %al|%al, $src}", []>;
 698 def OR16i16 : Ii16 <0x0D, RawFrm, (outs), (ins i16imm:$src),
 699                     "or{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 700 def OR32i32 : Ii32 <0x0D, RawFrm, (outs), (ins i32imm:$src),
 701                     "or{l}\t{$src, %eax|%eax, $src}", []>;
 702
 703
 704 let Constraints = "$src1 = $dst" in {
 705
 706 let isCommutable = 1 in { // X = XOR Y, Z --> X = XOR Z, Y
 707   def XOR8rr   : I<0x30, MRMDestReg,
 708                    (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
 709                    "xor{b}\t{$src2, $dst|$dst, $src2}",
 710                    [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
 711                                                         GR8:$src2))]>;
 712   def XOR16rr  : I<0x31, MRMDestReg,
 713                    (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
 714                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 715                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 716                                                          GR16:$src2))]>, OpSize;
 717   def XOR32rr  : I<0x31, MRMDestReg,
 718                    (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
 719                    "xor{l}\t{$src2, $dst|$dst, $src2}",
 720                    [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 721                                                          GR32:$src2))]>;
 722 } // isCommutable = 1
 723
 724 // XOR instructions with the destination register in REG and the source register
 725 //   in R/M.  Included for the disassembler.
 726 let isCodeGenOnly = 1 in {
 727 def XOR8rr_REV : I<0x32, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 728                   "xor{b}\t{$src2, $dst|$dst, $src2}", []>;
 729 def XOR16rr_REV : I<0x33, MRMSrcReg, (outs GR16:$dst),
 730                     (ins GR16:$src1, GR16:$src2),
 731                    "xor{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 732 def XOR32rr_REV : I<0x33, MRMSrcReg, (outs GR32:$dst),
 733                     (ins GR32:$src1, GR32:$src2),
 734                    "xor{l}\t{$src2, $dst|$dst, $src2}", []>;
 735 }
 736
 737 def XOR8rm   : I<0x32, MRMSrcMem,
 738                  (outs GR8 :$dst), (ins GR8:$src1, i8mem :$src2),
 739                  "xor{b}\t{$src2, $dst|$dst, $src2}",
 740                  [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
 741                                                       (load addr:$src2)))]>;
 742 def XOR16rm  : I<0x33, MRMSrcMem,
 743                  (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
 744                  "xor{w}\t{$src2, $dst|$dst, $src2}",
 745                  [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 746                                                        (load addr:$src2)))]>,
 747                  OpSize;
 748 def XOR32rm  : I<0x33, MRMSrcMem,
 749                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
 750                  "xor{l}\t{$src2, $dst|$dst, $src2}",
 751                  [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 752                                                        (load addr:$src2)))]>;
 753
 754 def XOR8ri  : Ii8<0x80, MRM6r,
 755                   (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
 756                   "xor{b}\t{$src2, $dst|$dst, $src2}",
 757                   [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1, imm:$src2))]>;
 758 def XOR16ri : Ii16<0x81, MRM6r,
 759                    (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 760                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 761                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 762                                                          imm:$src2))]>, OpSize;
 763 def XOR32ri  : Ii32<0x81, MRM6r,
 764                     (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 765                     "xor{l}\t{$src2, $dst|$dst, $src2}",
 766                     [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 767                                                           imm:$src2))]>;
 768 def XOR16ri8 : Ii8<0x83, MRM6r,
 769                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 770                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 771                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 772                                                          i16immSExt8:$src2))]>,
 773                    OpSize;
 774 def XOR32ri8 : Ii8<0x83, MRM6r,
 775                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 776                    "xor{l}\t{$src2, $dst|$dst, $src2}",
 777                    [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 778                                                          i32immSExt8:$src2))]>;
 779 } // Constraints = "$src1 = $dst"
 780
 781
 782 def XOR8mr   : I<0x30, MRMDestMem,
 783                  (outs), (ins i8mem :$dst, GR8 :$src),
 784                  "xor{b}\t{$src, $dst|$dst, $src}",
 785                  [(store (xor (load addr:$dst), GR8:$src), addr:$dst),
 786                   (implicit EFLAGS)]>;
 787 def XOR16mr  : I<0x31, MRMDestMem,
 788                  (outs), (ins i16mem:$dst, GR16:$src),
 789                  "xor{w}\t{$src, $dst|$dst, $src}",
 790                  [(store (xor (load addr:$dst), GR16:$src), addr:$dst),
 791                   (implicit EFLAGS)]>,
 792                  OpSize;
 793 def XOR32mr  : I<0x31, MRMDestMem,
 794                  (outs), (ins i32mem:$dst, GR32:$src),
 795                  "xor{l}\t{$src, $dst|$dst, $src}",
 796                  [(store (xor (load addr:$dst), GR32:$src), addr:$dst),
 797                   (implicit EFLAGS)]>;
 798 def XOR8mi   : Ii8<0x80, MRM6m,
 799                    (outs), (ins i8mem :$dst, i8imm :$src),
 800                    "xor{b}\t{$src, $dst|$dst, $src}",
 801                   [(store (xor (loadi8 addr:$dst), imm:$src), addr:$dst),
 802                    (implicit EFLAGS)]>;
 803 def XOR16mi  : Ii16<0x81, MRM6m,
 804                     (outs), (ins i16mem:$dst, i16imm:$src),
 805                     "xor{w}\t{$src, $dst|$dst, $src}",
 806                  [(store (xor (loadi16 addr:$dst), imm:$src), addr:$dst),
 807                   (implicit EFLAGS)]>,
 808                     OpSize;
 809 def XOR32mi  : Ii32<0x81, MRM6m,
 810                     (outs), (ins i32mem:$dst, i32imm:$src),
 811                     "xor{l}\t{$src, $dst|$dst, $src}",
 812                  [(store (xor (loadi32 addr:$dst), imm:$src), addr:$dst),
 813                   (implicit EFLAGS)]>;
 814 def XOR16mi8 : Ii8<0x83, MRM6m,
 815                    (outs), (ins i16mem:$dst, i16i8imm :$src),
 816                    "xor{w}\t{$src, $dst|$dst, $src}",
 817                [(store (xor (load addr:$dst), i16immSExt8:$src), addr:$dst),
 818                 (implicit EFLAGS)]>,
 819                    OpSize;
 820 def XOR32mi8 : Ii8<0x83, MRM6m,
 821                    (outs), (ins i32mem:$dst, i32i8imm :$src),
 822                    "xor{l}\t{$src, $dst|$dst, $src}",
 823                [(store (xor (load addr:$dst), i32immSExt8:$src), addr:$dst),
 824                 (implicit EFLAGS)]>;
 825
 826 def XOR8i8   : Ii8 <0x34, RawFrm, (outs), (ins i8imm:$src),
 827                     "xor{b}\t{$src, %al|%al, $src}", []>;
 828 def XOR16i16 : Ii16<0x35, RawFrm, (outs), (ins i16imm:$src),
 829                     "xor{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 830 def XOR32i32 : Ii32<0x35, RawFrm, (outs), (ins i32imm:$src),
 831                     "xor{l}\t{$src, %eax|%eax, $src}", []>;
 832 } // Defs = [EFLAGS]
 833
 834
 835 // Arithmetic.
 836 let Defs = [EFLAGS] in {
 837 let Constraints = "$src1 = $dst" in {
 838 let isCommutable = 1 in {   // X = ADD Y, Z   --> X = ADD Z, Y
 839 // Register-Register Addition
 840 def ADD8rr    : I<0x00, MRMDestReg, (outs GR8 :$dst),
 841                                     (ins GR8 :$src1, GR8 :$src2),
 842                   "add{b}\t{$src2, $dst|$dst, $src2}",
 843                   [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1, GR8:$src2))]>;
 844
 845 let isConvertibleToThreeAddress = 1 in {   // Can transform into LEA.
 846 // Register-Register Addition
 847 def ADD16rr  : I<0x01, MRMDestReg, (outs GR16:$dst),
 848                                    (ins GR16:$src1, GR16:$src2),
 849                  "add{w}\t{$src2, $dst|$dst, $src2}",
 850                  [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
 851                                                        GR16:$src2))]>, OpSize;
 852 def ADD32rr  : I<0x01, MRMDestReg, (outs GR32:$dst),
 853                                    (ins GR32:$src1, GR32:$src2),
 854                  "add{l}\t{$src2, $dst|$dst, $src2}",
 855                  [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
 856                                                        GR32:$src2))]>;
 857 def ADD64rr    : RI<0x01, MRMDestReg, (outs GR64:$dst),
 858                     (ins GR64:$src1, GR64:$src2),
 859                     "add{q}\t{$src2, $dst|$dst, $src2}",
 860                     [(set GR64:$dst, EFLAGS,
 861                           (X86add_flag GR64:$src1, GR64:$src2))]>;
 862 } // end isConvertibleToThreeAddress
 863 } // end isCommutable
 864
 865 // These are alternate spellings for use by the disassembler, we mark them as
 866 // code gen only to ensure they aren't matched by the assembler.
 867 let isCodeGenOnly = 1 in {
 868   def ADD8rr_alt: I<0x02, MRMSrcReg,
 869                     (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 870                    "add{b}\t{$src2, $dst|$dst, $src2}", []>;
 871   def ADD16rr_alt: I<0x03, MRMSrcReg,
 872                     (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
 873                     "add{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 874   def ADD32rr_alt: I<0x03, MRMSrcReg,
 875                      (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
 876                     "add{l}\t{$src2, $dst|$dst, $src2}", []>;
 877   def ADD64rr_alt : RI<0x03, MRMSrcReg,
 878                        (outs GR64:$dst), (ins GR64:$src1, GR64:$src2),
 879                        "add{l}\t{$src2, $dst|$dst, $src2}", []>;
 880 }
 881
 882 // Register-Memory Addition
 883 def ADD8rm   : I<0x02, MRMSrcMem, (outs GR8 :$dst),
 884                                   (ins GR8 :$src1, i8mem :$src2),
 885                  "add{b}\t{$src2, $dst|$dst, $src2}",
 886                  [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1,
 887                                                       (load addr:$src2)))]>;
 888 def ADD16rm  : I<0x03, MRMSrcMem, (outs GR16:$dst),
 889                                   (ins GR16:$src1, i16mem:$src2),
 890                  "add{w}\t{$src2, $dst|$dst, $src2}",
 891                  [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
 892                                                   (load addr:$src2)))]>, OpSize;
 893 def ADD32rm  : I<0x03, MRMSrcMem, (outs GR32:$dst),
 894                                   (ins GR32:$src1, i32mem:$src2),
 895                  "add{l}\t{$src2, $dst|$dst, $src2}",
 896                  [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
 897                                                        (load addr:$src2)))]>;
 898 def ADD64rm     : RI<0x03, MRMSrcMem, (outs GR64:$dst),
 899                      (ins GR64:$src1, i64mem:$src2),
 900                      "add{q}\t{$src2, $dst|$dst, $src2}",
 901                      [(set GR64:$dst, EFLAGS,
 902                            (X86add_flag GR64:$src1, (load addr:$src2)))]>;
 903
 904 // Register-Integer Addition
 905 def ADD8ri    : Ii8<0x80, MRM0r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
 906                     "add{b}\t{$src2, $dst|$dst, $src2}",
 907                     [(set GR8:$dst, EFLAGS,
 908                           (X86add_flag GR8:$src1, imm:$src2))]>;
 909
 910 let isConvertibleToThreeAddress = 1 in {   // Can transform into LEA.
 911 // Register-Integer Addition
 912 def ADD16ri  : Ii16<0x81, MRM0r, (outs GR16:$dst),
 913                                  (ins GR16:$src1, i16imm:$src2),
 914                     "add{w}\t{$src2, $dst|$dst, $src2}",
 915                     [(set GR16:$dst, EFLAGS,
 916                           (X86add_flag GR16:$src1, imm:$src2))]>, OpSize;
 917 def ADD32ri  : Ii32<0x81, MRM0r, (outs GR32:$dst),
 918                                  (ins GR32:$src1, i32imm:$src2),
 919                     "add{l}\t{$src2, $dst|$dst, $src2}",
 920                     [(set GR32:$dst, EFLAGS,
 921                           (X86add_flag GR32:$src1, imm:$src2))]>;
 922 def ADD16ri8 : Ii8<0x83, MRM0r, (outs GR16:$dst),
 923                                 (ins GR16:$src1, i16i8imm:$src2),
 924                    "add{w}\t{$src2, $dst|$dst, $src2}",
 925                    [(set GR16:$dst, EFLAGS,
 926                          (X86add_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
 927 def ADD32ri8 : Ii8<0x83, MRM0r, (outs GR32:$dst),
 928                                 (ins GR32:$src1, i32i8imm:$src2),
 929                    "add{l}\t{$src2, $dst|$dst, $src2}",
 930                    [(set GR32:$dst, EFLAGS,
 931                          (X86add_flag GR32:$src1, i32immSExt8:$src2))]>;
 932 def ADD64ri8  : RIi8<0x83, MRM0r, (outs GR64:$dst),
 933                      (ins GR64:$src1, i64i8imm:$src2),
 934                      "add{q}\t{$src2, $dst|$dst, $src2}",
 935                      [(set GR64:$dst, EFLAGS,
 936                            (X86add_flag GR64:$src1, i64immSExt8:$src2))]>;
 937 def ADD64ri32 : RIi32<0x81, MRM0r, (outs GR64:$dst),
 938                       (ins GR64:$src1, i64i32imm:$src2),
 939                       "add{q}\t{$src2, $dst|$dst, $src2}",
 940                       [(set GR64:$dst, EFLAGS,
 941                             (X86add_flag GR64:$src1, i64immSExt32:$src2))]>;
 942 }
 943 } // Constraints = "$src1 = $dst"
 944
 945 // Memory-Register Addition
 946 def ADD8mr   : I<0x00, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
 947                  "add{b}\t{$src2, $dst|$dst, $src2}",
 948                  [(store (add (load addr:$dst), GR8:$src2), addr:$dst),
 949                   (implicit EFLAGS)]>;
 950 def ADD16mr  : I<0x01, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
 951                  "add{w}\t{$src2, $dst|$dst, $src2}",
 952                  [(store (add (load addr:$dst), GR16:$src2), addr:$dst),
 953                   (implicit EFLAGS)]>, OpSize;
 954 def ADD32mr  : I<0x01, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
 955                  "add{l}\t{$src2, $dst|$dst, $src2}",
 956                  [(store (add (load addr:$dst), GR32:$src2), addr:$dst),
 957                   (implicit EFLAGS)]>;
 958 def ADD64mr  : RI<0x01, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
 959                   "add{q}\t{$src2, $dst|$dst, $src2}",
 960                   [(store (add (load addr:$dst), GR64:$src2), addr:$dst),
 961                    (implicit EFLAGS)]>;
 962 def ADD8mi   : Ii8<0x80, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src2),
 963                    "add{b}\t{$src2, $dst|$dst, $src2}",
 964                  [(store (add (loadi8 addr:$dst), imm:$src2), addr:$dst),
 965                   (implicit EFLAGS)]>;
 966 def ADD16mi  : Ii16<0x81, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src2),
 967                     "add{w}\t{$src2, $dst|$dst, $src2}",
 968                 [(store (add (loadi16 addr:$dst), imm:$src2), addr:$dst),
 969                  (implicit EFLAGS)]>, OpSize;
 970 def ADD32mi  : Ii32<0x81, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src2),
 971                     "add{l}\t{$src2, $dst|$dst, $src2}",
 972                     [(store (add (loadi32 addr:$dst), imm:$src2), addr:$dst),
 973                      (implicit EFLAGS)]>;
 974 def ADD64mi32 : RIi32<0x81, MRM0m, (outs), (ins i64mem:$dst, i64i32imm :$src2),
 975                       "add{q}\t{$src2, $dst|$dst, $src2}",
 976                [(store (add (load addr:$dst), i64immSExt32:$src2), addr:$dst),
 977                 (implicit EFLAGS)]>;
 978 def ADD16mi8 : Ii8<0x83, MRM0m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
 979                    "add{w}\t{$src2, $dst|$dst, $src2}",
 980                    [(store (add (load addr:$dst), i16immSExt8:$src2),
 981                                 addr:$dst),
 982                     (implicit EFLAGS)]>, OpSize;
 983 def ADD32mi8 : Ii8<0x83, MRM0m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
 984                    "add{l}\t{$src2, $dst|$dst, $src2}",
 985                 [(store (add (load addr:$dst), i32immSExt8:$src2),
 986                              addr:$dst),
 987                  (implicit EFLAGS)]>;
 988 def ADD64mi8 : RIi8<0x83, MRM0m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
 989                     "add{q}\t{$src2, $dst|$dst, $src2}",
 990                 [(store (add (load addr:$dst), i64immSExt8:$src2), addr:$dst),
 991                  (implicit EFLAGS)]>;
 992
 993 // addition to rAX
 994 def ADD8i8 : Ii8<0x04, RawFrm, (outs), (ins i8imm:$src),
 995                  "add{b}\t{$src, %al|%al, $src}", []>;
 996 def ADD16i16 : Ii16<0x05, RawFrm, (outs), (ins i16imm:$src),
 997                     "add{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 998 def ADD32i32 : Ii32<0x05, RawFrm, (outs), (ins i32imm:$src),
 999                     "add{l}\t{$src, %eax|%eax, $src}", []>;
1000 def ADD64i32 : RIi32<0x05, RawFrm, (outs), (ins i64i32imm:$src),
1001                      "add{q}\t{$src, %rax|%rax, $src}", []>;
1002
1003 let Uses = [EFLAGS] in {
1004 let Constraints = "$src1 = $dst" in {
1005 let isCommutable = 1 in {  // X = ADC Y, Z --> X = ADC Z, Y
1006 def ADC8rr   : I<0x10, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1007                  "adc{b}\t{$src2, $dst|$dst, $src2}",
1008                  [(set GR8:$dst, (adde GR8:$src1, GR8:$src2))]>;
1009 def ADC16rr  : I<0x11, MRMDestReg, (outs GR16:$dst),
1010                                    (ins GR16:$src1, GR16:$src2),
1011                  "adc{w}\t{$src2, $dst|$dst, $src2}",
1012                  [(set GR16:$dst, (adde GR16:$src1, GR16:$src2))]>, OpSize;
1013 def ADC32rr  : I<0x11, MRMDestReg, (outs GR32:$dst),
1014                                    (ins GR32:$src1, GR32:$src2),
1015                  "adc{l}\t{$src2, $dst|$dst, $src2}",
1016                  [(set GR32:$dst, (adde GR32:$src1, GR32:$src2))]>;
1017 def ADC64rr  : RI<0x11, MRMDestReg, (outs GR64:$dst),
1018                   (ins GR64:$src1, GR64:$src2),
1019                   "adc{q}\t{$src2, $dst|$dst, $src2}",
1020                   [(set GR64:$dst, (adde GR64:$src1, GR64:$src2))]>;
1021 }
1022
1023 let isCodeGenOnly = 1 in {
1024 def ADC8rr_REV : I<0x12, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1025                  "adc{b}\t{$src2, $dst|$dst, $src2}", []>;
1026 def ADC16rr_REV : I<0x13, MRMSrcReg, (outs GR16:$dst),
1027                     (ins GR16:$src1, GR16:$src2),
1028                     "adc{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1029 def ADC32rr_REV : I<0x13, MRMSrcReg, (outs GR32:$dst),
1030                     (ins GR32:$src1, GR32:$src2),
1031                     "adc{l}\t{$src2, $dst|$dst, $src2}", []>;
1032 def ADC64rr_REV : RI<0x13, MRMSrcReg , (outs GR32:$dst),
1033                      (ins GR64:$src1, GR64:$src2),
1034                     "adc{q}\t{$src2, $dst|$dst, $src2}", []>;
1035 }
1036
1037 def ADC8rm   : I<0x12, MRMSrcMem ,
1038                  (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1039                  "adc{b}\t{$src2, $dst|$dst, $src2}",
1040                  [(set GR8:$dst, (adde GR8:$src1, (load addr:$src2)))]>;
1041 def ADC16rm  : I<0x13, MRMSrcMem , (outs GR16:$dst),
1042                                    (ins GR16:$src1, i16mem:$src2),
1043                  "adc{w}\t{$src2, $dst|$dst, $src2}",
1044                  [(set GR16:$dst, (adde GR16:$src1, (load addr:$src2)))]>,
1045                  OpSize;
1046 def ADC32rm  : I<0x13, MRMSrcMem ,
1047                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
1048                  "adc{l}\t{$src2, $dst|$dst, $src2}",
1049                  [(set GR32:$dst, (adde GR32:$src1, (load addr:$src2)))]>;
1050 def ADC64rm  : RI<0x13, MRMSrcMem , (outs GR64:$dst),
1051                   (ins GR64:$src1, i64mem:$src2),
1052                   "adc{q}\t{$src2, $dst|$dst, $src2}",
1053                   [(set GR64:$dst, (adde GR64:$src1, (load addr:$src2)))]>;
1054 def ADC8ri   : Ii8<0x80, MRM2r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1055                     "adc{b}\t{$src2, $dst|$dst, $src2}",
1056                  [(set GR8:$dst, (adde GR8:$src1, imm:$src2))]>;
1057 def ADC16ri  : Ii16<0x81, MRM2r,
1058                     (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
1059                     "adc{w}\t{$src2, $dst|$dst, $src2}",
1060                  [(set GR16:$dst, (adde GR16:$src1, imm:$src2))]>, OpSize;
1061 def ADC16ri8 : Ii8<0x83, MRM2r, (outs GR16:$dst),
1062                                 (ins GR16:$src1, i16i8imm:$src2),
1063                    "adc{w}\t{$src2, $dst|$dst, $src2}",
1064                  [(set GR16:$dst, (adde GR16:$src1, i16immSExt8:$src2))]>,
1065                  OpSize;
1066 def ADC32ri  : Ii32<0x81, MRM2r, (outs GR32:$dst),
1067                                  (ins GR32:$src1, i32imm:$src2),
1068                     "adc{l}\t{$src2, $dst|$dst, $src2}",
1069                  [(set GR32:$dst, (adde GR32:$src1, imm:$src2))]>;
1070 def ADC32ri8 : Ii8<0x83, MRM2r, (outs GR32:$dst),
1071                                 (ins GR32:$src1, i32i8imm:$src2),
1072                    "adc{l}\t{$src2, $dst|$dst, $src2}",
1073                  [(set GR32:$dst, (adde GR32:$src1, i32immSExt8:$src2))]>;
1074 def ADC64ri32 : RIi32<0x81, MRM2r, (outs GR64:$dst),
1075                       (ins GR64:$src1, i64i32imm:$src2),
1076                       "adc{q}\t{$src2, $dst|$dst, $src2}",
1077                       [(set GR64:$dst, (adde GR64:$src1, i64immSExt32:$src2))]>;
1078 def ADC64ri8 : RIi8<0x83, MRM2r, (outs GR64:$dst),
1079                     (ins GR64:$src1, i64i8imm:$src2),
1080                     "adc{q}\t{$src2, $dst|$dst, $src2}",
1081                     [(set GR64:$dst, (adde GR64:$src1, i64immSExt8:$src2))]>;
1082 } // Constraints = "$src1 = $dst"
1083
1084 def ADC8mr   : I<0x10, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1085                  "adc{b}\t{$src2, $dst|$dst, $src2}",
1086                  [(store (adde (load addr:$dst), GR8:$src2), addr:$dst)]>;
1087 def ADC16mr  : I<0x11, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1088                  "adc{w}\t{$src2, $dst|$dst, $src2}",
1089                  [(store (adde (load addr:$dst), GR16:$src2), addr:$dst)]>,
1090                  OpSize;
1091 def ADC32mr  : I<0x11, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1092                  "adc{l}\t{$src2, $dst|$dst, $src2}",
1093                  [(store (adde (load addr:$dst), GR32:$src2), addr:$dst)]>;
1094 def ADC64mr  : RI<0x11, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1095                   "adc{q}\t{$src2, $dst|$dst, $src2}",
1096                   [(store (adde (load addr:$dst), GR64:$src2), addr:$dst)]>;
1097 def ADC8mi   : Ii8<0x80, MRM2m, (outs), (ins i8mem:$dst, i8imm:$src2),
1098                     "adc{b}\t{$src2, $dst|$dst, $src2}",
1099                 [(store (adde (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1100 def ADC16mi  : Ii16<0x81, MRM2m, (outs), (ins i16mem:$dst, i16imm:$src2),
1101                     "adc{w}\t{$src2, $dst|$dst, $src2}",
1102                 [(store (adde (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1103                 OpSize;
1104 def ADC16mi8 : Ii8<0x83, MRM2m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1105                    "adc{w}\t{$src2, $dst|$dst, $src2}",
1106              [(store (adde (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1107              OpSize;
1108 def ADC32mi  : Ii32<0x81, MRM2m, (outs), (ins i32mem:$dst, i32imm:$src2),
1109                     "adc{l}\t{$src2, $dst|$dst, $src2}",
1110                 [(store (adde (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1111 def ADC32mi8 : Ii8<0x83, MRM2m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1112                    "adc{l}\t{$src2, $dst|$dst, $src2}",
1113              [(store (adde (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1114
1115 def ADC64mi32 : RIi32<0x81, MRM2m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
1116                       "adc{q}\t{$src2, $dst|$dst, $src2}",
1117                  [(store (adde (load addr:$dst), i64immSExt32:$src2),
1118                   addr:$dst)]>;
1119 def ADC64mi8 : RIi8<0x83, MRM2m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1120                     "adc{q}\t{$src2, $dst|$dst, $src2}",
1121                  [(store (adde (load addr:$dst), i64immSExt8:$src2),
1122                   addr:$dst)]>;
1123
1124 def ADC8i8 : Ii8<0x14, RawFrm, (outs), (ins i8imm:$src),
1125                  "adc{b}\t{$src, %al|%al, $src}", []>;
1126 def ADC16i16 : Ii16<0x15, RawFrm, (outs), (ins i16imm:$src),
1127                     "adc{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1128 def ADC32i32 : Ii32<0x15, RawFrm, (outs), (ins i32imm:$src),
1129                     "adc{l}\t{$src, %eax|%eax, $src}", []>;
1130 def ADC64i32 : RIi32<0x15, RawFrm, (outs), (ins i64i32imm:$src),
1131                      "adc{q}\t{$src, %rax|%rax, $src}", []>;
1132 } // Uses = [EFLAGS]
1133
1134 let Constraints = "$src1 = $dst" in {
1135
1136 // Register-Register Subtraction
1137 def SUB8rr  : I<0x28, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1138                 "sub{b}\t{$src2, $dst|$dst, $src2}",
1139                 [(set GR8:$dst, EFLAGS,
1140                       (X86sub_flag GR8:$src1, GR8:$src2))]>;
1141 def SUB16rr : I<0x29, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
1142                 "sub{w}\t{$src2, $dst|$dst, $src2}",
1143                 [(set GR16:$dst, EFLAGS,
1144                       (X86sub_flag GR16:$src1, GR16:$src2))]>, OpSize;
1145 def SUB32rr : I<0x29, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
1146                 "sub{l}\t{$src2, $dst|$dst, $src2}",
1147                 [(set GR32:$dst, EFLAGS,
1148                       (X86sub_flag GR32:$src1, GR32:$src2))]>;
1149 def SUB64rr  : RI<0x29, MRMDestReg, (outs GR64:$dst),
1150                   (ins GR64:$src1, GR64:$src2),
1151                   "sub{q}\t{$src2, $dst|$dst, $src2}",
1152                   [(set GR64:$dst, EFLAGS,
1153                         (X86sub_flag GR64:$src1, GR64:$src2))]>;
1154
1155 let isCodeGenOnly = 1 in {
1156 def SUB8rr_REV : I<0x2A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1157                    "sub{b}\t{$src2, $dst|$dst, $src2}", []>;
1158 def SUB16rr_REV : I<0x2B, MRMSrcReg, (outs GR16:$dst),
1159                     (ins GR16:$src1, GR16:$src2),
1160                     "sub{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1161 def SUB32rr_REV : I<0x2B, MRMSrcReg, (outs GR32:$dst),
1162                     (ins GR32:$src1, GR32:$src2),
1163                     "sub{l}\t{$src2, $dst|$dst, $src2}", []>;
1164 def SUB64rr_REV : RI<0x2B, MRMSrcReg, (outs GR64:$dst),
1165                      (ins GR64:$src1, GR64:$src2),
1166                      "sub{q}\t{$src2, $dst|$dst, $src2}", []>;
1167 }
1168
1169 // Register-Memory Subtraction
1170 def SUB8rm  : I<0x2A, MRMSrcMem, (outs GR8 :$dst),
1171                                  (ins GR8 :$src1, i8mem :$src2),
1172                 "sub{b}\t{$src2, $dst|$dst, $src2}",
1173                 [(set GR8:$dst, EFLAGS,
1174                       (X86sub_flag GR8:$src1, (load addr:$src2)))]>;
1175 def SUB16rm : I<0x2B, MRMSrcMem, (outs GR16:$dst),
1176                                  (ins GR16:$src1, i16mem:$src2),
1177                 "sub{w}\t{$src2, $dst|$dst, $src2}",
1178                 [(set GR16:$dst, EFLAGS,
1179                       (X86sub_flag GR16:$src1, (load addr:$src2)))]>, OpSize;
1180 def SUB32rm : I<0x2B, MRMSrcMem, (outs GR32:$dst),
1181                                  (ins GR32:$src1, i32mem:$src2),
1182                 "sub{l}\t{$src2, $dst|$dst, $src2}",
1183                 [(set GR32:$dst, EFLAGS,
1184                       (X86sub_flag GR32:$src1, (load addr:$src2)))]>;
1185 def SUB64rm  : RI<0x2B, MRMSrcMem, (outs GR64:$dst),
1186                   (ins GR64:$src1, i64mem:$src2),
1187                   "sub{q}\t{$src2, $dst|$dst, $src2}",
1188                   [(set GR64:$dst, EFLAGS,
1189                         (X86sub_flag GR64:$src1, (load addr:$src2)))]>;
1190
1191 // Register-Integer Subtraction
1192 def SUB8ri   : Ii8 <0x80, MRM5r, (outs GR8:$dst),
1193                                  (ins GR8:$src1, i8imm:$src2),
1194                     "sub{b}\t{$src2, $dst|$dst, $src2}",
1195                     [(set GR8:$dst, EFLAGS,
1196                           (X86sub_flag GR8:$src1, imm:$src2))]>;
1197 def SUB16ri  : Ii16<0x81, MRM5r, (outs GR16:$dst),
1198                                  (ins GR16:$src1, i16imm:$src2),
1199                     "sub{w}\t{$src2, $dst|$dst, $src2}",
1200                     [(set GR16:$dst, EFLAGS,
1201                           (X86sub_flag GR16:$src1, imm:$src2))]>, OpSize;
1202 def SUB32ri  : Ii32<0x81, MRM5r, (outs GR32:$dst),
1203                                  (ins GR32:$src1, i32imm:$src2),
1204                     "sub{l}\t{$src2, $dst|$dst, $src2}",
1205                     [(set GR32:$dst, EFLAGS,
1206                           (X86sub_flag GR32:$src1, imm:$src2))]>;
1207 def SUB64ri32 : RIi32<0x81, MRM5r, (outs GR64:$dst),
1208                                    (ins GR64:$src1, i64i32imm:$src2),
1209                       "sub{q}\t{$src2, $dst|$dst, $src2}",
1210                       [(set GR64:$dst, EFLAGS,
1211                             (X86sub_flag GR64:$src1, i64immSExt32:$src2))]>;
1212 def SUB16ri8 : Ii8<0x83, MRM5r, (outs GR16:$dst),
1213                                 (ins GR16:$src1, i16i8imm:$src2),
1214                    "sub{w}\t{$src2, $dst|$dst, $src2}",
1215                    [(set GR16:$dst, EFLAGS,
1216                          (X86sub_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
1217 def SUB32ri8 : Ii8<0x83, MRM5r, (outs GR32:$dst),
1218                                 (ins GR32:$src1, i32i8imm:$src2),
1219                    "sub{l}\t{$src2, $dst|$dst, $src2}",
1220                    [(set GR32:$dst, EFLAGS,
1221                          (X86sub_flag GR32:$src1, i32immSExt8:$src2))]>;
1222 def SUB64ri8 : RIi8<0x83, MRM5r, (outs GR64:$dst),
1223                                  (ins GR64:$src1, i64i8imm:$src2),
1224                     "sub{q}\t{$src2, $dst|$dst, $src2}",
1225                     [(set GR64:$dst, EFLAGS,
1226                           (X86sub_flag GR64:$src1, i64immSExt8:$src2))]>;
1227 } // Constraints = "$src1 = $dst"
1228
1229 // Memory-Register Subtraction
1230 def SUB8mr   : I<0x28, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src2),
1231                  "sub{b}\t{$src2, $dst|$dst, $src2}",
1232                  [(store (sub (load addr:$dst), GR8:$src2), addr:$dst),
1233                   (implicit EFLAGS)]>;
1234 def SUB16mr  : I<0x29, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1235                  "sub{w}\t{$src2, $dst|$dst, $src2}",
1236                  [(store (sub (load addr:$dst), GR16:$src2), addr:$dst),
1237                   (implicit EFLAGS)]>, OpSize;
1238 def SUB32mr  : I<0x29, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1239                  "sub{l}\t{$src2, $dst|$dst, $src2}",
1240                  [(store (sub (load addr:$dst), GR32:$src2), addr:$dst),
1241                   (implicit EFLAGS)]>;
1242 def SUB64mr  : RI<0x29, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1243                   "sub{q}\t{$src2, $dst|$dst, $src2}",
1244                   [(store (sub (load addr:$dst), GR64:$src2), addr:$dst),
1245                    (implicit EFLAGS)]>;
1246
1247 // Memory-Integer Subtraction
1248 def SUB8mi   : Ii8<0x80, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src2),
1249                    "sub{b}\t{$src2, $dst|$dst, $src2}",
1250                    [(store (sub (loadi8 addr:$dst), imm:$src2), addr:$dst),
1251                     (implicit EFLAGS)]>;
1252 def SUB16mi  : Ii16<0x81, MRM5m, (outs), (ins i16mem:$dst, i16imm:$src2),
1253                     "sub{w}\t{$src2, $dst|$dst, $src2}",
1254                     [(store (sub (loadi16 addr:$dst), imm:$src2),addr:$dst),
1255                      (implicit EFLAGS)]>, OpSize;
1256 def SUB32mi  : Ii32<0x81, MRM5m, (outs), (ins i32mem:$dst, i32imm:$src2),
1257                     "sub{l}\t{$src2, $dst|$dst, $src2}",
1258                     [(store (sub (loadi32 addr:$dst), imm:$src2),addr:$dst),
1259                      (implicit EFLAGS)]>;
1260 def SUB64mi32 : RIi32<0x81, MRM5m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
1261                       "sub{q}\t{$src2, $dst|$dst, $src2}",
1262                       [(store (sub (load addr:$dst), i64immSExt32:$src2),
1263                               addr:$dst),
1264                        (implicit EFLAGS)]>;
1265 def SUB16mi8 : Ii8<0x83, MRM5m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1266                    "sub{w}\t{$src2, $dst|$dst, $src2}",
1267                    [(store (sub (load addr:$dst), i16immSExt8:$src2),
1268                            addr:$dst),
1269                     (implicit EFLAGS)]>, OpSize;
1270 def SUB32mi8 : Ii8<0x83, MRM5m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1271                    "sub{l}\t{$src2, $dst|$dst, $src2}",
1272                    [(store (sub (load addr:$dst), i32immSExt8:$src2),
1273                            addr:$dst),
1274                     (implicit EFLAGS)]>;
1275 def SUB64mi8 : RIi8<0x83, MRM5m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1276                     "sub{q}\t{$src2, $dst|$dst, $src2}",
1277                     [(store (sub (load addr:$dst), i64immSExt8:$src2),
1278                             addr:$dst),
1279                      (implicit EFLAGS)]>;
1280
1281 def SUB8i8 : Ii8<0x2C, RawFrm, (outs), (ins i8imm:$src),
1282                  "sub{b}\t{$src, %al|%al, $src}", []>;
1283 def SUB16i16 : Ii16<0x2D, RawFrm, (outs), (ins i16imm:$src),
1284                     "sub{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1285 def SUB32i32 : Ii32<0x2D, RawFrm, (outs), (ins i32imm:$src),
1286                     "sub{l}\t{$src, %eax|%eax, $src}", []>;
1287 def SUB64i32 : RIi32<0x2D, RawFrm, (outs), (ins i64i32imm:$src),
1288                      "sub{q}\t{$src, %rax|%rax, $src}", []>;
1289
1290 let Uses = [EFLAGS] in {
1291 let Constraints = "$src1 = $dst" in {
1292 def SBB8rr     : I<0x18, MRMDestReg, (outs GR8:$dst),
1293                                      (ins GR8:$src1, GR8:$src2),
1294                   "sbb{b}\t{$src2, $dst|$dst, $src2}",
1295                  [(set GR8:$dst, (sube GR8:$src1, GR8:$src2))]>;
1296 def SBB16rr    : I<0x19, MRMDestReg, (outs GR16:$dst),
1297                                      (ins GR16:$src1, GR16:$src2),
1298                   "sbb{w}\t{$src2, $dst|$dst, $src2}",
1299                  [(set GR16:$dst, (sube GR16:$src1, GR16:$src2))]>, OpSize;
1300 def SBB32rr    : I<0x19, MRMDestReg, (outs GR32:$dst),
1301                                       (ins GR32:$src1, GR32:$src2),
1302                   "sbb{l}\t{$src2, $dst|$dst, $src2}",
1303                  [(set GR32:$dst, (sube GR32:$src1, GR32:$src2))]>;
1304 def SBB64rr    : RI<0x19, MRMDestReg, (outs GR64:$dst),
1305                     (ins GR64:$src1, GR64:$src2),
1306                     "sbb{q}\t{$src2, $dst|$dst, $src2}",
1307                     [(set GR64:$dst, (sube GR64:$src1, GR64:$src2))]>;
1308 } // Constraints = "$src1 = $dst"
1309
1310
1311 def SBB8mr   : I<0x18, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1312                  "sbb{b}\t{$src2, $dst|$dst, $src2}",
1313                  [(store (sube (load addr:$dst), GR8:$src2), addr:$dst)]>;
1314 def SBB16mr  : I<0x19, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1315                  "sbb{w}\t{$src2, $dst|$dst, $src2}",
1316                  [(store (sube (load addr:$dst), GR16:$src2), addr:$dst)]>,
1317                  OpSize;
1318 def SBB32mr  : I<0x19, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1319                  "sbb{l}\t{$src2, $dst|$dst, $src2}",
1320                  [(store (sube (load addr:$dst), GR32:$src2), addr:$dst)]>;
1321 def SBB64mr  : RI<0x19, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1322                   "sbb{q}\t{$src2, $dst|$dst, $src2}",
1323                   [(store (sube (load addr:$dst), GR64:$src2), addr:$dst)]>;
1324
1325 def SBB8mi  : Ii8<0x80, MRM3m, (outs), (ins i8mem:$dst, i8imm:$src2),
1326                   "sbb{b}\t{$src2, $dst|$dst, $src2}",
1327                  [(store (sube (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1328 def SBB16mi  : Ii16<0x81, MRM3m, (outs), (ins i16mem:$dst, i16imm:$src2),
1329                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1330                 [(store (sube (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1331                 OpSize;
1332 def SBB16mi8 : Ii8<0x83, MRM3m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1333                    "sbb{w}\t{$src2, $dst|$dst, $src2}",
1334              [(store (sube (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1335              OpSize;
1336 def SBB32mi  : Ii32<0x81, MRM3m, (outs), (ins i32mem:$dst, i32imm:$src2),
1337                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1338                 [(store (sube (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1339 def SBB32mi8 : Ii8<0x83, MRM3m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1340                    "sbb{l}\t{$src2, $dst|$dst, $src2}",
1341              [(store (sube (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1342 def SBB64mi32 : RIi32<0x81, MRM3m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
1343                       "sbb{q}\t{$src2, $dst|$dst, $src2}",
1344               [(store (sube (load addr:$dst), i64immSExt32:$src2), addr:$dst)]>;
1345 def SBB64mi8 : RIi8<0x83, MRM3m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1346                     "sbb{q}\t{$src2, $dst|$dst, $src2}",
1347                [(store (sube (load addr:$dst), i64immSExt8:$src2), addr:$dst)]>;
1348
1349 def SBB8i8 : Ii8<0x1C, RawFrm, (outs), (ins i8imm:$src),
1350                  "sbb{b}\t{$src, %al|%al, $src}", []>;
1351 def SBB16i16 : Ii16<0x1D, RawFrm, (outs), (ins i16imm:$src),
1352                     "sbb{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1353 def SBB32i32 : Ii32<0x1D, RawFrm, (outs), (ins i32imm:$src),
1354                     "sbb{l}\t{$src, %eax|%eax, $src}", []>;
1355 def SBB64i32 : RIi32<0x1D, RawFrm, (outs), (ins i64i32imm:$src),
1356                      "sbb{q}\t{$src, %rax|%rax, $src}", []>;
1357
1358 let Constraints = "$src1 = $dst" in {
1359
1360 let isCodeGenOnly = 1 in {
1361 def SBB8rr_REV : I<0x1A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1362                    "sbb{b}\t{$src2, $dst|$dst, $src2}", []>;
1363 def SBB16rr_REV : I<0x1B, MRMSrcReg, (outs GR16:$dst),
1364                     (ins GR16:$src1, GR16:$src2),
1365                     "sbb{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1366 def SBB32rr_REV : I<0x1B, MRMSrcReg, (outs GR32:$dst),
1367                     (ins GR32:$src1, GR32:$src2),
1368                     "sbb{l}\t{$src2, $dst|$dst, $src2}", []>;
1369 def SBB64rr_REV : RI<0x1B, MRMSrcReg, (outs GR64:$dst),
1370                      (ins GR64:$src1, GR64:$src2),
1371                      "sbb{q}\t{$src2, $dst|$dst, $src2}", []>;
1372 }
1373
1374 def SBB8rm   : I<0x1A, MRMSrcMem, (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1375                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1376                     [(set GR8:$dst, (sube GR8:$src1, (load addr:$src2)))]>;
1377 def SBB16rm  : I<0x1B, MRMSrcMem, (outs GR16:$dst),
1378                                   (ins GR16:$src1, i16mem:$src2),
1379                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1380                     [(set GR16:$dst, (sube GR16:$src1, (load addr:$src2)))]>,
1381                     OpSize;
1382 def SBB32rm  : I<0x1B, MRMSrcMem, (outs GR32:$dst),
1383                                   (ins GR32:$src1, i32mem:$src2),
1384                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1385                     [(set GR32:$dst, (sube GR32:$src1, (load addr:$src2)))]>;
1386 def SBB64rm  : RI<0x1B, MRMSrcMem, (outs GR64:$dst),
1387                   (ins GR64:$src1, i64mem:$src2),
1388                   "sbb{q}\t{$src2, $dst|$dst, $src2}",
1389                   [(set GR64:$dst, (sube GR64:$src1, (load addr:$src2)))]>;
1390 def SBB8ri   : Ii8<0x80, MRM3r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1391                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1392                     [(set GR8:$dst, (sube GR8:$src1, imm:$src2))]>;
1393 def SBB16ri  : Ii16<0x81, MRM3r, (outs GR16:$dst),
1394                                  (ins GR16:$src1, i16imm:$src2),
1395                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1396                     [(set GR16:$dst, (sube GR16:$src1, imm:$src2))]>, OpSize;
1397 def SBB16ri8 : Ii8<0x83, MRM3r, (outs GR16:$dst),
1398                                 (ins GR16:$src1, i16i8imm:$src2),
1399                    "sbb{w}\t{$src2, $dst|$dst, $src2}",
1400                    [(set GR16:$dst, (sube GR16:$src1, i16immSExt8:$src2))]>,
1401                    OpSize;
1402 def SBB32ri  : Ii32<0x81, MRM3r, (outs GR32:$dst),
1403                                  (ins GR32:$src1, i32imm:$src2),
1404                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1405                     [(set GR32:$dst, (sube GR32:$src1, imm:$src2))]>;
1406 def SBB32ri8 : Ii8<0x83, MRM3r, (outs GR32:$dst),
1407                                 (ins GR32:$src1, i32i8imm:$src2),
1408                    "sbb{l}\t{$src2, $dst|$dst, $src2}",
1409                    [(set GR32:$dst, (sube GR32:$src1, i32immSExt8:$src2))]>;
1410 def SBB64ri32 : RIi32<0x81, MRM3r, (outs GR64:$dst),
1411                       (ins GR64:$src1, i64i32imm:$src2),
1412                       "sbb{q}\t{$src2, $dst|$dst, $src2}",
1413                       [(set GR64:$dst, (sube GR64:$src1, i64immSExt32:$src2))]>;
1414 def SBB64ri8 : RIi8<0x83, MRM3r, (outs GR64:$dst),
1415                     (ins GR64:$src1, i64i8imm:$src2),
1416                     "sbb{q}\t{$src2, $dst|$dst, $src2}",
1417                     [(set GR64:$dst, (sube GR64:$src1, i64immSExt8:$src2))]>;
1418
1419 } // Constraints = "$src1 = $dst"
1420 } // Uses = [EFLAGS]
1421 } // Defs = [EFLAGS]
1422
1423 //===----------------------------------------------------------------------===//
1424 // Test instructions are just like AND, except they don't generate a result.
1425 //
1426 let Defs = [EFLAGS] in {
1427 let isCommutable = 1 in {   // TEST X, Y   --> TEST Y, X
1428 def TEST8rr  : I<0x84, MRMSrcReg, (outs),  (ins GR8:$src1, GR8:$src2),
1429                      "test{b}\t{$src2, $src1|$src1, $src2}",
1430                      [(set EFLAGS, (X86cmp (and_su GR8:$src1, GR8:$src2), 0))]>;
1431 def TEST16rr : I<0x85, MRMSrcReg, (outs),  (ins GR16:$src1, GR16:$src2),
1432                      "test{w}\t{$src2, $src1|$src1, $src2}",
1433                      [(set EFLAGS, (X86cmp (and_su GR16:$src1, GR16:$src2),
1434                       0))]>,
1435                  OpSize;
1436 def TEST32rr : I<0x85, MRMSrcReg, (outs),  (ins GR32:$src1, GR32:$src2),
1437                      "test{l}\t{$src2, $src1|$src1, $src2}",
1438                      [(set EFLAGS, (X86cmp (and_su GR32:$src1, GR32:$src2),
1439                       0))]>;
1440 }
1441
1442 def TEST8i8  : Ii8<0xA8, RawFrm, (outs), (ins i8imm:$src),
1443                    "test{b}\t{$src, %al|%al, $src}", []>;
1444 def TEST16i16 : Ii16<0xA9, RawFrm, (outs), (ins i16imm:$src),
1445                      "test{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1446 def TEST32i32 : Ii32<0xA9, RawFrm, (outs), (ins i32imm:$src),
1447                      "test{l}\t{$src, %eax|%eax, $src}", []>;
1448
1449 def TEST8rm  : I<0x84, MRMSrcMem, (outs),  (ins GR8 :$src1, i8mem :$src2),
1450                      "test{b}\t{$src2, $src1|$src1, $src2}",
1451                      [(set EFLAGS, (X86cmp (and GR8:$src1, (loadi8 addr:$src2)),
1452                        0))]>;
1453 def TEST16rm : I<0x85, MRMSrcMem, (outs),  (ins GR16:$src1, i16mem:$src2),
1454                      "test{w}\t{$src2, $src1|$src1, $src2}",
1455                      [(set EFLAGS, (X86cmp (and GR16:$src1,
1456                                          (loadi16 addr:$src2)), 0))]>, OpSize;
1457 def TEST32rm : I<0x85, MRMSrcMem, (outs),  (ins GR32:$src1, i32mem:$src2),
1458                      "test{l}\t{$src2, $src1|$src1, $src2}",
1459                      [(set EFLAGS, (X86cmp (and GR32:$src1,
1460                                                 (loadi32 addr:$src2)), 0))]>;
1461
1462 def TEST8ri  : Ii8 <0xF6, MRM0r,                     // flags = GR8  & imm8
1463                     (outs),  (ins GR8:$src1, i8imm:$src2),
1464                     "test{b}\t{$src2, $src1|$src1, $src2}",
1465                     [(set EFLAGS, (X86cmp (and_su GR8:$src1, imm:$src2), 0))]>;
1466 def TEST16ri : Ii16<0xF7, MRM0r,                     // flags = GR16 & imm16
1467                     (outs),  (ins GR16:$src1, i16imm:$src2),
1468                     "test{w}\t{$src2, $src1|$src1, $src2}",
1469                     [(set EFLAGS, (X86cmp (and_su GR16:$src1, imm:$src2), 0))]>,
1470                     OpSize;
1471 def TEST32ri : Ii32<0xF7, MRM0r,                     // flags = GR32 & imm32
1472                     (outs),  (ins GR32:$src1, i32imm:$src2),
1473                     "test{l}\t{$src2, $src1|$src1, $src2}",
1474                     [(set EFLAGS, (X86cmp (and_su GR32:$src1, imm:$src2), 0))]>;
1475
1476 def TEST8mi  : Ii8 <0xF6, MRM0m,                   // flags = [mem8]  & imm8
1477                     (outs), (ins i8mem:$src1, i8imm:$src2),
1478                     "test{b}\t{$src2, $src1|$src1, $src2}",
1479                     [(set EFLAGS, (X86cmp (and (loadi8 addr:$src1), imm:$src2),
1480                      0))]>;
1481 def TEST16mi : Ii16<0xF7, MRM0m,                   // flags = [mem16] & imm16
1482                     (outs), (ins i16mem:$src1, i16imm:$src2),
1483                     "test{w}\t{$src2, $src1|$src1, $src2}",
1484                     [(set EFLAGS, (X86cmp (and (loadi16 addr:$src1), imm:$src2),
1485                      0))]>, OpSize;
1486 def TEST32mi : Ii32<0xF7, MRM0m,                   // flags = [mem32] & imm32
1487                     (outs), (ins i32mem:$src1, i32imm:$src2),
1488                     "test{l}\t{$src2, $src1|$src1, $src2}",
1489                     [(set EFLAGS, (X86cmp (and (loadi32 addr:$src1), imm:$src2),
1490                      0))]>;
1491 } // Defs = [EFLAGS]
1492