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