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 // Note: NOT does not set 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 } // isConvertibleToThreeAddress = 1, CodeSize = 1
 398
 399
 400 // In 64-bit mode, single byte INC and DEC cannot be encoded.
 401 let isConvertibleToThreeAddress = 1, CodeSize = 2 in {
 402 // Can transform into LEA.
 403 def INC64_16r : I<0xFF, MRM0r, (outs GR16:$dst), (ins GR16:$src1),
 404                   "inc{w}\t$dst",
 405                   [(set GR16:$dst, EFLAGS, (X86inc_flag GR16:$src1))]>,
 406                 OpSize, Requires<[In64BitMode]>;
 407 def INC64_32r : I<0xFF, MRM0r, (outs GR32:$dst), (ins GR32:$src1),
 408                   "inc{l}\t$dst",
 409                   [(set GR32:$dst, EFLAGS, (X86inc_flag GR32:$src1))]>,
 410                 Requires<[In64BitMode]>;
 411 def DEC64_16r : I<0xFF, MRM1r, (outs GR16:$dst), (ins GR16:$src1),
 412                   "dec{w}\t$dst",
 413                   [(set GR16:$dst, EFLAGS, (X86dec_flag GR16:$src1))]>,
 414                 OpSize, Requires<[In64BitMode]>;
 415 def DEC64_32r : I<0xFF, MRM1r, (outs GR32:$dst), (ins GR32:$src1),
 416                   "dec{l}\t$dst",
 417                   [(set GR32:$dst, EFLAGS, (X86dec_flag GR32:$src1))]>,
 418                 Requires<[In64BitMode]>;
 419 } // isConvertibleToThreeAddress = 1, CodeSize = 2
 420
 421 } // Constraints = "$src1 = $dst"
 422
 423 let CodeSize = 2 in {
 424   def INC8m  : I<0xFE, MRM0m, (outs), (ins i8mem :$dst), "inc{b}\t$dst",
 425                [(store (add (loadi8 addr:$dst), 1), addr:$dst),
 426                 (implicit EFLAGS)]>;
 427   def INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
 428                [(store (add (loadi16 addr:$dst), 1), addr:$dst),
 429                 (implicit EFLAGS)]>,
 430                OpSize, Requires<[In32BitMode]>;
 431   def INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
 432                [(store (add (loadi32 addr:$dst), 1), addr:$dst),
 433                 (implicit EFLAGS)]>,
 434                Requires<[In32BitMode]>;
 435   def INC64m : RI<0xFF, MRM0m, (outs), (ins i64mem:$dst), "inc{q}\t$dst",
 436                   [(store (add (loadi64 addr:$dst), 1), addr:$dst),
 437                    (implicit EFLAGS)]>;
 438
 439 // These are duplicates of their 32-bit counterparts. Only needed so X86 knows
 440 // how to unfold them.
 441 // FIXME: What is this for??
 442 def INC64_16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
 443                   [(store (add (loadi16 addr:$dst), 1), addr:$dst),
 444                     (implicit EFLAGS)]>,
 445                 OpSize, Requires<[In64BitMode]>;
 446 def INC64_32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
 447                   [(store (add (loadi32 addr:$dst), 1), addr:$dst),
 448                     (implicit EFLAGS)]>,
 449                 Requires<[In64BitMode]>;
 450 def DEC64_16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
 451                   [(store (add (loadi16 addr:$dst), -1), addr:$dst),
 452                     (implicit EFLAGS)]>,
 453                 OpSize, Requires<[In64BitMode]>;
 454 def DEC64_32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
 455                   [(store (add (loadi32 addr:$dst), -1), addr:$dst),
 456                     (implicit EFLAGS)]>,
 457                 Requires<[In64BitMode]>;
 458 } // CodeSize = 2
 459
 460 let Constraints = "$src1 = $dst" in {
 461 let CodeSize = 2 in
 462 def DEC8r  : I<0xFE, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
 463                "dec{b}\t$dst",
 464                [(set GR8:$dst, EFLAGS, (X86dec_flag GR8:$src1))]>;
 465 let isConvertibleToThreeAddress = 1, CodeSize = 1 in {   // Can xform into LEA.
 466 def DEC16r : I<0x48, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 467                "dec{w}\t$dst",
 468                [(set GR16:$dst, EFLAGS, (X86dec_flag GR16:$src1))]>,
 469              OpSize, Requires<[In32BitMode]>;
 470 def DEC32r : I<0x48, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 471                "dec{l}\t$dst",
 472                [(set GR32:$dst, EFLAGS, (X86dec_flag GR32:$src1))]>,
 473              Requires<[In32BitMode]>;
 474 def DEC64r : RI<0xFF, MRM1r, (outs GR64:$dst), (ins GR64:$src1), "dec{q}\t$dst",
 475                 [(set GR64:$dst, EFLAGS, (X86dec_flag GR64:$src1))]>;
 476 } // CodeSize = 2
 477 } // Constraints = "$src1 = $dst"
 478
 479
 480 let CodeSize = 2 in {
 481   def DEC8m  : I<0xFE, MRM1m, (outs), (ins i8mem :$dst), "dec{b}\t$dst",
 482                [(store (add (loadi8 addr:$dst), -1), addr:$dst),
 483                 (implicit EFLAGS)]>;
 484   def DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
 485                [(store (add (loadi16 addr:$dst), -1), addr:$dst),
 486                 (implicit EFLAGS)]>,
 487                OpSize, Requires<[In32BitMode]>;
 488   def DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
 489                [(store (add (loadi32 addr:$dst), -1), addr:$dst),
 490                 (implicit EFLAGS)]>,
 491                Requires<[In32BitMode]>;
 492   def DEC64m : RI<0xFF, MRM1m, (outs), (ins i64mem:$dst), "dec{q}\t$dst",
 493                   [(store (add (loadi64 addr:$dst), -1), addr:$dst),
 494                    (implicit EFLAGS)]>;
 495 } // CodeSize = 2
 496 } // Defs = [EFLAGS]
 497
 498
 499 class BinOpRR<bits<8> opcode, Format format, string mnemonic,
 500               RegisterClass regclass, SDNode opnode>
 501   : I<opcode, format, (outs regclass:$dst), (ins regclass:$src1,regclass:$src2),
 502       !strconcat(mnemonic, "\t{$src2, $dst|$dst, $src2}"),
 503       [(set regclass:$dst, EFLAGS, (opnode regclass:$src1, regclass:$src2))]>;
 504
 505 // Logical operators.
 506 let Defs = [EFLAGS] in {
 507 let Constraints = "$src1 = $dst" in {
 508
 509 let isCommutable = 1 in {   // X = AND Y, Z   --> X = AND Z, Y
 510 def AND8rr  : BinOpRR<0x20, MRMDestReg, "and{b}", GR8 , X86and_flag>;
 511 def AND16rr : BinOpRR<0x21, MRMDestReg, "and{w}", GR16, X86and_flag>, OpSize;
 512 def AND32rr : BinOpRR<0x21, MRMDestReg, "and{l}", GR32, X86and_flag>;
 513 def AND64rr : BinOpRR<0x21, MRMDestReg, "and{q}", GR64, X86and_flag>, REX_W;
 514 } // isCommutable
 515
 516
 517 // AND instructions with the destination register in REG and the source register
 518 //   in R/M.  Included for the disassembler.
 519 let isCodeGenOnly = 1 in {
 520 def AND8rr_REV : I<0x22, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 521                   "and{b}\t{$src2, $dst|$dst, $src2}", []>;
 522 def AND16rr_REV : I<0x23, MRMSrcReg, (outs GR16:$dst),
 523                     (ins GR16:$src1, GR16:$src2),
 524                    "and{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 525 def AND32rr_REV : I<0x23, MRMSrcReg, (outs GR32:$dst),
 526                     (ins GR32:$src1, GR32:$src2),
 527                    "and{l}\t{$src2, $dst|$dst, $src2}", []>;
 528 def AND64rr_REV : RI<0x23, MRMSrcReg, (outs GR64:$dst),
 529                      (ins GR64:$src1, GR64:$src2),
 530                      "and{q}\t{$src2, $dst|$dst, $src2}", []>;
 531 }
 532
 533 def AND8rm   : I<0x22, MRMSrcMem,
 534                  (outs GR8 :$dst), (ins GR8 :$src1, i8mem :$src2),
 535                  "and{b}\t{$src2, $dst|$dst, $src2}",
 536                 [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
 537                                                      (loadi8 addr:$src2)))]>;
 538 def AND16rm  : I<0x23, MRMSrcMem,
 539                  (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
 540                  "and{w}\t{$src2, $dst|$dst, $src2}",
 541                 [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 542                                                       (loadi16 addr:$src2)))]>,
 543                OpSize;
 544 def AND32rm  : I<0x23, MRMSrcMem,
 545                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
 546                  "and{l}\t{$src2, $dst|$dst, $src2}",
 547                 [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 548                                                       (loadi32 addr:$src2)))]>;
 549 def AND64rm  : RI<0x23, MRMSrcMem,
 550                   (outs GR64:$dst), (ins GR64:$src1, i64mem:$src2),
 551                   "and{q}\t{$src2, $dst|$dst, $src2}",
 552                   [(set GR64:$dst, EFLAGS,
 553                         (X86and_flag GR64:$src1, (load addr:$src2)))]>;
 554
 555 def AND8ri   : Ii8<0x80, MRM4r,
 556                    (outs GR8 :$dst), (ins GR8 :$src1, i8imm :$src2),
 557                    "and{b}\t{$src2, $dst|$dst, $src2}",
 558                    [(set GR8:$dst, EFLAGS, (X86and_flag GR8:$src1,
 559                                                         imm:$src2))]>;
 560 def AND16ri  : Ii16<0x81, MRM4r,
 561                     (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 562                     "and{w}\t{$src2, $dst|$dst, $src2}",
 563                     [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 564                                                           imm:$src2))]>, OpSize;
 565 def AND32ri  : Ii32<0x81, MRM4r,
 566                     (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 567                     "and{l}\t{$src2, $dst|$dst, $src2}",
 568                     [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 569                                                           imm:$src2))]>;
 570 def AND64ri32  : RIi32<0x81, MRM4r,
 571                        (outs GR64:$dst), (ins GR64:$src1, i64i32imm:$src2),
 572                        "and{q}\t{$src2, $dst|$dst, $src2}",
 573                        [(set GR64:$dst, EFLAGS,
 574                              (X86and_flag GR64:$src1, i64immSExt32:$src2))]>;
 575
 576 def AND16ri8 : Ii8<0x83, MRM4r,
 577                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 578                    "and{w}\t{$src2, $dst|$dst, $src2}",
 579                    [(set GR16:$dst, EFLAGS, (X86and_flag GR16:$src1,
 580                                                          i16immSExt8:$src2))]>,
 581                    OpSize;
 582 def AND32ri8 : Ii8<0x83, MRM4r,
 583                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 584                    "and{l}\t{$src2, $dst|$dst, $src2}",
 585                    [(set GR32:$dst, EFLAGS, (X86and_flag GR32:$src1,
 586                                                          i32immSExt8:$src2))]>;
 587 def AND64ri8 : RIi8<0x83, MRM4r,
 588                     (outs GR64:$dst), (ins GR64:$src1, i64i8imm:$src2),
 589                     "and{q}\t{$src2, $dst|$dst, $src2}",
 590                     [(set GR64:$dst, EFLAGS,
 591                           (X86and_flag GR64:$src1, i64immSExt8:$src2))]>;
 592 } // Constraints = "$src1 = $dst"
 593
 594 def AND8mr   : I<0x20, MRMDestMem,
 595                  (outs), (ins i8mem :$dst, GR8 :$src),
 596                  "and{b}\t{$src, $dst|$dst, $src}",
 597                  [(store (and (load addr:$dst), GR8:$src), addr:$dst),
 598                   (implicit EFLAGS)]>;
 599 def AND16mr  : I<0x21, MRMDestMem,
 600                  (outs), (ins i16mem:$dst, GR16:$src),
 601                  "and{w}\t{$src, $dst|$dst, $src}",
 602                  [(store (and (load addr:$dst), GR16:$src), addr:$dst),
 603                   (implicit EFLAGS)]>,
 604                  OpSize;
 605 def AND32mr  : I<0x21, MRMDestMem,
 606                  (outs), (ins i32mem:$dst, GR32:$src),
 607                  "and{l}\t{$src, $dst|$dst, $src}",
 608                  [(store (and (load addr:$dst), GR32:$src), addr:$dst),
 609                   (implicit EFLAGS)]>;
 610 def AND64mr  : RI<0x21, MRMDestMem,
 611                   (outs), (ins i64mem:$dst, GR64:$src),
 612                   "and{q}\t{$src, $dst|$dst, $src}",
 613                   [(store (and (load addr:$dst), GR64:$src), addr:$dst),
 614                    (implicit EFLAGS)]>;
 615
 616 def AND8mi   : Ii8<0x80, MRM4m,
 617                    (outs), (ins i8mem :$dst, i8imm :$src),
 618                    "and{b}\t{$src, $dst|$dst, $src}",
 619                     [(store (and (loadi8 addr:$dst), imm:$src), addr:$dst),
 620                      (implicit EFLAGS)]>;
 621 def AND16mi  : Ii16<0x81, MRM4m,
 622                     (outs), (ins i16mem:$dst, i16imm:$src),
 623                     "and{w}\t{$src, $dst|$dst, $src}",
 624                     [(store (and (loadi16 addr:$dst), imm:$src), addr:$dst),
 625                      (implicit EFLAGS)]>,
 626                     OpSize;
 627 def AND32mi  : Ii32<0x81, MRM4m,
 628                     (outs), (ins i32mem:$dst, i32imm:$src),
 629                     "and{l}\t{$src, $dst|$dst, $src}",
 630                     [(store (and (loadi32 addr:$dst), imm:$src), addr:$dst),
 631                      (implicit EFLAGS)]>;
 632 def AND64mi32  : RIi32<0x81, MRM4m,
 633                        (outs), (ins i64mem:$dst, i64i32imm:$src),
 634                        "and{q}\t{$src, $dst|$dst, $src}",
 635              [(store (and (loadi64 addr:$dst), i64immSExt32:$src), addr:$dst),
 636               (implicit EFLAGS)]>;
 637
 638 def AND16mi8 : Ii8<0x83, MRM4m,
 639                    (outs), (ins i16mem:$dst, i16i8imm :$src),
 640                    "and{w}\t{$src, $dst|$dst, $src}",
 641               [(store (and (load addr:$dst), i16immSExt8:$src), addr:$dst),
 642                (implicit EFLAGS)]>,
 643                    OpSize;
 644 def AND32mi8 : Ii8<0x83, MRM4m,
 645                    (outs), (ins i32mem:$dst, i32i8imm :$src),
 646                    "and{l}\t{$src, $dst|$dst, $src}",
 647               [(store (and (load addr:$dst), i32immSExt8:$src), addr:$dst),
 648                (implicit EFLAGS)]>;
 649 def AND64mi8 : RIi8<0x83, MRM4m,
 650                     (outs), (ins i64mem:$dst, i64i8imm :$src),
 651                     "and{q}\t{$src, $dst|$dst, $src}",
 652                  [(store (and (load addr:$dst), i64immSExt8:$src), addr:$dst),
 653                   (implicit EFLAGS)]>;
 654
 655 // FIXME: Implicitly modifiers AL.
 656 def AND8i8 : Ii8<0x24, RawFrm, (outs), (ins i8imm:$src),
 657                  "and{b}\t{$src, %al|%al, $src}", []>;
 658 def AND16i16 : Ii16<0x25, RawFrm, (outs), (ins i16imm:$src),
 659                     "and{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 660 def AND32i32 : Ii32<0x25, RawFrm, (outs), (ins i32imm:$src),
 661                     "and{l}\t{$src, %eax|%eax, $src}", []>;
 662 def AND64i32 : RIi32<0x25, RawFrm, (outs), (ins i64i32imm:$src),
 663                      "and{q}\t{$src, %rax|%rax, $src}", []>;
 664
 665 let Constraints = "$src1 = $dst" in {
 666
 667 let isCommutable = 1 in {   // X = OR Y, Z   --> X = OR Z, Y
 668 def OR8rr    : I<0x08, MRMDestReg, (outs GR8 :$dst),
 669                  (ins GR8 :$src1, GR8 :$src2),
 670                  "or{b}\t{$src2, $dst|$dst, $src2}",
 671                  [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1, GR8:$src2))]>;
 672 def OR16rr   : I<0x09, MRMDestReg, (outs GR16:$dst),
 673                  (ins GR16:$src1, GR16:$src2),
 674                  "or{w}\t{$src2, $dst|$dst, $src2}",
 675                  [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,GR16:$src2))]>,
 676                OpSize;
 677 def OR32rr   : I<0x09, MRMDestReg, (outs GR32:$dst),
 678                  (ins GR32:$src1, GR32:$src2),
 679                  "or{l}\t{$src2, $dst|$dst, $src2}",
 680                  [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,GR32:$src2))]>;
 681 def OR64rr   : RI<0x09, MRMDestReg, (outs GR64:$dst),
 682                   (ins GR64:$src1, GR64:$src2),
 683                   "or{q}\t{$src2, $dst|$dst, $src2}",
 684                   [(set GR64:$dst, EFLAGS,
 685                         (X86or_flag GR64:$src1, GR64:$src2))]>;
 686 }
 687
 688 // OR instructions with the destination register in REG and the source register
 689 //   in R/M.  Included for the disassembler.
 690 let isCodeGenOnly = 1 in {
 691 def OR8rr_REV : I<0x0A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 692                   "or{b}\t{$src2, $dst|$dst, $src2}", []>;
 693 def OR16rr_REV : I<0x0B, MRMSrcReg, (outs GR16:$dst),
 694                    (ins GR16:$src1, GR16:$src2),
 695                    "or{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 696 def OR32rr_REV : I<0x0B, MRMSrcReg, (outs GR32:$dst),
 697                    (ins GR32:$src1, GR32:$src2),
 698                    "or{l}\t{$src2, $dst|$dst, $src2}", []>;
 699 def OR64rr_REV : RI<0x0B, MRMSrcReg, (outs GR64:$dst),
 700                     (ins GR64:$src1, GR64:$src2),
 701                     "or{q}\t{$src2, $dst|$dst, $src2}", []>;
 702 }
 703
 704 def OR8rm    : I<0x0A, MRMSrcMem, (outs GR8 :$dst),
 705                  (ins GR8 :$src1, i8mem :$src2),
 706                  "or{b}\t{$src2, $dst|$dst, $src2}",
 707                 [(set GR8:$dst, EFLAGS, (X86or_flag GR8:$src1,
 708                                                     (load addr:$src2)))]>;
 709 def OR16rm   : I<0x0B, MRMSrcMem, (outs GR16:$dst),
 710                  (ins GR16:$src1, i16mem:$src2),
 711                  "or{w}\t{$src2, $dst|$dst, $src2}",
 712                 [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 713                                                      (load addr:$src2)))]>,
 714                OpSize;
 715 def OR32rm   : I<0x0B, MRMSrcMem, (outs GR32:$dst),
 716                  (ins GR32:$src1, i32mem:$src2),
 717                  "or{l}\t{$src2, $dst|$dst, $src2}",
 718                 [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 719                                                      (load addr:$src2)))]>;
 720 def OR64rm   : RI<0x0B, MRMSrcMem , (outs GR64:$dst),
 721                   (ins GR64:$src1, i64mem:$src2),
 722                   "or{q}\t{$src2, $dst|$dst, $src2}",
 723                   [(set GR64:$dst, EFLAGS,
 724                         (X86or_flag GR64:$src1, (load addr:$src2)))]>;
 725
 726 def OR8ri    : Ii8 <0x80, MRM1r, (outs GR8 :$dst),
 727                     (ins GR8 :$src1, i8imm:$src2),
 728                     "or{b}\t{$src2, $dst|$dst, $src2}",
 729                     [(set GR8:$dst,EFLAGS, (X86or_flag GR8:$src1, imm:$src2))]>;
 730 def OR16ri   : Ii16<0x81, MRM1r, (outs GR16:$dst),
 731                     (ins GR16:$src1, i16imm:$src2),
 732                     "or{w}\t{$src2, $dst|$dst, $src2}",
 733                     [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 734                                                         imm:$src2))]>, OpSize;
 735 def OR32ri   : Ii32<0x81, MRM1r, (outs GR32:$dst),
 736                     (ins GR32:$src1, i32imm:$src2),
 737                     "or{l}\t{$src2, $dst|$dst, $src2}",
 738                     [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 739                                                          imm:$src2))]>;
 740 def OR64ri32 : RIi32<0x81, MRM1r, (outs GR64:$dst),
 741                      (ins GR64:$src1, i64i32imm:$src2),
 742                      "or{q}\t{$src2, $dst|$dst, $src2}",
 743                   [(set GR64:$dst, EFLAGS,
 744                         (X86or_flag GR64:$src1, i64immSExt32:$src2))]>;
 745
 746 def OR16ri8  : Ii8<0x83, MRM1r, (outs GR16:$dst),
 747                    (ins GR16:$src1, i16i8imm:$src2),
 748                    "or{w}\t{$src2, $dst|$dst, $src2}",
 749                    [(set GR16:$dst, EFLAGS, (X86or_flag GR16:$src1,
 750                                                 i16immSExt8:$src2))]>, OpSize;
 751 def OR32ri8  : Ii8<0x83, MRM1r, (outs GR32:$dst),
 752                    (ins GR32:$src1, i32i8imm:$src2),
 753                    "or{l}\t{$src2, $dst|$dst, $src2}",
 754                    [(set GR32:$dst, EFLAGS, (X86or_flag GR32:$src1,
 755                                                         i32immSExt8:$src2))]>;
 756 def OR64ri8  : RIi8<0x83, MRM1r, (outs GR64:$dst),
 757                     (ins GR64:$src1, i64i8imm:$src2),
 758                     "or{q}\t{$src2, $dst|$dst, $src2}",
 759                    [(set GR64:$dst, EFLAGS,
 760                          (X86or_flag GR64:$src1, i64immSExt8:$src2))]>;
 761 } // Constraints = "$src1 = $dst"
 762
 763 def OR8mr  : I<0x08, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
 764                "or{b}\t{$src, $dst|$dst, $src}",
 765                [(store (or (load addr:$dst), GR8:$src), addr:$dst),
 766                 (implicit EFLAGS)]>;
 767 def OR16mr : I<0x09, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
 768                "or{w}\t{$src, $dst|$dst, $src}",
 769                [(store (or (load addr:$dst), GR16:$src), addr:$dst),
 770                 (implicit EFLAGS)]>, OpSize;
 771 def OR32mr : I<0x09, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
 772                "or{l}\t{$src, $dst|$dst, $src}",
 773                [(store (or (load addr:$dst), GR32:$src), addr:$dst),
 774                 (implicit EFLAGS)]>;
 775 def OR64mr : RI<0x09, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
 776                 "or{q}\t{$src, $dst|$dst, $src}",
 777                 [(store (or (load addr:$dst), GR64:$src), addr:$dst),
 778                  (implicit EFLAGS)]>;
 779
 780 def OR8mi    : Ii8<0x80, MRM1m, (outs), (ins i8mem :$dst, i8imm:$src),
 781                "or{b}\t{$src, $dst|$dst, $src}",
 782                [(store (or (loadi8 addr:$dst), imm:$src), addr:$dst),
 783                 (implicit EFLAGS)]>;
 784 def OR16mi   : Ii16<0x81, MRM1m, (outs), (ins i16mem:$dst, i16imm:$src),
 785                "or{w}\t{$src, $dst|$dst, $src}",
 786                [(store (or (loadi16 addr:$dst), imm:$src), addr:$dst),
 787                 (implicit EFLAGS)]>,
 788                OpSize;
 789 def OR32mi   : Ii32<0x81, MRM1m, (outs), (ins i32mem:$dst, i32imm:$src),
 790                "or{l}\t{$src, $dst|$dst, $src}",
 791                [(store (or (loadi32 addr:$dst), imm:$src), addr:$dst),
 792                 (implicit EFLAGS)]>;
 793 def OR64mi32 : RIi32<0x81, MRM1m, (outs), (ins i64mem:$dst, i64i32imm:$src),
 794                      "or{q}\t{$src, $dst|$dst, $src}",
 795               [(store (or (loadi64 addr:$dst), i64immSExt32:$src), addr:$dst),
 796                (implicit EFLAGS)]>;
 797
 798 def OR16mi8  : Ii8<0x83, MRM1m, (outs), (ins i16mem:$dst, i16i8imm:$src),
 799                "or{w}\t{$src, $dst|$dst, $src}",
 800                [(store (or (load addr:$dst), i16immSExt8:$src), addr:$dst),
 801                 (implicit EFLAGS)]>,
 802                    OpSize;
 803 def OR32mi8  : Ii8<0x83, MRM1m, (outs), (ins i32mem:$dst, i32i8imm:$src),
 804                "or{l}\t{$src, $dst|$dst, $src}",
 805                [(store (or (load addr:$dst), i32immSExt8:$src), addr:$dst),
 806                 (implicit EFLAGS)]>;
 807 def OR64mi8  : RIi8<0x83, MRM1m, (outs), (ins i64mem:$dst, i64i8imm:$src),
 808                     "or{q}\t{$src, $dst|$dst, $src}",
 809                   [(store (or (load addr:$dst), i64immSExt8:$src), addr:$dst),
 810                    (implicit EFLAGS)]>;
 811
 812 def OR8i8 : Ii8 <0x0C, RawFrm, (outs), (ins i8imm:$src),
 813                  "or{b}\t{$src, %al|%al, $src}", []>;
 814 def OR16i16 : Ii16 <0x0D, RawFrm, (outs), (ins i16imm:$src),
 815                     "or{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 816 def OR32i32 : Ii32 <0x0D, RawFrm, (outs), (ins i32imm:$src),
 817                     "or{l}\t{$src, %eax|%eax, $src}", []>;
 818 def OR64i32 : RIi32<0x0D, RawFrm, (outs), (ins i64i32imm:$src),
 819                     "or{q}\t{$src, %rax|%rax, $src}", []>;
 820
 821
 822 let Constraints = "$src1 = $dst" in {
 823
 824 let isCommutable = 1 in { // X = XOR Y, Z --> X = XOR Z, Y
 825   def XOR8rr   : I<0x30, MRMDestReg,
 826                    (outs GR8 :$dst), (ins GR8 :$src1, GR8 :$src2),
 827                    "xor{b}\t{$src2, $dst|$dst, $src2}",
 828                    [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
 829                                                         GR8:$src2))]>;
 830   def XOR16rr  : I<0x31, MRMDestReg,
 831                    (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
 832                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 833                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 834                                                          GR16:$src2))]>, OpSize;
 835   def XOR32rr  : I<0x31, MRMDestReg,
 836                    (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
 837                    "xor{l}\t{$src2, $dst|$dst, $src2}",
 838                    [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 839                                                          GR32:$src2))]>;
 840   def XOR64rr  : RI<0x31, MRMDestReg,  (outs GR64:$dst),
 841                     (ins GR64:$src1, GR64:$src2),
 842                     "xor{q}\t{$src2, $dst|$dst, $src2}",
 843                     [(set GR64:$dst, EFLAGS,
 844                           (X86xor_flag GR64:$src1, GR64:$src2))]>;
 845 } // isCommutable = 1
 846
 847 // XOR instructions with the destination register in REG and the source register
 848 //   in R/M.  Included for the disassembler.
 849 let isCodeGenOnly = 1 in {
 850 def XOR8rr_REV : I<0x32, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
 851                   "xor{b}\t{$src2, $dst|$dst, $src2}", []>;
 852 def XOR16rr_REV : I<0x33, MRMSrcReg, (outs GR16:$dst),
 853                     (ins GR16:$src1, GR16:$src2),
 854                    "xor{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
 855 def XOR32rr_REV : I<0x33, MRMSrcReg, (outs GR32:$dst),
 856                     (ins GR32:$src1, GR32:$src2),
 857                    "xor{l}\t{$src2, $dst|$dst, $src2}", []>;
 858 def XOR64rr_REV : RI<0x33, MRMSrcReg, (outs GR64:$dst),
 859                      (ins GR64:$src1, GR64:$src2),
 860                     "xor{q}\t{$src2, $dst|$dst, $src2}", []>;
 861 }
 862
 863 def XOR8rm   : I<0x32, MRMSrcMem,
 864                  (outs GR8 :$dst), (ins GR8:$src1, i8mem :$src2),
 865                  "xor{b}\t{$src2, $dst|$dst, $src2}",
 866                  [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1,
 867                                                       (load addr:$src2)))]>;
 868 def XOR16rm  : I<0x33, MRMSrcMem,
 869                  (outs GR16:$dst), (ins GR16:$src1, i16mem:$src2),
 870                  "xor{w}\t{$src2, $dst|$dst, $src2}",
 871                  [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 872                                                        (load addr:$src2)))]>,
 873                  OpSize;
 874 def XOR32rm  : I<0x33, MRMSrcMem,
 875                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
 876                  "xor{l}\t{$src2, $dst|$dst, $src2}",
 877                  [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 878                                                        (load addr:$src2)))]>;
 879 def XOR64rm  : RI<0x33, MRMSrcMem, (outs GR64:$dst),
 880                   (ins GR64:$src1, i64mem:$src2),
 881                   "xor{q}\t{$src2, $dst|$dst, $src2}",
 882                   [(set GR64:$dst, EFLAGS,
 883                         (X86xor_flag GR64:$src1, (load addr:$src2)))]>;
 884
 885 def XOR8ri  : Ii8<0x80, MRM6r,
 886                   (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
 887                   "xor{b}\t{$src2, $dst|$dst, $src2}",
 888                   [(set GR8:$dst, EFLAGS, (X86xor_flag GR8:$src1, imm:$src2))]>;
 889 def XOR16ri : Ii16<0x81, MRM6r,
 890                    (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 891                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 892                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 893                                                          imm:$src2))]>, OpSize;
 894 def XOR32ri  : Ii32<0x81, MRM6r,
 895                     (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 896                     "xor{l}\t{$src2, $dst|$dst, $src2}",
 897                     [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 898                                                           imm:$src2))]>;
 899 def XOR64ri32 : RIi32<0x81, MRM6r,
 900                       (outs GR64:$dst), (ins GR64:$src1, i64i32imm:$src2),
 901                       "xor{q}\t{$src2, $dst|$dst, $src2}",
 902                       [(set GR64:$dst, EFLAGS,
 903                             (X86xor_flag GR64:$src1, i64immSExt32:$src2))]>;
 904
 905 def XOR16ri8 : Ii8<0x83, MRM6r,
 906                    (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 907                    "xor{w}\t{$src2, $dst|$dst, $src2}",
 908                    [(set GR16:$dst, EFLAGS, (X86xor_flag GR16:$src1,
 909                                                          i16immSExt8:$src2))]>,
 910                    OpSize;
 911 def XOR32ri8 : Ii8<0x83, MRM6r,
 912                    (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 913                    "xor{l}\t{$src2, $dst|$dst, $src2}",
 914                    [(set GR32:$dst, EFLAGS, (X86xor_flag GR32:$src1,
 915                                                          i32immSExt8:$src2))]>;
 916 def XOR64ri8 : RIi8<0x83, MRM6r,  (outs GR64:$dst),
 917                     (ins GR64:$src1, i64i8imm:$src2),
 918                     "xor{q}\t{$src2, $dst|$dst, $src2}",
 919                     [(set GR64:$dst, EFLAGS,
 920                           (X86xor_flag GR64:$src1, i64immSExt8:$src2))]>;
 921 } // Constraints = "$src1 = $dst"
 922
 923
 924 def XOR8mr   : I<0x30, MRMDestMem,
 925                  (outs), (ins i8mem :$dst, GR8 :$src),
 926                  "xor{b}\t{$src, $dst|$dst, $src}",
 927                  [(store (xor (load addr:$dst), GR8:$src), addr:$dst),
 928                   (implicit EFLAGS)]>;
 929 def XOR16mr  : I<0x31, MRMDestMem,
 930                  (outs), (ins i16mem:$dst, GR16:$src),
 931                  "xor{w}\t{$src, $dst|$dst, $src}",
 932                  [(store (xor (load addr:$dst), GR16:$src), addr:$dst),
 933                   (implicit EFLAGS)]>,
 934                  OpSize;
 935 def XOR32mr  : I<0x31, MRMDestMem,
 936                  (outs), (ins i32mem:$dst, GR32:$src),
 937                  "xor{l}\t{$src, $dst|$dst, $src}",
 938                  [(store (xor (load addr:$dst), GR32:$src), addr:$dst),
 939                   (implicit EFLAGS)]>;
 940 def XOR64mr  : RI<0x31, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
 941                   "xor{q}\t{$src, $dst|$dst, $src}",
 942                   [(store (xor (load addr:$dst), GR64:$src), addr:$dst),
 943                    (implicit EFLAGS)]>;
 944
 945 def XOR8mi   : Ii8<0x80, MRM6m,
 946                    (outs), (ins i8mem :$dst, i8imm :$src),
 947                    "xor{b}\t{$src, $dst|$dst, $src}",
 948                   [(store (xor (loadi8 addr:$dst), imm:$src), addr:$dst),
 949                    (implicit EFLAGS)]>;
 950 def XOR16mi  : Ii16<0x81, MRM6m,
 951                     (outs), (ins i16mem:$dst, i16imm:$src),
 952                     "xor{w}\t{$src, $dst|$dst, $src}",
 953                  [(store (xor (loadi16 addr:$dst), imm:$src), addr:$dst),
 954                   (implicit EFLAGS)]>,
 955                     OpSize;
 956 def XOR32mi  : Ii32<0x81, MRM6m,
 957                     (outs), (ins i32mem:$dst, i32imm:$src),
 958                     "xor{l}\t{$src, $dst|$dst, $src}",
 959                  [(store (xor (loadi32 addr:$dst), imm:$src), addr:$dst),
 960                   (implicit EFLAGS)]>;
 961 def XOR64mi32 : RIi32<0x81, MRM6m, (outs), (ins i64mem:$dst, i64i32imm:$src),
 962                       "xor{q}\t{$src, $dst|$dst, $src}",
 963              [(store (xor (loadi64 addr:$dst), i64immSExt32:$src), addr:$dst),
 964               (implicit EFLAGS)]>;
 965
 966 def XOR16mi8 : Ii8<0x83, MRM6m,
 967                    (outs), (ins i16mem:$dst, i16i8imm :$src),
 968                    "xor{w}\t{$src, $dst|$dst, $src}",
 969                [(store (xor (load addr:$dst), i16immSExt8:$src), addr:$dst),
 970                 (implicit EFLAGS)]>,
 971                    OpSize;
 972 def XOR32mi8 : Ii8<0x83, MRM6m,
 973                    (outs), (ins i32mem:$dst, i32i8imm :$src),
 974                    "xor{l}\t{$src, $dst|$dst, $src}",
 975                [(store (xor (load addr:$dst), i32immSExt8:$src), addr:$dst),
 976                 (implicit EFLAGS)]>;
 977 def XOR64mi8 : RIi8<0x83, MRM6m, (outs), (ins i64mem:$dst, i64i8imm :$src),
 978                     "xor{q}\t{$src, $dst|$dst, $src}",
 979                  [(store (xor (load addr:$dst), i64immSExt8:$src), addr:$dst),
 980                   (implicit EFLAGS)]>;
 981
 982 def XOR8i8   : Ii8 <0x34, RawFrm, (outs), (ins i8imm:$src),
 983                     "xor{b}\t{$src, %al|%al, $src}", []>;
 984 def XOR16i16 : Ii16<0x35, RawFrm, (outs), (ins i16imm:$src),
 985                     "xor{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
 986 def XOR32i32 : Ii32<0x35, RawFrm, (outs), (ins i32imm:$src),
 987                     "xor{l}\t{$src, %eax|%eax, $src}", []>;
 988 def XOR64i32 : RIi32<0x35, RawFrm, (outs), (ins i64i32imm:$src),
 989                      "xor{q}\t{$src, %rax|%rax, $src}", []>;
 990 } // Defs = [EFLAGS]
 991
 992
 993 // Arithmetic.
 994 let Defs = [EFLAGS] in {
 995 let Constraints = "$src1 = $dst" in {
 996 let isCommutable = 1 in {   // X = ADD Y, Z   --> X = ADD Z, Y
 997 // Register-Register Addition
 998 def ADD8rr    : I<0x00, MRMDestReg, (outs GR8 :$dst),
 999                                     (ins GR8 :$src1, GR8 :$src2),
1000                   "add{b}\t{$src2, $dst|$dst, $src2}",
1001                   [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1, GR8:$src2))]>;
1002
1003 let isConvertibleToThreeAddress = 1 in {   // Can transform into LEA.
1004 // Register-Register Addition
1005 def ADD16rr  : I<0x01, MRMDestReg, (outs GR16:$dst),
1006                                    (ins GR16:$src1, GR16:$src2),
1007                  "add{w}\t{$src2, $dst|$dst, $src2}",
1008                  [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
1009                                                        GR16:$src2))]>, OpSize;
1010 def ADD32rr  : I<0x01, MRMDestReg, (outs GR32:$dst),
1011                                    (ins GR32:$src1, GR32:$src2),
1012                  "add{l}\t{$src2, $dst|$dst, $src2}",
1013                  [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
1014                                                        GR32:$src2))]>;
1015 def ADD64rr    : RI<0x01, MRMDestReg, (outs GR64:$dst),
1016                     (ins GR64:$src1, GR64:$src2),
1017                     "add{q}\t{$src2, $dst|$dst, $src2}",
1018                     [(set GR64:$dst, EFLAGS,
1019                           (X86add_flag GR64:$src1, GR64:$src2))]>;
1020 } // end isConvertibleToThreeAddress
1021 } // end isCommutable
1022
1023 // These are alternate spellings for use by the disassembler, we mark them as
1024 // code gen only to ensure they aren't matched by the assembler.
1025 let isCodeGenOnly = 1 in {
1026   def ADD8rr_alt: I<0x02, MRMSrcReg,
1027                     (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1028                    "add{b}\t{$src2, $dst|$dst, $src2}", []>;
1029   def ADD16rr_alt: I<0x03, MRMSrcReg,
1030                     (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
1031                     "add{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1032   def ADD32rr_alt: I<0x03, MRMSrcReg,
1033                      (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
1034                     "add{l}\t{$src2, $dst|$dst, $src2}", []>;
1035   def ADD64rr_alt : RI<0x03, MRMSrcReg,
1036                        (outs GR64:$dst), (ins GR64:$src1, GR64:$src2),
1037                        "add{l}\t{$src2, $dst|$dst, $src2}", []>;
1038 }
1039
1040 // Register-Memory Addition
1041 def ADD8rm   : I<0x02, MRMSrcMem, (outs GR8 :$dst),
1042                                   (ins GR8 :$src1, i8mem :$src2),
1043                  "add{b}\t{$src2, $dst|$dst, $src2}",
1044                  [(set GR8:$dst, EFLAGS, (X86add_flag GR8:$src1,
1045                                                       (load addr:$src2)))]>;
1046 def ADD16rm  : I<0x03, MRMSrcMem, (outs GR16:$dst),
1047                                   (ins GR16:$src1, i16mem:$src2),
1048                  "add{w}\t{$src2, $dst|$dst, $src2}",
1049                  [(set GR16:$dst, EFLAGS, (X86add_flag GR16:$src1,
1050                                                   (load addr:$src2)))]>, OpSize;
1051 def ADD32rm  : I<0x03, MRMSrcMem, (outs GR32:$dst),
1052                                   (ins GR32:$src1, i32mem:$src2),
1053                  "add{l}\t{$src2, $dst|$dst, $src2}",
1054                  [(set GR32:$dst, EFLAGS, (X86add_flag GR32:$src1,
1055                                                        (load addr:$src2)))]>;
1056 def ADD64rm     : RI<0x03, MRMSrcMem, (outs GR64:$dst),
1057                      (ins GR64:$src1, i64mem:$src2),
1058                      "add{q}\t{$src2, $dst|$dst, $src2}",
1059                      [(set GR64:$dst, EFLAGS,
1060                            (X86add_flag GR64:$src1, (load addr:$src2)))]>;
1061
1062 // Register-Integer Addition
1063 def ADD8ri    : Ii8<0x80, MRM0r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1064                     "add{b}\t{$src2, $dst|$dst, $src2}",
1065                     [(set GR8:$dst, EFLAGS,
1066                           (X86add_flag GR8:$src1, imm:$src2))]>;
1067
1068 let isConvertibleToThreeAddress = 1 in {   // Can transform into LEA.
1069 // Register-Integer Addition
1070 def ADD16ri  : Ii16<0x81, MRM0r, (outs GR16:$dst),
1071                                  (ins GR16:$src1, i16imm:$src2),
1072                     "add{w}\t{$src2, $dst|$dst, $src2}",
1073                     [(set GR16:$dst, EFLAGS,
1074                           (X86add_flag GR16:$src1, imm:$src2))]>, OpSize;
1075 def ADD32ri  : Ii32<0x81, MRM0r, (outs GR32:$dst),
1076                                  (ins GR32:$src1, i32imm:$src2),
1077                     "add{l}\t{$src2, $dst|$dst, $src2}",
1078                     [(set GR32:$dst, EFLAGS,
1079                           (X86add_flag GR32:$src1, imm:$src2))]>;
1080 def ADD16ri8 : Ii8<0x83, MRM0r, (outs GR16:$dst),
1081                                 (ins GR16:$src1, i16i8imm:$src2),
1082                    "add{w}\t{$src2, $dst|$dst, $src2}",
1083                    [(set GR16:$dst, EFLAGS,
1084                          (X86add_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
1085 def ADD32ri8 : Ii8<0x83, MRM0r, (outs GR32:$dst),
1086                                 (ins GR32:$src1, i32i8imm:$src2),
1087                    "add{l}\t{$src2, $dst|$dst, $src2}",
1088                    [(set GR32:$dst, EFLAGS,
1089                          (X86add_flag GR32:$src1, i32immSExt8:$src2))]>;
1090 def ADD64ri8  : RIi8<0x83, MRM0r, (outs GR64:$dst),
1091                      (ins GR64:$src1, i64i8imm:$src2),
1092                      "add{q}\t{$src2, $dst|$dst, $src2}",
1093                      [(set GR64:$dst, EFLAGS,
1094                            (X86add_flag GR64:$src1, i64immSExt8:$src2))]>;
1095 def ADD64ri32 : RIi32<0x81, MRM0r, (outs GR64:$dst),
1096                       (ins GR64:$src1, i64i32imm:$src2),
1097                       "add{q}\t{$src2, $dst|$dst, $src2}",
1098                       [(set GR64:$dst, EFLAGS,
1099                             (X86add_flag GR64:$src1, i64immSExt32:$src2))]>;
1100 }
1101 } // Constraints = "$src1 = $dst"
1102
1103 // Memory-Register Addition
1104 def ADD8mr   : I<0x00, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1105                  "add{b}\t{$src2, $dst|$dst, $src2}",
1106                  [(store (add (load addr:$dst), GR8:$src2), addr:$dst),
1107                   (implicit EFLAGS)]>;
1108 def ADD16mr  : I<0x01, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1109                  "add{w}\t{$src2, $dst|$dst, $src2}",
1110                  [(store (add (load addr:$dst), GR16:$src2), addr:$dst),
1111                   (implicit EFLAGS)]>, OpSize;
1112 def ADD32mr  : I<0x01, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1113                  "add{l}\t{$src2, $dst|$dst, $src2}",
1114                  [(store (add (load addr:$dst), GR32:$src2), addr:$dst),
1115                   (implicit EFLAGS)]>;
1116 def ADD64mr  : RI<0x01, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1117                   "add{q}\t{$src2, $dst|$dst, $src2}",
1118                   [(store (add (load addr:$dst), GR64:$src2), addr:$dst),
1119                    (implicit EFLAGS)]>;
1120 def ADD8mi   : Ii8<0x80, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src2),
1121                    "add{b}\t{$src2, $dst|$dst, $src2}",
1122                  [(store (add (loadi8 addr:$dst), imm:$src2), addr:$dst),
1123                   (implicit EFLAGS)]>;
1124 def ADD16mi  : Ii16<0x81, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src2),
1125                     "add{w}\t{$src2, $dst|$dst, $src2}",
1126                 [(store (add (loadi16 addr:$dst), imm:$src2), addr:$dst),
1127                  (implicit EFLAGS)]>, OpSize;
1128 def ADD32mi  : Ii32<0x81, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src2),
1129                     "add{l}\t{$src2, $dst|$dst, $src2}",
1130                     [(store (add (loadi32 addr:$dst), imm:$src2), addr:$dst),
1131                      (implicit EFLAGS)]>;
1132 def ADD64mi32 : RIi32<0x81, MRM0m, (outs), (ins i64mem:$dst, i64i32imm :$src2),
1133                       "add{q}\t{$src2, $dst|$dst, $src2}",
1134                [(store (add (load addr:$dst), i64immSExt32:$src2), addr:$dst),
1135                 (implicit EFLAGS)]>;
1136 def ADD16mi8 : Ii8<0x83, MRM0m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1137                    "add{w}\t{$src2, $dst|$dst, $src2}",
1138                    [(store (add (load addr:$dst), i16immSExt8:$src2),
1139                                 addr:$dst),
1140                     (implicit EFLAGS)]>, OpSize;
1141 def ADD32mi8 : Ii8<0x83, MRM0m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1142                    "add{l}\t{$src2, $dst|$dst, $src2}",
1143                 [(store (add (load addr:$dst), i32immSExt8:$src2),
1144                              addr:$dst),
1145                  (implicit EFLAGS)]>;
1146 def ADD64mi8 : RIi8<0x83, MRM0m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1147                     "add{q}\t{$src2, $dst|$dst, $src2}",
1148                 [(store (add (load addr:$dst), i64immSExt8:$src2), addr:$dst),
1149                  (implicit EFLAGS)]>;
1150
1151 // addition to rAX
1152 def ADD8i8 : Ii8<0x04, RawFrm, (outs), (ins i8imm:$src),
1153                  "add{b}\t{$src, %al|%al, $src}", []>;
1154 def ADD16i16 : Ii16<0x05, RawFrm, (outs), (ins i16imm:$src),
1155                     "add{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1156 def ADD32i32 : Ii32<0x05, RawFrm, (outs), (ins i32imm:$src),
1157                     "add{l}\t{$src, %eax|%eax, $src}", []>;
1158 def ADD64i32 : RIi32<0x05, RawFrm, (outs), (ins i64i32imm:$src),
1159                      "add{q}\t{$src, %rax|%rax, $src}", []>;
1160
1161 let Uses = [EFLAGS] in {
1162 let Constraints = "$src1 = $dst" in {
1163 let isCommutable = 1 in {  // X = ADC Y, Z --> X = ADC Z, Y
1164 def ADC8rr   : I<0x10, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1165                  "adc{b}\t{$src2, $dst|$dst, $src2}",
1166                  [(set GR8:$dst, (adde GR8:$src1, GR8:$src2))]>;
1167 def ADC16rr  : I<0x11, MRMDestReg, (outs GR16:$dst),
1168                                    (ins GR16:$src1, GR16:$src2),
1169                  "adc{w}\t{$src2, $dst|$dst, $src2}",
1170                  [(set GR16:$dst, (adde GR16:$src1, GR16:$src2))]>, OpSize;
1171 def ADC32rr  : I<0x11, MRMDestReg, (outs GR32:$dst),
1172                                    (ins GR32:$src1, GR32:$src2),
1173                  "adc{l}\t{$src2, $dst|$dst, $src2}",
1174                  [(set GR32:$dst, (adde GR32:$src1, GR32:$src2))]>;
1175 def ADC64rr  : RI<0x11, MRMDestReg, (outs GR64:$dst),
1176                   (ins GR64:$src1, GR64:$src2),
1177                   "adc{q}\t{$src2, $dst|$dst, $src2}",
1178                   [(set GR64:$dst, (adde GR64:$src1, GR64:$src2))]>;
1179 }
1180
1181 let isCodeGenOnly = 1 in {
1182 def ADC8rr_REV : I<0x12, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1183                  "adc{b}\t{$src2, $dst|$dst, $src2}", []>;
1184 def ADC16rr_REV : I<0x13, MRMSrcReg, (outs GR16:$dst),
1185                     (ins GR16:$src1, GR16:$src2),
1186                     "adc{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1187 def ADC32rr_REV : I<0x13, MRMSrcReg, (outs GR32:$dst),
1188                     (ins GR32:$src1, GR32:$src2),
1189                     "adc{l}\t{$src2, $dst|$dst, $src2}", []>;
1190 def ADC64rr_REV : RI<0x13, MRMSrcReg , (outs GR32:$dst),
1191                      (ins GR64:$src1, GR64:$src2),
1192                     "adc{q}\t{$src2, $dst|$dst, $src2}", []>;
1193 }
1194
1195 def ADC8rm   : I<0x12, MRMSrcMem ,
1196                  (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1197                  "adc{b}\t{$src2, $dst|$dst, $src2}",
1198                  [(set GR8:$dst, (adde GR8:$src1, (load addr:$src2)))]>;
1199 def ADC16rm  : I<0x13, MRMSrcMem , (outs GR16:$dst),
1200                                    (ins GR16:$src1, i16mem:$src2),
1201                  "adc{w}\t{$src2, $dst|$dst, $src2}",
1202                  [(set GR16:$dst, (adde GR16:$src1, (load addr:$src2)))]>,
1203                  OpSize;
1204 def ADC32rm  : I<0x13, MRMSrcMem ,
1205                  (outs GR32:$dst), (ins GR32:$src1, i32mem:$src2),
1206                  "adc{l}\t{$src2, $dst|$dst, $src2}",
1207                  [(set GR32:$dst, (adde GR32:$src1, (load addr:$src2)))]>;
1208 def ADC64rm  : RI<0x13, MRMSrcMem , (outs GR64:$dst),
1209                   (ins GR64:$src1, i64mem:$src2),
1210                   "adc{q}\t{$src2, $dst|$dst, $src2}",
1211                   [(set GR64:$dst, (adde GR64:$src1, (load addr:$src2)))]>;
1212 def ADC8ri   : Ii8<0x80, MRM2r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1213                     "adc{b}\t{$src2, $dst|$dst, $src2}",
1214                  [(set GR8:$dst, (adde GR8:$src1, imm:$src2))]>;
1215 def ADC16ri  : Ii16<0x81, MRM2r,
1216                     (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
1217                     "adc{w}\t{$src2, $dst|$dst, $src2}",
1218                  [(set GR16:$dst, (adde GR16:$src1, imm:$src2))]>, OpSize;
1219 def ADC16ri8 : Ii8<0x83, MRM2r, (outs GR16:$dst),
1220                                 (ins GR16:$src1, i16i8imm:$src2),
1221                    "adc{w}\t{$src2, $dst|$dst, $src2}",
1222                  [(set GR16:$dst, (adde GR16:$src1, i16immSExt8:$src2))]>,
1223                  OpSize;
1224 def ADC32ri  : Ii32<0x81, MRM2r, (outs GR32:$dst),
1225                                  (ins GR32:$src1, i32imm:$src2),
1226                     "adc{l}\t{$src2, $dst|$dst, $src2}",
1227                  [(set GR32:$dst, (adde GR32:$src1, imm:$src2))]>;
1228 def ADC32ri8 : Ii8<0x83, MRM2r, (outs GR32:$dst),
1229                                 (ins GR32:$src1, i32i8imm:$src2),
1230                    "adc{l}\t{$src2, $dst|$dst, $src2}",
1231                  [(set GR32:$dst, (adde GR32:$src1, i32immSExt8:$src2))]>;
1232 def ADC64ri32 : RIi32<0x81, MRM2r, (outs GR64:$dst),
1233                       (ins GR64:$src1, i64i32imm:$src2),
1234                       "adc{q}\t{$src2, $dst|$dst, $src2}",
1235                       [(set GR64:$dst, (adde GR64:$src1, i64immSExt32:$src2))]>;
1236 def ADC64ri8 : RIi8<0x83, MRM2r, (outs GR64:$dst),
1237                     (ins GR64:$src1, i64i8imm:$src2),
1238                     "adc{q}\t{$src2, $dst|$dst, $src2}",
1239                     [(set GR64:$dst, (adde GR64:$src1, i64immSExt8:$src2))]>;
1240 } // Constraints = "$src1 = $dst"
1241
1242 def ADC8mr   : I<0x10, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1243                  "adc{b}\t{$src2, $dst|$dst, $src2}",
1244                  [(store (adde (load addr:$dst), GR8:$src2), addr:$dst)]>;
1245 def ADC16mr  : I<0x11, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1246                  "adc{w}\t{$src2, $dst|$dst, $src2}",
1247                  [(store (adde (load addr:$dst), GR16:$src2), addr:$dst)]>,
1248                  OpSize;
1249 def ADC32mr  : I<0x11, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1250                  "adc{l}\t{$src2, $dst|$dst, $src2}",
1251                  [(store (adde (load addr:$dst), GR32:$src2), addr:$dst)]>;
1252 def ADC64mr  : RI<0x11, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1253                   "adc{q}\t{$src2, $dst|$dst, $src2}",
1254                   [(store (adde (load addr:$dst), GR64:$src2), addr:$dst)]>;
1255 def ADC8mi   : Ii8<0x80, MRM2m, (outs), (ins i8mem:$dst, i8imm:$src2),
1256                     "adc{b}\t{$src2, $dst|$dst, $src2}",
1257                 [(store (adde (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1258 def ADC16mi  : Ii16<0x81, MRM2m, (outs), (ins i16mem:$dst, i16imm:$src2),
1259                     "adc{w}\t{$src2, $dst|$dst, $src2}",
1260                 [(store (adde (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1261                 OpSize;
1262 def ADC16mi8 : Ii8<0x83, MRM2m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1263                    "adc{w}\t{$src2, $dst|$dst, $src2}",
1264              [(store (adde (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1265              OpSize;
1266 def ADC32mi  : Ii32<0x81, MRM2m, (outs), (ins i32mem:$dst, i32imm:$src2),
1267                     "adc{l}\t{$src2, $dst|$dst, $src2}",
1268                 [(store (adde (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1269 def ADC32mi8 : Ii8<0x83, MRM2m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1270                    "adc{l}\t{$src2, $dst|$dst, $src2}",
1271              [(store (adde (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1272
1273 def ADC64mi32 : RIi32<0x81, MRM2m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
1274                       "adc{q}\t{$src2, $dst|$dst, $src2}",
1275                  [(store (adde (load addr:$dst), i64immSExt32:$src2),
1276                   addr:$dst)]>;
1277 def ADC64mi8 : RIi8<0x83, MRM2m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1278                     "adc{q}\t{$src2, $dst|$dst, $src2}",
1279                  [(store (adde (load addr:$dst), i64immSExt8:$src2),
1280                   addr:$dst)]>;
1281
1282 def ADC8i8 : Ii8<0x14, RawFrm, (outs), (ins i8imm:$src),
1283                  "adc{b}\t{$src, %al|%al, $src}", []>;
1284 def ADC16i16 : Ii16<0x15, RawFrm, (outs), (ins i16imm:$src),
1285                     "adc{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1286 def ADC32i32 : Ii32<0x15, RawFrm, (outs), (ins i32imm:$src),
1287                     "adc{l}\t{$src, %eax|%eax, $src}", []>;
1288 def ADC64i32 : RIi32<0x15, RawFrm, (outs), (ins i64i32imm:$src),
1289                      "adc{q}\t{$src, %rax|%rax, $src}", []>;
1290 } // Uses = [EFLAGS]
1291
1292 let Constraints = "$src1 = $dst" in {
1293
1294 // Register-Register Subtraction
1295 def SUB8rr  : I<0x28, MRMDestReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1296                 "sub{b}\t{$src2, $dst|$dst, $src2}",
1297                 [(set GR8:$dst, EFLAGS,
1298                       (X86sub_flag GR8:$src1, GR8:$src2))]>;
1299 def SUB16rr : I<0x29, MRMDestReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
1300                 "sub{w}\t{$src2, $dst|$dst, $src2}",
1301                 [(set GR16:$dst, EFLAGS,
1302                       (X86sub_flag GR16:$src1, GR16:$src2))]>, OpSize;
1303 def SUB32rr : I<0x29, MRMDestReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
1304                 "sub{l}\t{$src2, $dst|$dst, $src2}",
1305                 [(set GR32:$dst, EFLAGS,
1306                       (X86sub_flag GR32:$src1, GR32:$src2))]>;
1307 def SUB64rr  : RI<0x29, MRMDestReg, (outs GR64:$dst),
1308                   (ins GR64:$src1, GR64:$src2),
1309                   "sub{q}\t{$src2, $dst|$dst, $src2}",
1310                   [(set GR64:$dst, EFLAGS,
1311                         (X86sub_flag GR64:$src1, GR64:$src2))]>;
1312
1313 let isCodeGenOnly = 1 in {
1314 def SUB8rr_REV : I<0x2A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1315                    "sub{b}\t{$src2, $dst|$dst, $src2}", []>;
1316 def SUB16rr_REV : I<0x2B, MRMSrcReg, (outs GR16:$dst),
1317                     (ins GR16:$src1, GR16:$src2),
1318                     "sub{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1319 def SUB32rr_REV : I<0x2B, MRMSrcReg, (outs GR32:$dst),
1320                     (ins GR32:$src1, GR32:$src2),
1321                     "sub{l}\t{$src2, $dst|$dst, $src2}", []>;
1322 def SUB64rr_REV : RI<0x2B, MRMSrcReg, (outs GR64:$dst),
1323                      (ins GR64:$src1, GR64:$src2),
1324                      "sub{q}\t{$src2, $dst|$dst, $src2}", []>;
1325 }
1326
1327 // Register-Memory Subtraction
1328 def SUB8rm  : I<0x2A, MRMSrcMem, (outs GR8 :$dst),
1329                                  (ins GR8 :$src1, i8mem :$src2),
1330                 "sub{b}\t{$src2, $dst|$dst, $src2}",
1331                 [(set GR8:$dst, EFLAGS,
1332                       (X86sub_flag GR8:$src1, (load addr:$src2)))]>;
1333 def SUB16rm : I<0x2B, MRMSrcMem, (outs GR16:$dst),
1334                                  (ins GR16:$src1, i16mem:$src2),
1335                 "sub{w}\t{$src2, $dst|$dst, $src2}",
1336                 [(set GR16:$dst, EFLAGS,
1337                       (X86sub_flag GR16:$src1, (load addr:$src2)))]>, OpSize;
1338 def SUB32rm : I<0x2B, MRMSrcMem, (outs GR32:$dst),
1339                                  (ins GR32:$src1, i32mem:$src2),
1340                 "sub{l}\t{$src2, $dst|$dst, $src2}",
1341                 [(set GR32:$dst, EFLAGS,
1342                       (X86sub_flag GR32:$src1, (load addr:$src2)))]>;
1343 def SUB64rm  : RI<0x2B, MRMSrcMem, (outs GR64:$dst),
1344                   (ins GR64:$src1, i64mem:$src2),
1345                   "sub{q}\t{$src2, $dst|$dst, $src2}",
1346                   [(set GR64:$dst, EFLAGS,
1347                         (X86sub_flag GR64:$src1, (load addr:$src2)))]>;
1348
1349 // Register-Integer Subtraction
1350 def SUB8ri   : Ii8 <0x80, MRM5r, (outs GR8:$dst),
1351                                  (ins GR8:$src1, i8imm:$src2),
1352                     "sub{b}\t{$src2, $dst|$dst, $src2}",
1353                     [(set GR8:$dst, EFLAGS,
1354                           (X86sub_flag GR8:$src1, imm:$src2))]>;
1355 def SUB16ri  : Ii16<0x81, MRM5r, (outs GR16:$dst),
1356                                  (ins GR16:$src1, i16imm:$src2),
1357                     "sub{w}\t{$src2, $dst|$dst, $src2}",
1358                     [(set GR16:$dst, EFLAGS,
1359                           (X86sub_flag GR16:$src1, imm:$src2))]>, OpSize;
1360 def SUB32ri  : Ii32<0x81, MRM5r, (outs GR32:$dst),
1361                                  (ins GR32:$src1, i32imm:$src2),
1362                     "sub{l}\t{$src2, $dst|$dst, $src2}",
1363                     [(set GR32:$dst, EFLAGS,
1364                           (X86sub_flag GR32:$src1, imm:$src2))]>;
1365 def SUB64ri32 : RIi32<0x81, MRM5r, (outs GR64:$dst),
1366                                    (ins GR64:$src1, i64i32imm:$src2),
1367                       "sub{q}\t{$src2, $dst|$dst, $src2}",
1368                       [(set GR64:$dst, EFLAGS,
1369                             (X86sub_flag GR64:$src1, i64immSExt32:$src2))]>;
1370 def SUB16ri8 : Ii8<0x83, MRM5r, (outs GR16:$dst),
1371                                 (ins GR16:$src1, i16i8imm:$src2),
1372                    "sub{w}\t{$src2, $dst|$dst, $src2}",
1373                    [(set GR16:$dst, EFLAGS,
1374                          (X86sub_flag GR16:$src1, i16immSExt8:$src2))]>, OpSize;
1375 def SUB32ri8 : Ii8<0x83, MRM5r, (outs GR32:$dst),
1376                                 (ins GR32:$src1, i32i8imm:$src2),
1377                    "sub{l}\t{$src2, $dst|$dst, $src2}",
1378                    [(set GR32:$dst, EFLAGS,
1379                          (X86sub_flag GR32:$src1, i32immSExt8:$src2))]>;
1380 def SUB64ri8 : RIi8<0x83, MRM5r, (outs GR64:$dst),
1381                                  (ins GR64:$src1, i64i8imm:$src2),
1382                     "sub{q}\t{$src2, $dst|$dst, $src2}",
1383                     [(set GR64:$dst, EFLAGS,
1384                           (X86sub_flag GR64:$src1, i64immSExt8:$src2))]>;
1385 } // Constraints = "$src1 = $dst"
1386
1387 // Memory-Register Subtraction
1388 def SUB8mr   : I<0x28, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src2),
1389                  "sub{b}\t{$src2, $dst|$dst, $src2}",
1390                  [(store (sub (load addr:$dst), GR8:$src2), addr:$dst),
1391                   (implicit EFLAGS)]>;
1392 def SUB16mr  : I<0x29, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1393                  "sub{w}\t{$src2, $dst|$dst, $src2}",
1394                  [(store (sub (load addr:$dst), GR16:$src2), addr:$dst),
1395                   (implicit EFLAGS)]>, OpSize;
1396 def SUB32mr  : I<0x29, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1397                  "sub{l}\t{$src2, $dst|$dst, $src2}",
1398                  [(store (sub (load addr:$dst), GR32:$src2), addr:$dst),
1399                   (implicit EFLAGS)]>;
1400 def SUB64mr  : RI<0x29, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1401                   "sub{q}\t{$src2, $dst|$dst, $src2}",
1402                   [(store (sub (load addr:$dst), GR64:$src2), addr:$dst),
1403                    (implicit EFLAGS)]>;
1404
1405 // Memory-Integer Subtraction
1406 def SUB8mi   : Ii8<0x80, MRM5m, (outs), (ins i8mem :$dst, i8imm:$src2),
1407                    "sub{b}\t{$src2, $dst|$dst, $src2}",
1408                    [(store (sub (loadi8 addr:$dst), imm:$src2), addr:$dst),
1409                     (implicit EFLAGS)]>;
1410 def SUB16mi  : Ii16<0x81, MRM5m, (outs), (ins i16mem:$dst, i16imm:$src2),
1411                     "sub{w}\t{$src2, $dst|$dst, $src2}",
1412                     [(store (sub (loadi16 addr:$dst), imm:$src2),addr:$dst),
1413                      (implicit EFLAGS)]>, OpSize;
1414 def SUB32mi  : Ii32<0x81, MRM5m, (outs), (ins i32mem:$dst, i32imm:$src2),
1415                     "sub{l}\t{$src2, $dst|$dst, $src2}",
1416                     [(store (sub (loadi32 addr:$dst), imm:$src2),addr:$dst),
1417                      (implicit EFLAGS)]>;
1418 def SUB64mi32 : RIi32<0x81, MRM5m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
1419                       "sub{q}\t{$src2, $dst|$dst, $src2}",
1420                       [(store (sub (load addr:$dst), i64immSExt32:$src2),
1421                               addr:$dst),
1422                        (implicit EFLAGS)]>;
1423 def SUB16mi8 : Ii8<0x83, MRM5m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1424                    "sub{w}\t{$src2, $dst|$dst, $src2}",
1425                    [(store (sub (load addr:$dst), i16immSExt8:$src2),
1426                            addr:$dst),
1427                     (implicit EFLAGS)]>, OpSize;
1428 def SUB32mi8 : Ii8<0x83, MRM5m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1429                    "sub{l}\t{$src2, $dst|$dst, $src2}",
1430                    [(store (sub (load addr:$dst), i32immSExt8:$src2),
1431                            addr:$dst),
1432                     (implicit EFLAGS)]>;
1433 def SUB64mi8 : RIi8<0x83, MRM5m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1434                     "sub{q}\t{$src2, $dst|$dst, $src2}",
1435                     [(store (sub (load addr:$dst), i64immSExt8:$src2),
1436                             addr:$dst),
1437                      (implicit EFLAGS)]>;
1438
1439 def SUB8i8 : Ii8<0x2C, RawFrm, (outs), (ins i8imm:$src),
1440                  "sub{b}\t{$src, %al|%al, $src}", []>;
1441 def SUB16i16 : Ii16<0x2D, RawFrm, (outs), (ins i16imm:$src),
1442                     "sub{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1443 def SUB32i32 : Ii32<0x2D, RawFrm, (outs), (ins i32imm:$src),
1444                     "sub{l}\t{$src, %eax|%eax, $src}", []>;
1445 def SUB64i32 : RIi32<0x2D, RawFrm, (outs), (ins i64i32imm:$src),
1446                      "sub{q}\t{$src, %rax|%rax, $src}", []>;
1447
1448 let Uses = [EFLAGS] in {
1449 let Constraints = "$src1 = $dst" in {
1450 def SBB8rr     : I<0x18, MRMDestReg, (outs GR8:$dst),
1451                                      (ins GR8:$src1, GR8:$src2),
1452                   "sbb{b}\t{$src2, $dst|$dst, $src2}",
1453                  [(set GR8:$dst, (sube GR8:$src1, GR8:$src2))]>;
1454 def SBB16rr    : I<0x19, MRMDestReg, (outs GR16:$dst),
1455                                      (ins GR16:$src1, GR16:$src2),
1456                   "sbb{w}\t{$src2, $dst|$dst, $src2}",
1457                  [(set GR16:$dst, (sube GR16:$src1, GR16:$src2))]>, OpSize;
1458 def SBB32rr    : I<0x19, MRMDestReg, (outs GR32:$dst),
1459                                       (ins GR32:$src1, GR32:$src2),
1460                   "sbb{l}\t{$src2, $dst|$dst, $src2}",
1461                  [(set GR32:$dst, (sube GR32:$src1, GR32:$src2))]>;
1462 def SBB64rr    : RI<0x19, MRMDestReg, (outs GR64:$dst),
1463                     (ins GR64:$src1, GR64:$src2),
1464                     "sbb{q}\t{$src2, $dst|$dst, $src2}",
1465                     [(set GR64:$dst, (sube GR64:$src1, GR64:$src2))]>;
1466 } // Constraints = "$src1 = $dst"
1467
1468
1469 def SBB8mr   : I<0x18, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
1470                  "sbb{b}\t{$src2, $dst|$dst, $src2}",
1471                  [(store (sube (load addr:$dst), GR8:$src2), addr:$dst)]>;
1472 def SBB16mr  : I<0x19, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
1473                  "sbb{w}\t{$src2, $dst|$dst, $src2}",
1474                  [(store (sube (load addr:$dst), GR16:$src2), addr:$dst)]>,
1475                  OpSize;
1476 def SBB32mr  : I<0x19, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
1477                  "sbb{l}\t{$src2, $dst|$dst, $src2}",
1478                  [(store (sube (load addr:$dst), GR32:$src2), addr:$dst)]>;
1479 def SBB64mr  : RI<0x19, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
1480                   "sbb{q}\t{$src2, $dst|$dst, $src2}",
1481                   [(store (sube (load addr:$dst), GR64:$src2), addr:$dst)]>;
1482
1483 def SBB8mi  : Ii8<0x80, MRM3m, (outs), (ins i8mem:$dst, i8imm:$src2),
1484                   "sbb{b}\t{$src2, $dst|$dst, $src2}",
1485                  [(store (sube (loadi8 addr:$dst), imm:$src2), addr:$dst)]>;
1486 def SBB16mi  : Ii16<0x81, MRM3m, (outs), (ins i16mem:$dst, i16imm:$src2),
1487                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1488                 [(store (sube (loadi16 addr:$dst), imm:$src2), addr:$dst)]>,
1489                 OpSize;
1490 def SBB16mi8 : Ii8<0x83, MRM3m, (outs), (ins i16mem:$dst, i16i8imm :$src2),
1491                    "sbb{w}\t{$src2, $dst|$dst, $src2}",
1492              [(store (sube (load addr:$dst), i16immSExt8:$src2), addr:$dst)]>,
1493              OpSize;
1494 def SBB32mi  : Ii32<0x81, MRM3m, (outs), (ins i32mem:$dst, i32imm:$src2),
1495                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1496                 [(store (sube (loadi32 addr:$dst), imm:$src2), addr:$dst)]>;
1497 def SBB32mi8 : Ii8<0x83, MRM3m, (outs), (ins i32mem:$dst, i32i8imm :$src2),
1498                    "sbb{l}\t{$src2, $dst|$dst, $src2}",
1499              [(store (sube (load addr:$dst), i32immSExt8:$src2), addr:$dst)]>;
1500 def SBB64mi32 : RIi32<0x81, MRM3m, (outs), (ins i64mem:$dst, i64i32imm:$src2),
1501                       "sbb{q}\t{$src2, $dst|$dst, $src2}",
1502               [(store (sube (load addr:$dst), i64immSExt32:$src2), addr:$dst)]>;
1503 def SBB64mi8 : RIi8<0x83, MRM3m, (outs), (ins i64mem:$dst, i64i8imm :$src2),
1504                     "sbb{q}\t{$src2, $dst|$dst, $src2}",
1505                [(store (sube (load addr:$dst), i64immSExt8:$src2), addr:$dst)]>;
1506
1507 def SBB8i8 : Ii8<0x1C, RawFrm, (outs), (ins i8imm:$src),
1508                  "sbb{b}\t{$src, %al|%al, $src}", []>;
1509 def SBB16i16 : Ii16<0x1D, RawFrm, (outs), (ins i16imm:$src),
1510                     "sbb{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1511 def SBB32i32 : Ii32<0x1D, RawFrm, (outs), (ins i32imm:$src),
1512                     "sbb{l}\t{$src, %eax|%eax, $src}", []>;
1513 def SBB64i32 : RIi32<0x1D, RawFrm, (outs), (ins i64i32imm:$src),
1514                      "sbb{q}\t{$src, %rax|%rax, $src}", []>;
1515
1516 let Constraints = "$src1 = $dst" in {
1517
1518 let isCodeGenOnly = 1 in {
1519 def SBB8rr_REV : I<0x1A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1520                    "sbb{b}\t{$src2, $dst|$dst, $src2}", []>;
1521 def SBB16rr_REV : I<0x1B, MRMSrcReg, (outs GR16:$dst),
1522                     (ins GR16:$src1, GR16:$src2),
1523                     "sbb{w}\t{$src2, $dst|$dst, $src2}", []>, OpSize;
1524 def SBB32rr_REV : I<0x1B, MRMSrcReg, (outs GR32:$dst),
1525                     (ins GR32:$src1, GR32:$src2),
1526                     "sbb{l}\t{$src2, $dst|$dst, $src2}", []>;
1527 def SBB64rr_REV : RI<0x1B, MRMSrcReg, (outs GR64:$dst),
1528                      (ins GR64:$src1, GR64:$src2),
1529                      "sbb{q}\t{$src2, $dst|$dst, $src2}", []>;
1530 }
1531
1532 def SBB8rm   : I<0x1A, MRMSrcMem, (outs GR8:$dst), (ins GR8:$src1, i8mem:$src2),
1533                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1534                     [(set GR8:$dst, (sube GR8:$src1, (load addr:$src2)))]>;
1535 def SBB16rm  : I<0x1B, MRMSrcMem, (outs GR16:$dst),
1536                                   (ins GR16:$src1, i16mem:$src2),
1537                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1538                     [(set GR16:$dst, (sube GR16:$src1, (load addr:$src2)))]>,
1539                     OpSize;
1540 def SBB32rm  : I<0x1B, MRMSrcMem, (outs GR32:$dst),
1541                                   (ins GR32:$src1, i32mem:$src2),
1542                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1543                     [(set GR32:$dst, (sube GR32:$src1, (load addr:$src2)))]>;
1544 def SBB64rm  : RI<0x1B, MRMSrcMem, (outs GR64:$dst),
1545                   (ins GR64:$src1, i64mem:$src2),
1546                   "sbb{q}\t{$src2, $dst|$dst, $src2}",
1547                   [(set GR64:$dst, (sube GR64:$src1, (load addr:$src2)))]>;
1548 def SBB8ri   : Ii8<0x80, MRM3r, (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1549                     "sbb{b}\t{$src2, $dst|$dst, $src2}",
1550                     [(set GR8:$dst, (sube GR8:$src1, imm:$src2))]>;
1551 def SBB16ri  : Ii16<0x81, MRM3r, (outs GR16:$dst),
1552                                  (ins GR16:$src1, i16imm:$src2),
1553                     "sbb{w}\t{$src2, $dst|$dst, $src2}",
1554                     [(set GR16:$dst, (sube GR16:$src1, imm:$src2))]>, OpSize;
1555 def SBB16ri8 : Ii8<0x83, MRM3r, (outs GR16:$dst),
1556                                 (ins GR16:$src1, i16i8imm:$src2),
1557                    "sbb{w}\t{$src2, $dst|$dst, $src2}",
1558                    [(set GR16:$dst, (sube GR16:$src1, i16immSExt8:$src2))]>,
1559                    OpSize;
1560 def SBB32ri  : Ii32<0x81, MRM3r, (outs GR32:$dst),
1561                                  (ins GR32:$src1, i32imm:$src2),
1562                     "sbb{l}\t{$src2, $dst|$dst, $src2}",
1563                     [(set GR32:$dst, (sube GR32:$src1, imm:$src2))]>;
1564 def SBB32ri8 : Ii8<0x83, MRM3r, (outs GR32:$dst),
1565                                 (ins GR32:$src1, i32i8imm:$src2),
1566                    "sbb{l}\t{$src2, $dst|$dst, $src2}",
1567                    [(set GR32:$dst, (sube GR32:$src1, i32immSExt8:$src2))]>;
1568 def SBB64ri32 : RIi32<0x81, MRM3r, (outs GR64:$dst),
1569                       (ins GR64:$src1, i64i32imm:$src2),
1570                       "sbb{q}\t{$src2, $dst|$dst, $src2}",
1571                       [(set GR64:$dst, (sube GR64:$src1, i64immSExt32:$src2))]>;
1572 def SBB64ri8 : RIi8<0x83, MRM3r, (outs GR64:$dst),
1573                     (ins GR64:$src1, i64i8imm:$src2),
1574                     "sbb{q}\t{$src2, $dst|$dst, $src2}",
1575                     [(set GR64:$dst, (sube GR64:$src1, i64immSExt8:$src2))]>;
1576
1577 } // Constraints = "$src1 = $dst"
1578 } // Uses = [EFLAGS]
1579 } // Defs = [EFLAGS]
1580
1581 //===----------------------------------------------------------------------===//
1582 // Test instructions are just like AND, except they don't generate a result.
1583 //
1584 let Defs = [EFLAGS] in {
1585 let isCommutable = 1 in {   // TEST X, Y   --> TEST Y, X
1586 def TEST8rr  : I<0x84, MRMSrcReg, (outs),  (ins GR8:$src1, GR8:$src2),
1587                      "test{b}\t{$src2, $src1|$src1, $src2}",
1588                      [(set EFLAGS, (X86cmp (and_su GR8:$src1, GR8:$src2), 0))]>;
1589 def TEST16rr : I<0x85, MRMSrcReg, (outs),  (ins GR16:$src1, GR16:$src2),
1590                      "test{w}\t{$src2, $src1|$src1, $src2}",
1591                      [(set EFLAGS, (X86cmp (and_su GR16:$src1, GR16:$src2),
1592                       0))]>,
1593                  OpSize;
1594 def TEST32rr : I<0x85, MRMSrcReg, (outs),  (ins GR32:$src1, GR32:$src2),
1595                      "test{l}\t{$src2, $src1|$src1, $src2}",
1596                      [(set EFLAGS, (X86cmp (and_su GR32:$src1, GR32:$src2),
1597                       0))]>;
1598 def TEST64rr : RI<0x85, MRMSrcReg, (outs), (ins GR64:$src1, GR64:$src2),
1599                   "test{q}\t{$src2, $src1|$src1, $src2}",
1600                   [(set EFLAGS, (X86cmp (and GR64:$src1, GR64:$src2), 0))]>;
1601 }
1602
1603 def TEST8rm  : I<0x84, MRMSrcMem, (outs),  (ins GR8 :$src1, i8mem :$src2),
1604                      "test{b}\t{$src2, $src1|$src1, $src2}",
1605                      [(set EFLAGS, (X86cmp (and GR8:$src1, (loadi8 addr:$src2)),
1606                        0))]>;
1607 def TEST16rm : I<0x85, MRMSrcMem, (outs),  (ins GR16:$src1, i16mem:$src2),
1608                      "test{w}\t{$src2, $src1|$src1, $src2}",
1609                      [(set EFLAGS, (X86cmp (and GR16:$src1,
1610                                          (loadi16 addr:$src2)), 0))]>, OpSize;
1611 def TEST32rm : I<0x85, MRMSrcMem, (outs),  (ins GR32:$src1, i32mem:$src2),
1612                      "test{l}\t{$src2, $src1|$src1, $src2}",
1613                      [(set EFLAGS, (X86cmp (and GR32:$src1,
1614                                                 (loadi32 addr:$src2)), 0))]>;
1615 def TEST64rm : RI<0x85, MRMSrcMem, (outs), (ins GR64:$src1, i64mem:$src2),
1616                   "test{q}\t{$src2, $src1|$src1, $src2}",
1617                   [(set EFLAGS, (X86cmp (and GR64:$src1, (loadi64 addr:$src2)),
1618                     0))]>;
1619
1620 def TEST8ri  : Ii8 <0xF6, MRM0r,                     // flags = GR8  & imm8
1621                     (outs),  (ins GR8:$src1, i8imm:$src2),
1622                     "test{b}\t{$src2, $src1|$src1, $src2}",
1623                     [(set EFLAGS, (X86cmp (and_su GR8:$src1, imm:$src2), 0))]>;
1624 def TEST16ri : Ii16<0xF7, MRM0r,                     // flags = GR16 & imm16
1625                     (outs),  (ins GR16:$src1, i16imm:$src2),
1626                     "test{w}\t{$src2, $src1|$src1, $src2}",
1627                     [(set EFLAGS, (X86cmp (and_su GR16:$src1, imm:$src2), 0))]>,
1628                     OpSize;
1629 def TEST32ri : Ii32<0xF7, MRM0r,                     // flags = GR32 & imm32
1630                     (outs),  (ins GR32:$src1, i32imm:$src2),
1631                     "test{l}\t{$src2, $src1|$src1, $src2}",
1632                     [(set EFLAGS, (X86cmp (and_su GR32:$src1, imm:$src2), 0))]>;
1633 def TEST64ri32 : RIi32<0xF7, MRM0r, (outs),
1634                                         (ins GR64:$src1, i64i32imm:$src2),
1635                        "test{q}\t{$src2, $src1|$src1, $src2}",
1636                      [(set EFLAGS, (X86cmp (and GR64:$src1, i64immSExt32:$src2),
1637                       0))]>;
1638
1639 def TEST8mi  : Ii8 <0xF6, MRM0m,                   // flags = [mem8]  & imm8
1640                     (outs), (ins i8mem:$src1, i8imm:$src2),
1641                     "test{b}\t{$src2, $src1|$src1, $src2}",
1642                     [(set EFLAGS, (X86cmp (and (loadi8 addr:$src1), imm:$src2),
1643                      0))]>;
1644 def TEST16mi : Ii16<0xF7, MRM0m,                   // flags = [mem16] & imm16
1645                     (outs), (ins i16mem:$src1, i16imm:$src2),
1646                     "test{w}\t{$src2, $src1|$src1, $src2}",
1647                     [(set EFLAGS, (X86cmp (and (loadi16 addr:$src1), imm:$src2),
1648                      0))]>, OpSize;
1649 def TEST32mi : Ii32<0xF7, MRM0m,                   // flags = [mem32] & imm32
1650                     (outs), (ins i32mem:$src1, i32imm:$src2),
1651                     "test{l}\t{$src2, $src1|$src1, $src2}",
1652                     [(set EFLAGS, (X86cmp (and (loadi32 addr:$src1), imm:$src2),
1653                      0))]>;
1654 def TEST64mi32 : RIi32<0xF7, MRM0m, (outs),
1655                                         (ins i64mem:$src1, i64i32imm:$src2),
1656                        "test{q}\t{$src2, $src1|$src1, $src2}",
1657                 [(set EFLAGS, (X86cmp (and (loadi64 addr:$src1),
1658                                            i64immSExt32:$src2), 0))]>;
1659
1660 def TEST8i8  : Ii8<0xA8, RawFrm, (outs), (ins i8imm:$src),
1661                    "test{b}\t{$src, %al|%al, $src}", []>;
1662 def TEST16i16 : Ii16<0xA9, RawFrm, (outs), (ins i16imm:$src),
1663                      "test{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1664 def TEST32i32 : Ii32<0xA9, RawFrm, (outs), (ins i32imm:$src),
1665                      "test{l}\t{$src, %eax|%eax, $src}", []>;
1666 def TEST64i32 : RIi32<0xa9, RawFrm, (outs), (ins i64i32imm:$src),
1667                       "test{q}\t{$src, %rax|%rax, $src}", []>;
1668
1669 } // Defs = [EFLAGS]
1670
1671
1672 //===----------------------------------------------------------------------===//
1673 // Integer comparisons
1674
1675 let Defs = [EFLAGS] in {
1676
1677 def CMP8rr  : I<0x38, MRMDestReg,
1678                 (outs), (ins GR8 :$src1, GR8 :$src2),
1679                 "cmp{b}\t{$src2, $src1|$src1, $src2}",
1680                 [(set EFLAGS, (X86cmp GR8:$src1, GR8:$src2))]>;
1681 def CMP16rr : I<0x39, MRMDestReg,
1682                 (outs), (ins GR16:$src1, GR16:$src2),
1683                 "cmp{w}\t{$src2, $src1|$src1, $src2}",
1684                 [(set EFLAGS, (X86cmp GR16:$src1, GR16:$src2))]>, OpSize;
1685 def CMP32rr : I<0x39, MRMDestReg,
1686                 (outs), (ins GR32:$src1, GR32:$src2),
1687                 "cmp{l}\t{$src2, $src1|$src1, $src2}",
1688                 [(set EFLAGS, (X86cmp GR32:$src1, GR32:$src2))]>;
1689 def CMP64rr : RI<0x39, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
1690                  "cmp{q}\t{$src2, $src1|$src1, $src2}",
1691                  [(set EFLAGS, (X86cmp GR64:$src1, GR64:$src2))]>;
1692
1693 def CMP8mr  : I<0x38, MRMDestMem,
1694                 (outs), (ins i8mem :$src1, GR8 :$src2),
1695                 "cmp{b}\t{$src2, $src1|$src1, $src2}",
1696                 [(set EFLAGS, (X86cmp (loadi8 addr:$src1), GR8:$src2))]>;
1697 def CMP16mr : I<0x39, MRMDestMem,
1698                 (outs), (ins i16mem:$src1, GR16:$src2),
1699                 "cmp{w}\t{$src2, $src1|$src1, $src2}",
1700                 [(set EFLAGS, (X86cmp (loadi16 addr:$src1), GR16:$src2))]>,
1701                  OpSize;
1702 def CMP32mr : I<0x39, MRMDestMem,
1703                 (outs), (ins i32mem:$src1, GR32:$src2),
1704                 "cmp{l}\t{$src2, $src1|$src1, $src2}",
1705                 [(set EFLAGS, (X86cmp (loadi32 addr:$src1), GR32:$src2))]>;
1706 def CMP64mr : RI<0x39, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
1707                  "cmp{q}\t{$src2, $src1|$src1, $src2}",
1708                  [(set EFLAGS, (X86cmp (loadi64 addr:$src1), GR64:$src2))]>;
1709
1710 def CMP8rm  : I<0x3A, MRMSrcMem,
1711                 (outs), (ins GR8 :$src1, i8mem :$src2),
1712                 "cmp{b}\t{$src2, $src1|$src1, $src2}",
1713                 [(set EFLAGS, (X86cmp GR8:$src1, (loadi8 addr:$src2)))]>;
1714 def CMP16rm : I<0x3B, MRMSrcMem,
1715                 (outs), (ins GR16:$src1, i16mem:$src2),
1716                 "cmp{w}\t{$src2, $src1|$src1, $src2}",
1717                 [(set EFLAGS, (X86cmp GR16:$src1, (loadi16 addr:$src2)))]>,
1718                  OpSize;
1719 def CMP32rm : I<0x3B, MRMSrcMem,
1720                 (outs), (ins GR32:$src1, i32mem:$src2),
1721                 "cmp{l}\t{$src2, $src1|$src1, $src2}",
1722                 [(set EFLAGS, (X86cmp GR32:$src1, (loadi32 addr:$src2)))]>;
1723 def CMP64rm : RI<0x3B, MRMSrcMem, (outs), (ins GR64:$src1, i64mem:$src2),
1724                  "cmp{q}\t{$src2, $src1|$src1, $src2}",
1725                  [(set EFLAGS, (X86cmp GR64:$src1, (loadi64 addr:$src2)))]>;
1726
1727 // These are alternate spellings for use by the disassembler, we mark them as
1728 // code gen only to ensure they aren't matched by the assembler.
1729 let isCodeGenOnly = 1 in {
1730   def CMP8rr_alt : I<0x3A, MRMSrcReg, (outs), (ins GR8:$src1, GR8:$src2),
1731                     "cmp{b}\t{$src2, $src1|$src1, $src2}", []>;
1732   def CMP16rr_alt : I<0x3B, MRMSrcReg, (outs), (ins GR16:$src1, GR16:$src2),
1733                      "cmp{w}\t{$src2, $src1|$src1, $src2}", []>, OpSize;
1734   def CMP32rr_alt : I<0x3B, MRMSrcReg, (outs), (ins GR32:$src1, GR32:$src2),
1735                      "cmp{l}\t{$src2, $src1|$src1, $src2}", []>;
1736   def CMP64rr_alt : RI<0x3B, MRMSrcReg, (outs), (ins GR64:$src1, GR64:$src2),
1737                       "cmp{q}\t{$src2, $src1|$src1, $src2}", []>;
1738 }
1739
1740 def CMP8ri  : Ii8<0x80, MRM7r,
1741                   (outs), (ins GR8:$src1, i8imm:$src2),
1742                   "cmp{b}\t{$src2, $src1|$src1, $src2}",
1743                   [(set EFLAGS, (X86cmp GR8:$src1, imm:$src2))]>;
1744 def CMP16ri : Ii16<0x81, MRM7r,
1745                    (outs), (ins GR16:$src1, i16imm:$src2),
1746                    "cmp{w}\t{$src2, $src1|$src1, $src2}",
1747                    [(set EFLAGS, (X86cmp GR16:$src1, imm:$src2))]>, OpSize;
1748 def CMP32ri : Ii32<0x81, MRM7r,
1749                    (outs), (ins GR32:$src1, i32imm:$src2),
1750                    "cmp{l}\t{$src2, $src1|$src1, $src2}",
1751                    [(set EFLAGS, (X86cmp GR32:$src1, imm:$src2))]>;
1752 def CMP64ri32 : RIi32<0x81, MRM7r, (outs), (ins GR64:$src1, i64i32imm:$src2),
1753                       "cmp{q}\t{$src2, $src1|$src1, $src2}",
1754                       [(set EFLAGS, (X86cmp GR64:$src1, i64immSExt32:$src2))]>;
1755
1756 def CMP8mi  : Ii8 <0x80, MRM7m,
1757                    (outs), (ins i8mem :$src1, i8imm :$src2),
1758                    "cmp{b}\t{$src2, $src1|$src1, $src2}",
1759                    [(set EFLAGS, (X86cmp (loadi8 addr:$src1), imm:$src2))]>;
1760 def CMP16mi : Ii16<0x81, MRM7m,
1761                    (outs), (ins i16mem:$src1, i16imm:$src2),
1762                    "cmp{w}\t{$src2, $src1|$src1, $src2}",
1763                    [(set EFLAGS, (X86cmp (loadi16 addr:$src1), imm:$src2))]>,
1764                    OpSize;
1765 def CMP32mi : Ii32<0x81, MRM7m,
1766                    (outs), (ins i32mem:$src1, i32imm:$src2),
1767                    "cmp{l}\t{$src2, $src1|$src1, $src2}",
1768                    [(set EFLAGS, (X86cmp (loadi32 addr:$src1), imm:$src2))]>;
1769 def CMP64mi32 : RIi32<0x81, MRM7m, (outs),
1770                                        (ins i64mem:$src1, i64i32imm:$src2),
1771                       "cmp{q}\t{$src2, $src1|$src1, $src2}",
1772                       [(set EFLAGS, (X86cmp (loadi64 addr:$src1),
1773                                             i64immSExt32:$src2))]>;
1774
1775 def CMP16ri8 : Ii8<0x83, MRM7r,
1776                    (outs), (ins GR16:$src1, i16i8imm:$src2),
1777                    "cmp{w}\t{$src2, $src1|$src1, $src2}",
1778                    [(set EFLAGS, (X86cmp GR16:$src1, i16immSExt8:$src2))]>,
1779                     OpSize;
1780 def CMP32ri8 : Ii8<0x83, MRM7r,
1781                    (outs), (ins GR32:$src1, i32i8imm:$src2),
1782                    "cmp{l}\t{$src2, $src1|$src1, $src2}",
1783                    [(set EFLAGS, (X86cmp GR32:$src1, i32immSExt8:$src2))]>;
1784 def CMP64ri8 : RIi8<0x83, MRM7r, (outs), (ins GR64:$src1, i64i8imm:$src2),
1785                     "cmp{q}\t{$src2, $src1|$src1, $src2}",
1786                     [(set EFLAGS, (X86cmp GR64:$src1, i64immSExt8:$src2))]>;
1787
1788 def CMP16mi8 : Ii8<0x83, MRM7m,
1789                    (outs), (ins i16mem:$src1, i16i8imm:$src2),
1790                    "cmp{w}\t{$src2, $src1|$src1, $src2}",
1791                    [(set EFLAGS, (X86cmp (loadi16 addr:$src1),
1792                                          i16immSExt8:$src2))]>, OpSize;
1793 def CMP32mi8 : Ii8<0x83, MRM7m,
1794                    (outs), (ins i32mem:$src1, i32i8imm:$src2),
1795                    "cmp{l}\t{$src2, $src1|$src1, $src2}",
1796                    [(set EFLAGS, (X86cmp (loadi32 addr:$src1),
1797                                          i32immSExt8:$src2))]>;
1798 def CMP64mi8 : RIi8<0x83, MRM7m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
1799                     "cmp{q}\t{$src2, $src1|$src1, $src2}",
1800                     [(set EFLAGS, (X86cmp (loadi64 addr:$src1),
1801                                           i64immSExt8:$src2))]>;
1802
1803 def CMP8i8 : Ii8<0x3C, RawFrm, (outs), (ins i8imm:$src),
1804                  "cmp{b}\t{$src, %al|%al, $src}", []>;
1805 def CMP16i16 : Ii16<0x3D, RawFrm, (outs), (ins i16imm:$src),
1806                     "cmp{w}\t{$src, %ax|%ax, $src}", []>, OpSize;
1807 def CMP32i32 : Ii32<0x3D, RawFrm, (outs), (ins i32imm:$src),
1808                     "cmp{l}\t{$src, %eax|%eax, $src}", []>;
1809 def CMP64i32 : RIi32<0x3D, RawFrm, (outs), (ins i64i32imm:$src),
1810                      "cmp{q}\t{$src, %rax|%rax, $src}", []>;
1811
1812 } // Defs = [EFLAGS]