lib/Target/X86/X86InstrArithmetic.td

   1 //===-- X86InstrArithmetic.td - Integer Arithmetic Instrs --*- tablegen -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file describes the integer arithmetic instructions in the X86
  10 // architecture.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // LEA - Load Effective Address
  16 let SchedRW = [WriteLEA] in {
  17 let hasSideEffects = 0 in
  18 def LEA16r   : I<0x8D, MRMSrcMem,
  19                  (outs GR16:$dst), (ins anymem:$src),
  20                  "lea{w}\t{$src|$dst}, {$dst|$src}", []>, OpSize16;
  21 let isReMaterializable = 1 in
  22 def LEA32r   : I<0x8D, MRMSrcMem,
  23                  (outs GR32:$dst), (ins anymem:$src),
  24                  "lea{l}\t{$src|$dst}, {$dst|$src}",
  25                  [(set GR32:$dst, lea32addr:$src)]>,
  26                  OpSize32, Requires<[Not64BitMode]>;
  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, lea64_32addr:$src)]>,
  32                   OpSize32, Requires<[In64BitMode]>;
  33
  34 let isReMaterializable = 1 in
  35 def LEA64r   : RI<0x8D, MRMSrcMem, (outs GR64:$dst), (ins lea64mem:$src),
  36                   "lea{q}\t{$src|$dst}, {$dst|$src}",
  37                   [(set GR64:$dst, lea64addr:$src)]>;
  38 } // SchedRW
  39
  40 //===----------------------------------------------------------------------===//
  41 //  Fixed-Register Multiplication and Division Instructions.
  42 //
  43
  44 // SchedModel info for instruction that loads one value and gets the second
  45 // (and possibly third) value from a register.
  46 // This is used for instructions that put the memory operands before other
  47 // uses.
  48 class SchedLoadReg<X86FoldableSchedWrite Sched> : Sched<[Sched.Folded,
  49   // Memory operand.
  50   ReadDefault, ReadDefault, ReadDefault, ReadDefault, ReadDefault,
  51   // Register reads (implicit or explicit).
  52   Sched.ReadAfterFold, Sched.ReadAfterFold]>;
  53
  54 // Extra precision multiplication
  55
  56 // AL is really implied by AX, but the registers in Defs must match the
  57 // SDNode results (i8, i32).
  58 // AL,AH = AL*GR8
  59 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  60 def MUL8r  : I<0xF6, MRM4r, (outs),  (ins GR8:$src), "mul{b}\t$src",
  61                // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
  62                // This probably ought to be moved to a def : Pat<> if the
  63                // syntax can be accepted.
  64                [(set AL, (mul AL, GR8:$src)),
  65                 (implicit EFLAGS)]>, Sched<[WriteIMul8]>;
  66 // AX,DX = AX*GR16
  67 let Defs = [AX,DX,EFLAGS], Uses = [AX], hasSideEffects = 0 in
  68 def MUL16r : I<0xF7, MRM4r, (outs),  (ins GR16:$src),
  69                "mul{w}\t$src",
  70                []>, OpSize16, Sched<[WriteIMul16]>;
  71 // EAX,EDX = EAX*GR32
  72 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX], hasSideEffects = 0 in
  73 def MUL32r : I<0xF7, MRM4r, (outs),  (ins GR32:$src),
  74                "mul{l}\t$src",
  75                [/*(set EAX, EDX, EFLAGS, (X86umul_flag EAX, GR32:$src))*/]>,
  76                OpSize32, Sched<[WriteIMul32]>;
  77 // RAX,RDX = RAX*GR64
  78 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX], hasSideEffects = 0 in
  79 def MUL64r : RI<0xF7, MRM4r, (outs), (ins GR64:$src),
  80                 "mul{q}\t$src",
  81                 [/*(set RAX, RDX, EFLAGS, (X86umul_flag RAX, GR64:$src))*/]>,
  82                 Sched<[WriteIMul64]>;
  83 // AL,AH = AL*[mem8]
  84 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
  85 def MUL8m  : I<0xF6, MRM4m, (outs), (ins i8mem :$src),
  86                "mul{b}\t$src",
  87                // FIXME: Used for 8-bit mul, ignore result upper 8 bits.
  88                // This probably ought to be moved to a def : Pat<> if the
  89                // syntax can be accepted.
  90                [(set AL, (mul AL, (loadi8 addr:$src))),
  91                 (implicit EFLAGS)]>, SchedLoadReg<WriteIMul8>;
  92 // AX,DX = AX*[mem16]
  93 let mayLoad = 1, hasSideEffects = 0 in {
  94 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
  95 def MUL16m : I<0xF7, MRM4m, (outs), (ins i16mem:$src),
  96                "mul{w}\t$src", []>, OpSize16, SchedLoadReg<WriteIMul16>;
  97 // EAX,EDX = EAX*[mem32]
  98 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
  99 def MUL32m : I<0xF7, MRM4m, (outs), (ins i32mem:$src),
 100               "mul{l}\t$src", []>, OpSize32, SchedLoadReg<WriteIMul32>;
 101 // RAX,RDX = RAX*[mem64]
 102 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX] in
 103 def MUL64m : RI<0xF7, MRM4m, (outs), (ins i64mem:$src),
 104                 "mul{q}\t$src", []>, SchedLoadReg<WriteIMul64>,
 105                 Requires<[In64BitMode]>;
 106 }
 107
 108 let hasSideEffects = 0 in {
 109 // AL,AH = AL*GR8
 110 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
 111 def IMUL8r  : I<0xF6, MRM5r, (outs),  (ins GR8:$src), "imul{b}\t$src", []>,
 112                 Sched<[WriteIMul8]>;
 113 // AX,DX = AX*GR16
 114 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
 115 def IMUL16r : I<0xF7, MRM5r, (outs),  (ins GR16:$src), "imul{w}\t$src", []>,
 116                 OpSize16, Sched<[WriteIMul16]>;
 117 // EAX,EDX = EAX*GR32
 118 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
 119 def IMUL32r : I<0xF7, MRM5r, (outs),  (ins GR32:$src), "imul{l}\t$src", []>,
 120                 OpSize32, Sched<[WriteIMul32]>;
 121 // RAX,RDX = RAX*GR64
 122 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX] in
 123 def IMUL64r : RI<0xF7, MRM5r, (outs), (ins GR64:$src), "imul{q}\t$src", []>,
 124                  Sched<[WriteIMul64]>;
 125
 126 let mayLoad = 1 in {
 127 // AL,AH = AL*[mem8]
 128 let Defs = [AL,EFLAGS,AX], Uses = [AL] in
 129 def IMUL8m  : I<0xF6, MRM5m, (outs), (ins i8mem :$src),
 130                 "imul{b}\t$src", []>, SchedLoadReg<WriteIMul8>;
 131 // AX,DX = AX*[mem16]
 132 let Defs = [AX,DX,EFLAGS], Uses = [AX] in
 133 def IMUL16m : I<0xF7, MRM5m, (outs), (ins i16mem:$src),
 134                 "imul{w}\t$src", []>, OpSize16, SchedLoadReg<WriteIMul16>;
 135 // EAX,EDX = EAX*[mem32]
 136 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX] in
 137 def IMUL32m : I<0xF7, MRM5m, (outs), (ins i32mem:$src),
 138                 "imul{l}\t$src", []>, OpSize32, SchedLoadReg<WriteIMul32>;
 139 // RAX,RDX = RAX*[mem64]
 140 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX] in
 141 def IMUL64m : RI<0xF7, MRM5m, (outs), (ins i64mem:$src),
 142                  "imul{q}\t$src", []>, SchedLoadReg<WriteIMul64>,
 143                  Requires<[In64BitMode]>;
 144 }
 145 } // hasSideEffects
 146
 147
 148 let Defs = [EFLAGS] in {
 149 let Constraints = "$src1 = $dst" in {
 150
 151 let isCommutable = 1 in {
 152 // X = IMUL Y, Z --> X = IMUL Z, Y
 153 // Register-Register Signed Integer Multiply
 154 def IMUL16rr : I<0xAF, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src1,GR16:$src2),
 155                  "imul{w}\t{$src2, $dst|$dst, $src2}",
 156                  [(set GR16:$dst, EFLAGS,
 157                        (X86smul_flag GR16:$src1, GR16:$src2))]>,
 158                  Sched<[WriteIMul16Reg]>, TB, OpSize16;
 159 def IMUL32rr : I<0xAF, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src1,GR32:$src2),
 160                  "imul{l}\t{$src2, $dst|$dst, $src2}",
 161                  [(set GR32:$dst, EFLAGS,
 162                        (X86smul_flag GR32:$src1, GR32:$src2))]>,
 163                  Sched<[WriteIMul32Reg]>, TB, OpSize32;
 164 def IMUL64rr : RI<0xAF, MRMSrcReg, (outs GR64:$dst),
 165                                    (ins GR64:$src1, GR64:$src2),
 166                   "imul{q}\t{$src2, $dst|$dst, $src2}",
 167                   [(set GR64:$dst, EFLAGS,
 168                         (X86smul_flag GR64:$src1, GR64:$src2))]>,
 169                   Sched<[WriteIMul64Reg]>, TB;
 170 } // isCommutable
 171
 172 // Register-Memory Signed Integer Multiply
 173 def IMUL16rm : I<0xAF, MRMSrcMem, (outs GR16:$dst),
 174                                   (ins GR16:$src1, i16mem:$src2),
 175                  "imul{w}\t{$src2, $dst|$dst, $src2}",
 176                  [(set GR16:$dst, EFLAGS,
 177                        (X86smul_flag GR16:$src1, (loadi16 addr:$src2)))]>,
 178                  Sched<[WriteIMul16Reg.Folded, WriteIMul16Reg.ReadAfterFold]>, TB, OpSize16;
 179 def IMUL32rm : I<0xAF, MRMSrcMem, (outs GR32:$dst),
 180                  (ins GR32:$src1, i32mem:$src2),
 181                  "imul{l}\t{$src2, $dst|$dst, $src2}",
 182                  [(set GR32:$dst, EFLAGS,
 183                        (X86smul_flag GR32:$src1, (loadi32 addr:$src2)))]>,
 184                  Sched<[WriteIMul32Reg.Folded, WriteIMul32Reg.ReadAfterFold]>, TB, OpSize32;
 185 def IMUL64rm : RI<0xAF, MRMSrcMem, (outs GR64:$dst),
 186                                    (ins GR64:$src1, i64mem:$src2),
 187                   "imul{q}\t{$src2, $dst|$dst, $src2}",
 188                   [(set GR64:$dst, EFLAGS,
 189                         (X86smul_flag GR64:$src1, (loadi64 addr:$src2)))]>,
 190                   Sched<[WriteIMul64Reg.Folded, WriteIMul32Reg.ReadAfterFold]>, TB;
 191 } // Constraints = "$src1 = $dst"
 192
 193 } // Defs = [EFLAGS]
 194
 195 // Surprisingly enough, these are not two address instructions!
 196 let Defs = [EFLAGS] in {
 197 // NOTE: These are order specific, we want the ri8 forms to be listed
 198 // first so that they are slightly preferred to the ri forms.
 199
 200 // Register-Integer Signed Integer Multiply
 201 def IMUL16rri8 : Ii8<0x6B, MRMSrcReg,                       // GR16 = GR16*I8
 202                      (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
 203                      "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 204                      [(set GR16:$dst, EFLAGS,
 205                            (X86smul_flag GR16:$src1, i16immSExt8:$src2))]>,
 206                      Sched<[WriteIMul16Imm]>, OpSize16;
 207 def IMUL16rri  : Ii16<0x69, MRMSrcReg,                      // GR16 = GR16*I16
 208                       (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
 209                       "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 210                       [(set GR16:$dst, EFLAGS,
 211                             (X86smul_flag GR16:$src1, imm:$src2))]>,
 212                       Sched<[WriteIMul16Imm]>, OpSize16;
 213 def IMUL32rri  : Ii32<0x69, MRMSrcReg,                      // GR32 = GR32*I32
 214                       (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
 215                       "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 216                       [(set GR32:$dst, EFLAGS,
 217                             (X86smul_flag GR32:$src1, imm:$src2))]>,
 218                       Sched<[WriteIMul32Imm]>, OpSize32;
 219 def IMUL32rri8 : Ii8<0x6B, MRMSrcReg,                       // GR32 = GR32*I8
 220                      (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
 221                      "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 222                      [(set GR32:$dst, EFLAGS,
 223                            (X86smul_flag GR32:$src1, i32immSExt8:$src2))]>,
 224                      Sched<[WriteIMul32Imm]>, OpSize32;
 225 def IMUL64rri8 : RIi8<0x6B, MRMSrcReg,                      // GR64 = GR64*I8
 226                       (outs GR64:$dst), (ins GR64:$src1, i64i8imm:$src2),
 227                       "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 228                       [(set GR64:$dst, EFLAGS,
 229                             (X86smul_flag GR64:$src1, i64immSExt8:$src2))]>,
 230                       Sched<[WriteIMul64Imm]>;
 231 def IMUL64rri32 : RIi32S<0x69, MRMSrcReg,                    // GR64 = GR64*I32
 232                          (outs GR64:$dst), (ins GR64:$src1, i64i32imm:$src2),
 233                          "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 234                          [(set GR64:$dst, EFLAGS,
 235                              (X86smul_flag GR64:$src1, i64immSExt32:$src2))]>,
 236                          Sched<[WriteIMul64Imm]>;
 237
 238 // Memory-Integer Signed Integer Multiply
 239 def IMUL16rmi8 : Ii8<0x6B, MRMSrcMem,                       // GR16 = [mem16]*I8
 240                      (outs GR16:$dst), (ins i16mem:$src1, i16i8imm :$src2),
 241                      "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 242                      [(set GR16:$dst, EFLAGS,
 243                            (X86smul_flag (loadi16 addr:$src1),
 244                                          i16immSExt8:$src2))]>,
 245                      Sched<[WriteIMul16Imm.Folded]>, OpSize16;
 246 def IMUL16rmi  : Ii16<0x69, MRMSrcMem,                     // GR16 = [mem16]*I16
 247                       (outs GR16:$dst), (ins i16mem:$src1, i16imm:$src2),
 248                       "imul{w}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 249                       [(set GR16:$dst, EFLAGS,
 250                             (X86smul_flag (loadi16 addr:$src1), imm:$src2))]>,
 251                       Sched<[WriteIMul16Imm.Folded]>, OpSize16;
 252 def IMUL32rmi8 : Ii8<0x6B, MRMSrcMem,                       // GR32 = [mem32]*I8
 253                      (outs GR32:$dst), (ins i32mem:$src1, i32i8imm: $src2),
 254                      "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 255                      [(set GR32:$dst, EFLAGS,
 256                            (X86smul_flag (loadi32 addr:$src1),
 257                                          i32immSExt8:$src2))]>,
 258                      Sched<[WriteIMul32Imm.Folded]>, OpSize32;
 259 def IMUL32rmi  : Ii32<0x69, MRMSrcMem,                     // GR32 = [mem32]*I32
 260                       (outs GR32:$dst), (ins i32mem:$src1, i32imm:$src2),
 261                       "imul{l}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 262                       [(set GR32:$dst, EFLAGS,
 263                             (X86smul_flag (loadi32 addr:$src1), imm:$src2))]>,
 264                       Sched<[WriteIMul32Imm.Folded]>, OpSize32;
 265 def IMUL64rmi8 : RIi8<0x6B, MRMSrcMem,                      // GR64 = [mem64]*I8
 266                       (outs GR64:$dst), (ins i64mem:$src1, i64i8imm: $src2),
 267                       "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 268                       [(set GR64:$dst, EFLAGS,
 269                             (X86smul_flag (loadi64 addr:$src1),
 270                                           i64immSExt8:$src2))]>,
 271                       Sched<[WriteIMul64Imm.Folded]>;
 272 def IMUL64rmi32 : RIi32S<0x69, MRMSrcMem,                   // GR64 = [mem64]*I32
 273                          (outs GR64:$dst), (ins i64mem:$src1, i64i32imm:$src2),
 274                          "imul{q}\t{$src2, $src1, $dst|$dst, $src1, $src2}",
 275                          [(set GR64:$dst, EFLAGS,
 276                               (X86smul_flag (loadi64 addr:$src1),
 277                                             i64immSExt32:$src2))]>,
 278                          Sched<[WriteIMul64Imm.Folded]>;
 279 } // Defs = [EFLAGS]
 280
 281 // unsigned division/remainder
 282 let hasSideEffects = 1 in { // so that we don't speculatively execute
 283 let Defs = [AL,AH,EFLAGS], Uses = [AX] in
 284 def DIV8r  : I<0xF6, MRM6r, (outs),  (ins GR8:$src),    // AX/r8 = AL,AH
 285                "div{b}\t$src", []>, Sched<[WriteDiv8]>;
 286 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 287 def DIV16r : I<0xF7, MRM6r, (outs),  (ins GR16:$src),   // DX:AX/r16 = AX,DX
 288                "div{w}\t$src", []>, Sched<[WriteDiv16]>, OpSize16;
 289 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 290 def DIV32r : I<0xF7, MRM6r, (outs),  (ins GR32:$src),   // EDX:EAX/r32 = EAX,EDX
 291                "div{l}\t$src", []>, Sched<[WriteDiv32]>, OpSize32;
 292 // RDX:RAX/r64 = RAX,RDX
 293 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in
 294 def DIV64r : RI<0xF7, MRM6r, (outs), (ins GR64:$src),
 295                 "div{q}\t$src", []>, Sched<[WriteDiv64]>;
 296
 297 let mayLoad = 1 in {
 298 let Defs = [AL,AH,EFLAGS], Uses = [AX] in
 299 def DIV8m  : I<0xF6, MRM6m, (outs), (ins i8mem:$src),   // AX/[mem8] = AL,AH
 300                "div{b}\t$src", []>, SchedLoadReg<WriteDiv8>;
 301 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 302 def DIV16m : I<0xF7, MRM6m, (outs), (ins i16mem:$src),  // DX:AX/[mem16] = AX,DX
 303                "div{w}\t$src", []>, OpSize16, SchedLoadReg<WriteDiv16>;
 304 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in    // EDX:EAX/[mem32] = EAX,EDX
 305 def DIV32m : I<0xF7, MRM6m, (outs), (ins i32mem:$src),
 306                "div{l}\t$src", []>, SchedLoadReg<WriteDiv32>, OpSize32;
 307 // RDX:RAX/[mem64] = RAX,RDX
 308 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in
 309 def DIV64m : RI<0xF7, MRM6m, (outs), (ins i64mem:$src),
 310                 "div{q}\t$src", []>, SchedLoadReg<WriteDiv64>,
 311                 Requires<[In64BitMode]>;
 312 }
 313
 314 // Signed division/remainder.
 315 let Defs = [AL,AH,EFLAGS], Uses = [AX] in
 316 def IDIV8r : I<0xF6, MRM7r, (outs),  (ins GR8:$src),    // AX/r8 = AL,AH
 317                "idiv{b}\t$src", []>, Sched<[WriteIDiv8]>;
 318 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 319 def IDIV16r: I<0xF7, MRM7r, (outs),  (ins GR16:$src),   // DX:AX/r16 = AX,DX
 320                "idiv{w}\t$src", []>, Sched<[WriteIDiv16]>, OpSize16;
 321 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in
 322 def IDIV32r: I<0xF7, MRM7r, (outs),  (ins GR32:$src),   // EDX:EAX/r32 = EAX,EDX
 323                "idiv{l}\t$src", []>, Sched<[WriteIDiv32]>, OpSize32;
 324 // RDX:RAX/r64 = RAX,RDX
 325 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in
 326 def IDIV64r: RI<0xF7, MRM7r, (outs), (ins GR64:$src),
 327                 "idiv{q}\t$src", []>, Sched<[WriteIDiv64]>;
 328
 329 let mayLoad = 1 in {
 330 let Defs = [AL,AH,EFLAGS], Uses = [AX] in
 331 def IDIV8m : I<0xF6, MRM7m, (outs), (ins i8mem:$src),   // AX/[mem8] = AL,AH
 332                "idiv{b}\t$src", []>, SchedLoadReg<WriteIDiv8>;
 333 let Defs = [AX,DX,EFLAGS], Uses = [AX,DX] in
 334 def IDIV16m: I<0xF7, MRM7m, (outs), (ins i16mem:$src),  // DX:AX/[mem16] = AX,DX
 335                "idiv{w}\t$src", []>, OpSize16, SchedLoadReg<WriteIDiv16>;
 336 let Defs = [EAX,EDX,EFLAGS], Uses = [EAX,EDX] in    // EDX:EAX/[mem32] = EAX,EDX
 337 def IDIV32m: I<0xF7, MRM7m, (outs), (ins i32mem:$src),
 338                "idiv{l}\t$src", []>, OpSize32, SchedLoadReg<WriteIDiv32>;
 339 let Defs = [RAX,RDX,EFLAGS], Uses = [RAX,RDX] in // RDX:RAX/[mem64] = RAX,RDX
 340 def IDIV64m: RI<0xF7, MRM7m, (outs), (ins i64mem:$src),
 341                 "idiv{q}\t$src", []>, SchedLoadReg<WriteIDiv64>,
 342                 Requires<[In64BitMode]>;
 343 }
 344 } // hasSideEffects = 0
 345
 346 //===----------------------------------------------------------------------===//
 347 //  Two address Instructions.
 348 //
 349
 350 // unary instructions
 351 let CodeSize = 2 in {
 352 let Defs = [EFLAGS] in {
 353 let Constraints = "$src1 = $dst", SchedRW = [WriteALU] in {
 354 def NEG8r  : I<0xF6, MRM3r, (outs GR8 :$dst), (ins GR8 :$src1),
 355                "neg{b}\t$dst",
 356                [(set GR8:$dst, (ineg GR8:$src1)),
 357                 (implicit EFLAGS)]>;
 358 def NEG16r : I<0xF7, MRM3r, (outs GR16:$dst), (ins GR16:$src1),
 359                "neg{w}\t$dst",
 360                [(set GR16:$dst, (ineg GR16:$src1)),
 361                 (implicit EFLAGS)]>, OpSize16;
 362 def NEG32r : I<0xF7, MRM3r, (outs GR32:$dst), (ins GR32:$src1),
 363                "neg{l}\t$dst",
 364                [(set GR32:$dst, (ineg GR32:$src1)),
 365                 (implicit EFLAGS)]>, OpSize32;
 366 def NEG64r : RI<0xF7, MRM3r, (outs GR64:$dst), (ins GR64:$src1), "neg{q}\t$dst",
 367                 [(set GR64:$dst, (ineg GR64:$src1)),
 368                  (implicit EFLAGS)]>;
 369 } // Constraints = "$src1 = $dst", SchedRW
 370
 371 // Read-modify-write negate.
 372 let SchedRW = [WriteALURMW] in {
 373 def NEG8m  : I<0xF6, MRM3m, (outs), (ins i8mem :$dst),
 374                "neg{b}\t$dst",
 375                [(store (ineg (loadi8 addr:$dst)), addr:$dst),
 376                 (implicit EFLAGS)]>;
 377 def NEG16m : I<0xF7, MRM3m, (outs), (ins i16mem:$dst),
 378                "neg{w}\t$dst",
 379                [(store (ineg (loadi16 addr:$dst)), addr:$dst),
 380                 (implicit EFLAGS)]>, OpSize16;
 381 def NEG32m : I<0xF7, MRM3m, (outs), (ins i32mem:$dst),
 382                "neg{l}\t$dst",
 383                [(store (ineg (loadi32 addr:$dst)), addr:$dst),
 384                 (implicit EFLAGS)]>, OpSize32;
 385 def NEG64m : RI<0xF7, MRM3m, (outs), (ins i64mem:$dst), "neg{q}\t$dst",
 386                 [(store (ineg (loadi64 addr:$dst)), addr:$dst),
 387                  (implicit EFLAGS)]>,
 388                 Requires<[In64BitMode]>;
 389 } // SchedRW
 390 } // Defs = [EFLAGS]
 391
 392
 393 // Note: NOT does not set EFLAGS!
 394
 395 let Constraints = "$src1 = $dst", SchedRW = [WriteALU] in {
 396 def NOT8r  : I<0xF6, MRM2r, (outs GR8 :$dst), (ins GR8 :$src1),
 397                "not{b}\t$dst",
 398                [(set GR8:$dst, (not GR8:$src1))]>;
 399 def NOT16r : I<0xF7, MRM2r, (outs GR16:$dst), (ins GR16:$src1),
 400                "not{w}\t$dst",
 401                [(set GR16:$dst, (not GR16:$src1))]>, OpSize16;
 402 def NOT32r : I<0xF7, MRM2r, (outs GR32:$dst), (ins GR32:$src1),
 403                "not{l}\t$dst",
 404                [(set GR32:$dst, (not GR32:$src1))]>, OpSize32;
 405 def NOT64r : RI<0xF7, MRM2r, (outs GR64:$dst), (ins GR64:$src1), "not{q}\t$dst",
 406                 [(set GR64:$dst, (not GR64:$src1))]>;
 407 } // Constraints = "$src1 = $dst", SchedRW
 408
 409 let SchedRW = [WriteALURMW] in {
 410 def NOT8m  : I<0xF6, MRM2m, (outs), (ins i8mem :$dst),
 411                "not{b}\t$dst",
 412                [(store (not (loadi8 addr:$dst)), addr:$dst)]>;
 413 def NOT16m : I<0xF7, MRM2m, (outs), (ins i16mem:$dst),
 414                "not{w}\t$dst",
 415                [(store (not (loadi16 addr:$dst)), addr:$dst)]>,
 416                OpSize16;
 417 def NOT32m : I<0xF7, MRM2m, (outs), (ins i32mem:$dst),
 418                "not{l}\t$dst",
 419                [(store (not (loadi32 addr:$dst)), addr:$dst)]>,
 420                OpSize32;
 421 def NOT64m : RI<0xF7, MRM2m, (outs), (ins i64mem:$dst), "not{q}\t$dst",
 422                 [(store (not (loadi64 addr:$dst)), addr:$dst)]>,
 423                 Requires<[In64BitMode]>;
 424 } // SchedRW
 425 } // CodeSize
 426
 427 def X86add_flag_nocf : PatFrag<(ops node:$lhs, node:$rhs),
 428                                (X86add_flag node:$lhs, node:$rhs), [{
 429   return hasNoCarryFlagUses(SDValue(N, 1));
 430 }]>;
 431
 432 def X86sub_flag_nocf : PatFrag<(ops node:$lhs, node:$rhs),
 433                                (X86sub_flag node:$lhs, node:$rhs), [{
 434   // Only use DEC if the result is used.
 435   return !SDValue(N, 0).use_empty() && hasNoCarryFlagUses(SDValue(N, 1));
 436 }]>;
 437
 438 // TODO: inc/dec is slow for P4, but fast for Pentium-M.
 439 let Defs = [EFLAGS] in {
 440 let Constraints = "$src1 = $dst", SchedRW = [WriteALU] in {
 441 let isConvertibleToThreeAddress = 1, CodeSize = 2 in { // Can xform into LEA.
 442 def INC8r  : I<0xFE, MRM0r, (outs GR8 :$dst), (ins GR8 :$src1),
 443                "inc{b}\t$dst",
 444                [(set GR8:$dst, EFLAGS, (X86add_flag_nocf GR8:$src1, 1))]>;
 445 def INC16r : I<0xFF, MRM0r, (outs GR16:$dst), (ins GR16:$src1),
 446                "inc{w}\t$dst",
 447                [(set GR16:$dst, EFLAGS, (X86add_flag_nocf GR16:$src1, 1))]>,
 448                OpSize16;
 449 def INC32r : I<0xFF, MRM0r, (outs GR32:$dst), (ins GR32:$src1),
 450                "inc{l}\t$dst",
 451                [(set GR32:$dst, EFLAGS, (X86add_flag_nocf GR32:$src1, 1))]>,
 452                OpSize32;
 453 def INC64r : RI<0xFF, MRM0r, (outs GR64:$dst), (ins GR64:$src1), "inc{q}\t$dst",
 454                 [(set GR64:$dst, EFLAGS, (X86add_flag_nocf GR64:$src1, 1))]>;
 455 } // isConvertibleToThreeAddress = 1, CodeSize = 2
 456
 457 // Short forms only valid in 32-bit mode. Selected during MCInst lowering.
 458 let CodeSize = 1, hasSideEffects = 0 in {
 459 def INC16r_alt : I<0x40, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 460                    "inc{w}\t$dst", []>,
 461                  OpSize16, Requires<[Not64BitMode]>;
 462 def INC32r_alt : I<0x40, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 463                    "inc{l}\t$dst", []>,
 464                  OpSize32, Requires<[Not64BitMode]>;
 465 } // CodeSize = 1, hasSideEffects = 0
 466 } // Constraints = "$src1 = $dst", SchedRW
 467
 468 let CodeSize = 2, SchedRW = [WriteALURMW] in {
 469 let Predicates = [UseIncDec] in {
 470   def INC8m  : I<0xFE, MRM0m, (outs), (ins i8mem :$dst), "inc{b}\t$dst",
 471                [(store (add (loadi8 addr:$dst), 1), addr:$dst),
 472                 (implicit EFLAGS)]>;
 473   def INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst), "inc{w}\t$dst",
 474                [(store (add (loadi16 addr:$dst), 1), addr:$dst),
 475                 (implicit EFLAGS)]>, OpSize16;
 476   def INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst), "inc{l}\t$dst",
 477                [(store (add (loadi32 addr:$dst), 1), addr:$dst),
 478                 (implicit EFLAGS)]>, OpSize32;
 479 } // Predicates
 480 let Predicates = [UseIncDec, In64BitMode] in {
 481   def INC64m : RI<0xFF, MRM0m, (outs), (ins i64mem:$dst), "inc{q}\t$dst",
 482                   [(store (add (loadi64 addr:$dst), 1), addr:$dst),
 483                    (implicit EFLAGS)]>;
 484 } // Predicates
 485 } // CodeSize = 2, SchedRW
 486
 487 let Constraints = "$src1 = $dst", SchedRW = [WriteALU] in {
 488 let isConvertibleToThreeAddress = 1, CodeSize = 2 in { // Can xform into LEA.
 489 def DEC8r  : I<0xFE, MRM1r, (outs GR8 :$dst), (ins GR8 :$src1),
 490                "dec{b}\t$dst",
 491                [(set GR8:$dst, EFLAGS, (X86sub_flag_nocf GR8:$src1, 1))]>;
 492 def DEC16r : I<0xFF, MRM1r, (outs GR16:$dst), (ins GR16:$src1),
 493                "dec{w}\t$dst",
 494                [(set GR16:$dst, EFLAGS, (X86sub_flag_nocf GR16:$src1, 1))]>,
 495                OpSize16;
 496 def DEC32r : I<0xFF, MRM1r, (outs GR32:$dst), (ins GR32:$src1),
 497                "dec{l}\t$dst",
 498                [(set GR32:$dst, EFLAGS, (X86sub_flag_nocf GR32:$src1, 1))]>,
 499                OpSize32;
 500 def DEC64r : RI<0xFF, MRM1r, (outs GR64:$dst), (ins GR64:$src1), "dec{q}\t$dst",
 501                 [(set GR64:$dst, EFLAGS, (X86sub_flag_nocf GR64:$src1, 1))]>;
 502 } // isConvertibleToThreeAddress = 1, CodeSize = 2
 503
 504 // Short forms only valid in 32-bit mode. Selected during MCInst lowering.
 505 let CodeSize = 1, hasSideEffects = 0 in {
 506 def DEC16r_alt : I<0x48, AddRegFrm, (outs GR16:$dst), (ins GR16:$src1),
 507                    "dec{w}\t$dst", []>,
 508                  OpSize16, Requires<[Not64BitMode]>;
 509 def DEC32r_alt : I<0x48, AddRegFrm, (outs GR32:$dst), (ins GR32:$src1),
 510                    "dec{l}\t$dst", []>,
 511                  OpSize32, Requires<[Not64BitMode]>;
 512 } // CodeSize = 1, hasSideEffects = 0
 513 } // Constraints = "$src1 = $dst", SchedRW
 514
 515
 516 let CodeSize = 2, SchedRW = [WriteALURMW] in {
 517 let Predicates = [UseIncDec] in {
 518   def DEC8m  : I<0xFE, MRM1m, (outs), (ins i8mem :$dst), "dec{b}\t$dst",
 519                [(store (add (loadi8 addr:$dst), -1), addr:$dst),
 520                 (implicit EFLAGS)]>;
 521   def DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst), "dec{w}\t$dst",
 522                [(store (add (loadi16 addr:$dst), -1), addr:$dst),
 523                 (implicit EFLAGS)]>, OpSize16;
 524   def DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst), "dec{l}\t$dst",
 525                [(store (add (loadi32 addr:$dst), -1), addr:$dst),
 526                 (implicit EFLAGS)]>, OpSize32;
 527 } // Predicates
 528 let Predicates = [UseIncDec, In64BitMode] in {
 529   def DEC64m : RI<0xFF, MRM1m, (outs), (ins i64mem:$dst), "dec{q}\t$dst",
 530                   [(store (add (loadi64 addr:$dst), -1), addr:$dst),
 531                    (implicit EFLAGS)]>;
 532 } // Predicates
 533 } // CodeSize = 2, SchedRW
 534 } // Defs = [EFLAGS]
 535
 536 /// X86TypeInfo - This is a bunch of information that describes relevant X86
 537 /// information about value types.  For example, it can tell you what the
 538 /// register class and preferred load to use.
 539 class X86TypeInfo<ValueType vt, string instrsuffix, RegisterClass regclass,
 540                   PatFrag loadnode, X86MemOperand memoperand, ImmType immkind,
 541                   Operand immoperand, SDPatternOperator immoperator,
 542                   Operand imm8operand, SDPatternOperator imm8operator,
 543                   bit hasOddOpcode, OperandSize opSize,
 544                   bit hasREX_WPrefix> {
 545   /// VT - This is the value type itself.
 546   ValueType VT = vt;
 547
 548   /// InstrSuffix - This is the suffix used on instructions with this type.  For
 549   /// example, i8 -> "b", i16 -> "w", i32 -> "l", i64 -> "q".
 550   string InstrSuffix = instrsuffix;
 551
 552   /// RegClass - This is the register class associated with this type.  For
 553   /// example, i8 -> GR8, i16 -> GR16, i32 -> GR32, i64 -> GR64.
 554   RegisterClass RegClass = regclass;
 555
 556   /// LoadNode - This is the load node associated with this type.  For
 557   /// example, i8 -> loadi8, i16 -> loadi16, i32 -> loadi32, i64 -> loadi64.
 558   PatFrag LoadNode = loadnode;
 559
 560   /// MemOperand - This is the memory operand associated with this type.  For
 561   /// example, i8 -> i8mem, i16 -> i16mem, i32 -> i32mem, i64 -> i64mem.
 562   X86MemOperand MemOperand = memoperand;
 563
 564   /// ImmEncoding - This is the encoding of an immediate of this type.  For
 565   /// example, i8 -> Imm8, i16 -> Imm16, i32 -> Imm32.  Note that i64 -> Imm32
 566   /// since the immediate fields of i64 instructions is a 32-bit sign extended
 567   /// value.
 568   ImmType ImmEncoding = immkind;
 569
 570   /// ImmOperand - This is the operand kind of an immediate of this type.  For
 571   /// example, i8 -> i8imm, i16 -> i16imm, i32 -> i32imm.  Note that i64 ->
 572   /// i64i32imm since the immediate fields of i64 instructions is a 32-bit sign
 573   /// extended value.
 574   Operand ImmOperand = immoperand;
 575
 576   /// ImmOperator - This is the operator that should be used to match an
 577   /// immediate of this kind in a pattern (e.g. imm, or i64immSExt32).
 578   SDPatternOperator ImmOperator = immoperator;
 579
 580   /// Imm8Operand - This is the operand kind to use for an imm8 of this type.
 581   /// For example, i8 -> <invalid>, i16 -> i16i8imm, i32 -> i32i8imm.  This is
 582   /// only used for instructions that have a sign-extended imm8 field form.
 583   Operand Imm8Operand = imm8operand;
 584
 585   /// Imm8Operator - This is the operator that should be used to match an 8-bit
 586   /// sign extended immediate of this kind in a pattern (e.g. imm16immSExt8).
 587   SDPatternOperator Imm8Operator = imm8operator;
 588
 589   /// HasOddOpcode - This bit is true if the instruction should have an odd (as
 590   /// opposed to even) opcode.  Operations on i8 are usually even, operations on
 591   /// other datatypes are odd.
 592   bit HasOddOpcode = hasOddOpcode;
 593
 594   /// OpSize - Selects whether the instruction needs a 0x66 prefix based on
 595   /// 16-bit vs 32-bit mode. i8/i64 set this to OpSizeFixed. i16 sets this
 596   /// to Opsize16. i32 sets this to OpSize32.
 597   OperandSize OpSize = opSize;
 598
 599   /// HasREX_WPrefix - This bit is set to true if the instruction should have
 600   /// the 0x40 REX prefix.  This is set for i64 types.
 601   bit HasREX_WPrefix = hasREX_WPrefix;
 602 }
 603
 604 def invalid_node : SDNode<"<<invalid_node>>", SDTIntLeaf,[],"<<invalid_node>>">;
 605
 606
 607 def Xi8  : X86TypeInfo<i8, "b", GR8, loadi8, i8mem,
 608                        Imm8, i8imm, relocImm8_su, i8imm, invalid_node,
 609                        0, OpSizeFixed, 0>;
 610 def Xi16 : X86TypeInfo<i16, "w", GR16, loadi16, i16mem,
 611                        Imm16, i16imm, relocImm16_su, i16i8imm, i16immSExt8_su,
 612                        1, OpSize16, 0>;
 613 def Xi32 : X86TypeInfo<i32, "l", GR32, loadi32, i32mem,
 614                        Imm32, i32imm, relocImm32_su, i32i8imm, i32immSExt8_su,
 615                        1, OpSize32, 0>;
 616 def Xi64 : X86TypeInfo<i64, "q", GR64, loadi64, i64mem,
 617                        Imm32S, i64i32imm, i64relocImmSExt32_su, i64i8imm, i64immSExt8_su,
 618                        1, OpSizeFixed, 1>;
 619
 620 /// ITy - This instruction base class takes the type info for the instruction.
 621 /// Using this, it:
 622 /// 1. Concatenates together the instruction mnemonic with the appropriate
 623 ///    suffix letter, a tab, and the arguments.
 624 /// 2. Infers whether the instruction should have a 0x66 prefix byte.
 625 /// 3. Infers whether the instruction should have a 0x40 REX_W prefix.
 626 /// 4. Infers whether the low bit of the opcode should be 0 (for i8 operations)
 627 ///    or 1 (for i16,i32,i64 operations).
 628 class ITy<bits<8> opcode, Format f, X86TypeInfo typeinfo, dag outs, dag ins,
 629           string mnemonic, string args, list<dag> pattern>
 630   : I<{opcode{7}, opcode{6}, opcode{5}, opcode{4},
 631        opcode{3}, opcode{2}, opcode{1}, typeinfo.HasOddOpcode },
 632       f, outs, ins,
 633       !strconcat(mnemonic, "{", typeinfo.InstrSuffix, "}\t", args), pattern> {
 634
 635   // Infer instruction prefixes from type info.
 636   let OpSize = typeinfo.OpSize;
 637   let hasREX_WPrefix  = typeinfo.HasREX_WPrefix;
 638 }
 639
 640 // BinOpRR - Instructions like "add reg, reg, reg".
 641 class BinOpRR<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 642               dag outlist, X86FoldableSchedWrite sched, list<dag> pattern>
 643   : ITy<opcode, MRMDestReg, typeinfo, outlist,
 644         (ins typeinfo.RegClass:$src1, typeinfo.RegClass:$src2),
 645         mnemonic, "{$src2, $src1|$src1, $src2}", pattern>,
 646     Sched<[sched]>;
 647
 648 // BinOpRR_F - Instructions like "cmp reg, Reg", where the pattern has
 649 // just a EFLAGS as a result.
 650 class BinOpRR_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 651                 SDPatternOperator opnode>
 652   : BinOpRR<opcode, mnemonic, typeinfo, (outs), WriteALU,
 653             [(set EFLAGS,
 654                   (opnode typeinfo.RegClass:$src1, typeinfo.RegClass:$src2))]>;
 655
 656 // BinOpRR_RF - Instructions like "add reg, reg, reg", where the pattern has
 657 // both a regclass and EFLAGS as a result.
 658 class BinOpRR_RF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 659                  SDNode opnode>
 660   : BinOpRR<opcode, mnemonic, typeinfo, (outs typeinfo.RegClass:$dst), WriteALU,
 661             [(set typeinfo.RegClass:$dst, EFLAGS,
 662                   (opnode typeinfo.RegClass:$src1, typeinfo.RegClass:$src2))]>;
 663
 664 // BinOpRR_RFF - Instructions like "adc reg, reg, reg", where the pattern has
 665 // both a regclass and EFLAGS as a result, and has EFLAGS as input.
 666 class BinOpRR_RFF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 667                   SDNode opnode>
 668   : BinOpRR<opcode, mnemonic, typeinfo, (outs typeinfo.RegClass:$dst), WriteADC,
 669             [(set typeinfo.RegClass:$dst, EFLAGS,
 670                   (opnode typeinfo.RegClass:$src1, typeinfo.RegClass:$src2,
 671                           EFLAGS))]>;
 672
 673 // BinOpRR_Rev - Instructions like "add reg, reg, reg" (reversed encoding).
 674 class BinOpRR_Rev<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 675                   X86FoldableSchedWrite sched = WriteALU>
 676   : ITy<opcode, MRMSrcReg, typeinfo,
 677         (outs typeinfo.RegClass:$dst),
 678         (ins typeinfo.RegClass:$src1, typeinfo.RegClass:$src2),
 679         mnemonic, "{$src2, $dst|$dst, $src2}", []>,
 680     Sched<[sched]> {
 681   // The disassembler should know about this, but not the asmparser.
 682   let isCodeGenOnly = 1;
 683   let ForceDisassemble = 1;
 684   let hasSideEffects = 0;
 685 }
 686
 687 // BinOpRR_RDD_Rev - Instructions like "adc reg, reg, reg" (reversed encoding).
 688 class BinOpRR_RFF_Rev<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo>
 689   : BinOpRR_Rev<opcode, mnemonic, typeinfo, WriteADC>;
 690
 691 // BinOpRR_F_Rev - Instructions like "cmp reg, reg" (reversed encoding).
 692 class BinOpRR_F_Rev<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo>
 693   : ITy<opcode, MRMSrcReg, typeinfo, (outs),
 694         (ins typeinfo.RegClass:$src1, typeinfo.RegClass:$src2),
 695         mnemonic, "{$src2, $src1|$src1, $src2}", []>,
 696     Sched<[WriteALU]> {
 697   // The disassembler should know about this, but not the asmparser.
 698   let isCodeGenOnly = 1;
 699   let ForceDisassemble = 1;
 700   let hasSideEffects = 0;
 701 }
 702
 703 // BinOpRM - Instructions like "add reg, reg, [mem]".
 704 class BinOpRM<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 705               dag outlist, X86FoldableSchedWrite sched, list<dag> pattern>
 706   : ITy<opcode, MRMSrcMem, typeinfo, outlist,
 707         (ins typeinfo.RegClass:$src1, typeinfo.MemOperand:$src2),
 708         mnemonic, "{$src2, $src1|$src1, $src2}", pattern>,
 709     Sched<[sched.Folded, sched.ReadAfterFold]>;
 710
 711 // BinOpRM_F - Instructions like "cmp reg, [mem]".
 712 class BinOpRM_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 713                 SDNode opnode>
 714   : BinOpRM<opcode, mnemonic, typeinfo, (outs), WriteALU,
 715             [(set EFLAGS,
 716             (opnode typeinfo.RegClass:$src1, (typeinfo.LoadNode addr:$src2)))]>;
 717
 718 // BinOpRM_RF - Instructions like "add reg, reg, [mem]".
 719 class BinOpRM_RF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 720                  SDNode opnode>
 721   : BinOpRM<opcode, mnemonic, typeinfo, (outs typeinfo.RegClass:$dst), WriteALU,
 722             [(set typeinfo.RegClass:$dst, EFLAGS,
 723             (opnode typeinfo.RegClass:$src1, (typeinfo.LoadNode addr:$src2)))]>;
 724
 725 // BinOpRM_RFF - Instructions like "adc reg, reg, [mem]".
 726 class BinOpRM_RFF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 727                  SDNode opnode>
 728   : BinOpRM<opcode, mnemonic, typeinfo, (outs typeinfo.RegClass:$dst), WriteADC,
 729             [(set typeinfo.RegClass:$dst, EFLAGS,
 730             (opnode typeinfo.RegClass:$src1, (typeinfo.LoadNode addr:$src2),
 731                     EFLAGS))]>;
 732
 733 // BinOpRI - Instructions like "add reg, reg, imm".
 734 class BinOpRI<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 735               Format f, dag outlist, X86FoldableSchedWrite sched, list<dag> pattern>
 736   : ITy<opcode, f, typeinfo, outlist,
 737         (ins typeinfo.RegClass:$src1, typeinfo.ImmOperand:$src2),
 738         mnemonic, "{$src2, $src1|$src1, $src2}", pattern>,
 739     Sched<[sched]> {
 740   let ImmT = typeinfo.ImmEncoding;
 741 }
 742
 743 // BinOpRI_F - Instructions like "cmp reg, imm".
 744 class BinOpRI_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 745                 SDPatternOperator opnode, Format f>
 746   : BinOpRI<opcode, mnemonic, typeinfo, f, (outs), WriteALU,
 747             [(set EFLAGS,
 748                 (opnode typeinfo.RegClass:$src1, typeinfo.ImmOperator:$src2))]>;
 749
 750 // BinOpRI_RF - Instructions like "add reg, reg, imm".
 751 class BinOpRI_RF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 752                  SDNode opnode, Format f>
 753   : BinOpRI<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteALU,
 754             [(set typeinfo.RegClass:$dst, EFLAGS,
 755                 (opnode typeinfo.RegClass:$src1, typeinfo.ImmOperator:$src2))]>;
 756 // BinOpRI_RFF - Instructions like "adc reg, reg, imm".
 757 class BinOpRI_RFF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 758                  SDNode opnode, Format f>
 759   : BinOpRI<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteADC,
 760             [(set typeinfo.RegClass:$dst, EFLAGS,
 761                 (opnode typeinfo.RegClass:$src1, typeinfo.ImmOperator:$src2,
 762                         EFLAGS))]>;
 763
 764 // BinOpRI8 - Instructions like "add reg, reg, imm8".
 765 class BinOpRI8<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 766                Format f, dag outlist, X86FoldableSchedWrite sched, list<dag> pattern>
 767   : ITy<opcode, f, typeinfo, outlist,
 768         (ins typeinfo.RegClass:$src1, typeinfo.Imm8Operand:$src2),
 769         mnemonic, "{$src2, $src1|$src1, $src2}", pattern>,
 770     Sched<[sched]> {
 771   let ImmT = Imm8; // Always 8-bit immediate.
 772 }
 773
 774 // BinOpRI8_F - Instructions like "cmp reg, imm8".
 775 class BinOpRI8_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 776                   SDPatternOperator opnode, Format f>
 777   : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs), WriteALU,
 778              [(set EFLAGS,
 779                (opnode typeinfo.RegClass:$src1, typeinfo.Imm8Operator:$src2))]>;
 780
 781 // BinOpRI8_RF - Instructions like "add reg, reg, imm8".
 782 class BinOpRI8_RF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 783                   SDPatternOperator opnode, Format f>
 784   : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteALU,
 785              [(set typeinfo.RegClass:$dst, EFLAGS,
 786                (opnode typeinfo.RegClass:$src1, typeinfo.Imm8Operator:$src2))]>;
 787
 788 // BinOpRI8_RFF - Instructions like "adc reg, reg, imm8".
 789 class BinOpRI8_RFF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 790                    SDPatternOperator opnode, Format f>
 791   : BinOpRI8<opcode, mnemonic, typeinfo, f, (outs typeinfo.RegClass:$dst), WriteADC,
 792              [(set typeinfo.RegClass:$dst, EFLAGS,
 793                (opnode typeinfo.RegClass:$src1, typeinfo.Imm8Operator:$src2,
 794                        EFLAGS))]>;
 795
 796 // BinOpMR - Instructions like "add [mem], reg".
 797 class BinOpMR<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 798               list<dag> pattern>
 799   : ITy<opcode, MRMDestMem, typeinfo,
 800         (outs), (ins typeinfo.MemOperand:$dst, typeinfo.RegClass:$src),
 801         mnemonic, "{$src, $dst|$dst, $src}", pattern>;
 802
 803 // BinOpMR_RMW - Instructions like "add [mem], reg".
 804 class BinOpMR_RMW<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 805                   SDNode opnode>
 806   : BinOpMR<opcode, mnemonic, typeinfo,
 807           [(store (opnode (load addr:$dst), typeinfo.RegClass:$src), addr:$dst),
 808            (implicit EFLAGS)]>, Sched<[WriteALURMW]>;
 809
 810 // BinOpMR_RMW_FF - Instructions like "adc [mem], reg".
 811 class BinOpMR_RMW_FF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 812                     SDNode opnode>
 813   : BinOpMR<opcode, mnemonic, typeinfo,
 814             [(store (opnode (load addr:$dst), typeinfo.RegClass:$src, EFLAGS),
 815                     addr:$dst),
 816              (implicit EFLAGS)]>, Sched<[WriteADCRMW]>;
 817
 818 // BinOpMR_F - Instructions like "cmp [mem], reg".
 819 class BinOpMR_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 820                 SDPatternOperator opnode>
 821   : BinOpMR<opcode, mnemonic, typeinfo,
 822             [(set EFLAGS, (opnode (typeinfo.LoadNode addr:$dst),
 823                                    typeinfo.RegClass:$src))]>,
 824             Sched<[WriteALU.Folded, ReadDefault, ReadDefault, ReadDefault,
 825                    ReadDefault, ReadDefault, WriteALU.ReadAfterFold]>;
 826
 827 // BinOpMI - Instructions like "add [mem], imm".
 828 class BinOpMI<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 829               Format f, list<dag> pattern>
 830   : ITy<opcode, f, typeinfo,
 831         (outs), (ins typeinfo.MemOperand:$dst, typeinfo.ImmOperand:$src),
 832         mnemonic, "{$src, $dst|$dst, $src}", pattern> {
 833   let ImmT = typeinfo.ImmEncoding;
 834 }
 835
 836 // BinOpMI_RMW - Instructions like "add [mem], imm".
 837 class BinOpMI_RMW<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 838                   SDNode opnode, Format f>
 839   : BinOpMI<opcode, mnemonic, typeinfo, f,
 840             [(store (opnode (typeinfo.VT (load addr:$dst)),
 841                             typeinfo.ImmOperator:$src), addr:$dst),
 842              (implicit EFLAGS)]>, Sched<[WriteALURMW]>;
 843 // BinOpMI_RMW_FF - Instructions like "adc [mem], imm".
 844 class BinOpMI_RMW_FF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 845                      SDNode opnode, Format f>
 846   : BinOpMI<opcode, mnemonic, typeinfo, f,
 847             [(store (opnode (typeinfo.VT (load addr:$dst)),
 848                              typeinfo.ImmOperator:$src, EFLAGS), addr:$dst),
 849              (implicit EFLAGS)]>, Sched<[WriteADCRMW]>;
 850
 851 // BinOpMI_F - Instructions like "cmp [mem], imm".
 852 class BinOpMI_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 853                 SDPatternOperator opnode, Format f>
 854   : BinOpMI<opcode, mnemonic, typeinfo, f,
 855             [(set EFLAGS, (opnode (typeinfo.LoadNode addr:$dst),
 856                                   typeinfo.ImmOperator:$src))]>,
 857             Sched<[WriteALU.Folded]>;
 858
 859 // BinOpMI8 - Instructions like "add [mem], imm8".
 860 class BinOpMI8<string mnemonic, X86TypeInfo typeinfo,
 861                Format f, list<dag> pattern>
 862   : ITy<0x82, f, typeinfo,
 863         (outs), (ins typeinfo.MemOperand:$dst, typeinfo.Imm8Operand:$src),
 864         mnemonic, "{$src, $dst|$dst, $src}", pattern> {
 865   let ImmT = Imm8; // Always 8-bit immediate.
 866 }
 867
 868 // BinOpMI8_RMW - Instructions like "add [mem], imm8".
 869 class BinOpMI8_RMW<string mnemonic, X86TypeInfo typeinfo,
 870                    SDPatternOperator opnode, Format f>
 871   : BinOpMI8<mnemonic, typeinfo, f,
 872              [(store (opnode (load addr:$dst),
 873                              typeinfo.Imm8Operator:$src), addr:$dst),
 874               (implicit EFLAGS)]>, Sched<[WriteALURMW]>;
 875
 876 // BinOpMI8_RMW_FF - Instructions like "adc [mem], imm8".
 877 class BinOpMI8_RMW_FF<string mnemonic, X86TypeInfo typeinfo,
 878                       SDPatternOperator opnode, Format f>
 879   : BinOpMI8<mnemonic, typeinfo, f,
 880              [(store (opnode (load addr:$dst),
 881                              typeinfo.Imm8Operator:$src, EFLAGS), addr:$dst),
 882               (implicit EFLAGS)]>, Sched<[WriteADCRMW]>;
 883
 884 // BinOpMI8_F - Instructions like "cmp [mem], imm8".
 885 class BinOpMI8_F<string mnemonic, X86TypeInfo typeinfo,
 886                  SDPatternOperator opnode, Format f>
 887   : BinOpMI8<mnemonic, typeinfo, f,
 888              [(set EFLAGS, (opnode (typeinfo.LoadNode addr:$dst),
 889                                     typeinfo.Imm8Operator:$src))]>,
 890              Sched<[WriteALU.Folded]>;
 891
 892 // BinOpAI - Instructions like "add %eax, %eax, imm", that imp-def EFLAGS.
 893 class BinOpAI<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 894               Register areg, string operands, X86FoldableSchedWrite sched = WriteALU>
 895   : ITy<opcode, RawFrm, typeinfo,
 896         (outs), (ins typeinfo.ImmOperand:$src),
 897         mnemonic, operands, []>, Sched<[sched]> {
 898   let ImmT = typeinfo.ImmEncoding;
 899   let Uses = [areg];
 900   let Defs = [areg, EFLAGS];
 901   let hasSideEffects = 0;
 902 }
 903
 904 // BinOpAI_RFF - Instructions like "adc %eax, %eax, imm", that implicitly define
 905 // and use EFLAGS.
 906 class BinOpAI_RFF<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 907                   Register areg, string operands>
 908   : BinOpAI<opcode, mnemonic, typeinfo, areg, operands, WriteADC> {
 909   let Uses = [areg, EFLAGS];
 910 }
 911
 912 // BinOpAI_F - Instructions like "cmp %eax, %eax, imm", that imp-def EFLAGS.
 913 class BinOpAI_F<bits<8> opcode, string mnemonic, X86TypeInfo typeinfo,
 914                 Register areg, string operands>
 915   : BinOpAI<opcode, mnemonic, typeinfo, areg, operands> {
 916   let Defs = [EFLAGS];
 917 }
 918
 919 /// ArithBinOp_RF - This is an arithmetic binary operator where the pattern is
 920 /// defined with "(set GPR:$dst, EFLAGS, (...".
 921 ///
 922 /// It would be nice to get rid of the second and third argument here, but
 923 /// tblgen can't handle dependent type references aggressively enough: PR8330
 924 multiclass ArithBinOp_RF<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
 925                          string mnemonic, Format RegMRM, Format MemMRM,
 926                          SDNode opnodeflag, SDNode opnode,
 927                          bit CommutableRR, bit ConvertibleToThreeAddress,
 928                          bit ConvertibleToThreeAddressRR> {
 929   let Defs = [EFLAGS] in {
 930     let Constraints = "$src1 = $dst" in {
 931       let isCommutable = CommutableRR in {
 932         let isConvertibleToThreeAddress = ConvertibleToThreeAddressRR in {
 933           def NAME#8rr  : BinOpRR_RF<BaseOpc, mnemonic, Xi8 , opnodeflag>;
 934           def NAME#16rr : BinOpRR_RF<BaseOpc, mnemonic, Xi16, opnodeflag>;
 935           def NAME#32rr : BinOpRR_RF<BaseOpc, mnemonic, Xi32, opnodeflag>;
 936           def NAME#64rr : BinOpRR_RF<BaseOpc, mnemonic, Xi64, opnodeflag>;
 937         } // isConvertibleToThreeAddress
 938       } // isCommutable
 939
 940       def NAME#8rr_REV  : BinOpRR_Rev<BaseOpc2, mnemonic, Xi8>, FoldGenData<NAME#8rr>;
 941       def NAME#16rr_REV : BinOpRR_Rev<BaseOpc2, mnemonic, Xi16>, FoldGenData<NAME#16rr>;
 942       def NAME#32rr_REV : BinOpRR_Rev<BaseOpc2, mnemonic, Xi32>, FoldGenData<NAME#32rr>;
 943       def NAME#64rr_REV : BinOpRR_Rev<BaseOpc2, mnemonic, Xi64>, FoldGenData<NAME#64rr>;
 944
 945       def NAME#8rm   : BinOpRM_RF<BaseOpc2, mnemonic, Xi8 , opnodeflag>;
 946       def NAME#16rm  : BinOpRM_RF<BaseOpc2, mnemonic, Xi16, opnodeflag>;
 947       def NAME#32rm  : BinOpRM_RF<BaseOpc2, mnemonic, Xi32, opnodeflag>;
 948       def NAME#64rm  : BinOpRM_RF<BaseOpc2, mnemonic, Xi64, opnodeflag>;
 949
 950       let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
 951         def NAME#8ri   : BinOpRI_RF<0x80, mnemonic, Xi8 , opnodeflag, RegMRM>;
 952
 953         // NOTE: These are order specific, we want the ri8 forms to be listed
 954         // first so that they are slightly preferred to the ri forms.
 955         def NAME#16ri8 : BinOpRI8_RF<0x82, mnemonic, Xi16, opnodeflag, RegMRM>;
 956         def NAME#32ri8 : BinOpRI8_RF<0x82, mnemonic, Xi32, opnodeflag, RegMRM>;
 957         def NAME#64ri8 : BinOpRI8_RF<0x82, mnemonic, Xi64, opnodeflag, RegMRM>;
 958
 959         def NAME#16ri  : BinOpRI_RF<0x80, mnemonic, Xi16, opnodeflag, RegMRM>;
 960         def NAME#32ri  : BinOpRI_RF<0x80, mnemonic, Xi32, opnodeflag, RegMRM>;
 961         def NAME#64ri32: BinOpRI_RF<0x80, mnemonic, Xi64, opnodeflag, RegMRM>;
 962       }
 963     } // Constraints = "$src1 = $dst"
 964
 965     let mayLoad = 1, mayStore = 1 in {
 966       def NAME#8mr    : BinOpMR_RMW<BaseOpc, mnemonic, Xi8 , opnode>;
 967       def NAME#16mr   : BinOpMR_RMW<BaseOpc, mnemonic, Xi16, opnode>;
 968       def NAME#32mr   : BinOpMR_RMW<BaseOpc, mnemonic, Xi32, opnode>;
 969       def NAME#64mr   : BinOpMR_RMW<BaseOpc, mnemonic, Xi64, opnode>;
 970     }
 971
 972     // NOTE: These are order specific, we want the mi8 forms to be listed
 973     // first so that they are slightly preferred to the mi forms.
 974     def NAME#16mi8  : BinOpMI8_RMW<mnemonic, Xi16, opnode, MemMRM>;
 975     def NAME#32mi8  : BinOpMI8_RMW<mnemonic, Xi32, opnode, MemMRM>;
 976     let Predicates = [In64BitMode] in
 977     def NAME#64mi8  : BinOpMI8_RMW<mnemonic, Xi64, opnode, MemMRM>;
 978
 979     def NAME#8mi    : BinOpMI_RMW<0x80, mnemonic, Xi8 , opnode, MemMRM>;
 980     def NAME#16mi   : BinOpMI_RMW<0x80, mnemonic, Xi16, opnode, MemMRM>;
 981     def NAME#32mi   : BinOpMI_RMW<0x80, mnemonic, Xi32, opnode, MemMRM>;
 982     let Predicates = [In64BitMode] in
 983     def NAME#64mi32 : BinOpMI_RMW<0x80, mnemonic, Xi64, opnode, MemMRM>;
 984
 985     // These are for the disassembler since 0x82 opcode behaves like 0x80, but
 986     // not in 64-bit mode.
 987     let Predicates = [Not64BitMode], isCodeGenOnly = 1, ForceDisassemble = 1,
 988         hasSideEffects = 0 in {
 989       let Constraints = "$src1 = $dst" in
 990         def NAME#8ri8 : BinOpRI8_RF<0x82, mnemonic, Xi8, null_frag, RegMRM>;
 991       let mayLoad = 1, mayStore = 1 in
 992         def NAME#8mi8 : BinOpMI8_RMW<mnemonic, Xi8, null_frag, MemMRM>;
 993     }
 994   } // Defs = [EFLAGS]
 995
 996   def NAME#8i8   : BinOpAI<BaseOpc4, mnemonic, Xi8 , AL,
 997                            "{$src, %al|al, $src}">;
 998   def NAME#16i16 : BinOpAI<BaseOpc4, mnemonic, Xi16, AX,
 999                            "{$src, %ax|ax, $src}">;
1000   def NAME#32i32 : BinOpAI<BaseOpc4, mnemonic, Xi32, EAX,
1001                            "{$src, %eax|eax, $src}">;
1002   def NAME#64i32 : BinOpAI<BaseOpc4, mnemonic, Xi64, RAX,
1003                            "{$src, %rax|rax, $src}">;
1004 }
1005
1006 /// ArithBinOp_RFF - This is an arithmetic binary operator where the pattern is
1007 /// defined with "(set GPR:$dst, EFLAGS, (node LHS, RHS, EFLAGS))" like ADC and
1008 /// SBB.
1009 ///
1010 /// It would be nice to get rid of the second and third argument here, but
1011 /// tblgen can't handle dependent type references aggressively enough: PR8330
1012 multiclass ArithBinOp_RFF<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
1013                           string mnemonic, Format RegMRM, Format MemMRM,
1014                           SDNode opnode, bit CommutableRR,
1015                            bit ConvertibleToThreeAddress> {
1016   let Uses = [EFLAGS], Defs = [EFLAGS] in {
1017     let Constraints = "$src1 = $dst" in {
1018       let isCommutable = CommutableRR in {
1019         def NAME#8rr  : BinOpRR_RFF<BaseOpc, mnemonic, Xi8 , opnode>;
1020         let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
1021           def NAME#16rr : BinOpRR_RFF<BaseOpc, mnemonic, Xi16, opnode>;
1022           def NAME#32rr : BinOpRR_RFF<BaseOpc, mnemonic, Xi32, opnode>;
1023           def NAME#64rr : BinOpRR_RFF<BaseOpc, mnemonic, Xi64, opnode>;
1024         } // isConvertibleToThreeAddress
1025       } // isCommutable
1026
1027       def NAME#8rr_REV  : BinOpRR_RFF_Rev<BaseOpc2, mnemonic, Xi8>, FoldGenData<NAME#8rr>;
1028       def NAME#16rr_REV : BinOpRR_RFF_Rev<BaseOpc2, mnemonic, Xi16>, FoldGenData<NAME#16rr>;
1029       def NAME#32rr_REV : BinOpRR_RFF_Rev<BaseOpc2, mnemonic, Xi32>, FoldGenData<NAME#32rr>;
1030       def NAME#64rr_REV : BinOpRR_RFF_Rev<BaseOpc2, mnemonic, Xi64>, FoldGenData<NAME#64rr>;
1031
1032       def NAME#8rm   : BinOpRM_RFF<BaseOpc2, mnemonic, Xi8 , opnode>;
1033       def NAME#16rm  : BinOpRM_RFF<BaseOpc2, mnemonic, Xi16, opnode>;
1034       def NAME#32rm  : BinOpRM_RFF<BaseOpc2, mnemonic, Xi32, opnode>;
1035       def NAME#64rm  : BinOpRM_RFF<BaseOpc2, mnemonic, Xi64, opnode>;
1036
1037       def NAME#8ri   : BinOpRI_RFF<0x80, mnemonic, Xi8 , opnode, RegMRM>;
1038
1039       let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
1040         // NOTE: These are order specific, we want the ri8 forms to be listed
1041         // first so that they are slightly preferred to the ri forms.
1042         def NAME#16ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi16, opnode, RegMRM>;
1043         def NAME#32ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi32, opnode, RegMRM>;
1044         def NAME#64ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi64, opnode, RegMRM>;
1045
1046         def NAME#16ri  : BinOpRI_RFF<0x80, mnemonic, Xi16, opnode, RegMRM>;
1047         def NAME#32ri  : BinOpRI_RFF<0x80, mnemonic, Xi32, opnode, RegMRM>;
1048         def NAME#64ri32: BinOpRI_RFF<0x80, mnemonic, Xi64, opnode, RegMRM>;
1049       }
1050     } // Constraints = "$src1 = $dst"
1051
1052     def NAME#8mr    : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi8 , opnode>;
1053     def NAME#16mr   : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi16, opnode>;
1054     def NAME#32mr   : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi32, opnode>;
1055     def NAME#64mr   : BinOpMR_RMW_FF<BaseOpc, mnemonic, Xi64, opnode>;
1056
1057     // NOTE: These are order specific, we want the mi8 forms to be listed
1058     // first so that they are slightly preferred to the mi forms.
1059     def NAME#16mi8  : BinOpMI8_RMW_FF<mnemonic, Xi16, opnode, MemMRM>;
1060     def NAME#32mi8  : BinOpMI8_RMW_FF<mnemonic, Xi32, opnode, MemMRM>;
1061     let Predicates = [In64BitMode] in
1062     def NAME#64mi8  : BinOpMI8_RMW_FF<mnemonic, Xi64, opnode, MemMRM>;
1063
1064     def NAME#8mi    : BinOpMI_RMW_FF<0x80, mnemonic, Xi8 , opnode, MemMRM>;
1065     def NAME#16mi   : BinOpMI_RMW_FF<0x80, mnemonic, Xi16, opnode, MemMRM>;
1066     def NAME#32mi   : BinOpMI_RMW_FF<0x80, mnemonic, Xi32, opnode, MemMRM>;
1067     let Predicates = [In64BitMode] in
1068     def NAME#64mi32 : BinOpMI_RMW_FF<0x80, mnemonic, Xi64, opnode, MemMRM>;
1069
1070     // These are for the disassembler since 0x82 opcode behaves like 0x80, but
1071     // not in 64-bit mode.
1072     let Predicates = [Not64BitMode], isCodeGenOnly = 1, ForceDisassemble = 1,
1073         hasSideEffects = 0 in {
1074       let Constraints = "$src1 = $dst" in
1075         def NAME#8ri8 : BinOpRI8_RFF<0x82, mnemonic, Xi8, null_frag, RegMRM>;
1076       let mayLoad = 1, mayStore = 1 in
1077         def NAME#8mi8 : BinOpMI8_RMW_FF<mnemonic, Xi8, null_frag, MemMRM>;
1078     }
1079   } // Uses = [EFLAGS], Defs = [EFLAGS]
1080
1081   def NAME#8i8   : BinOpAI_RFF<BaseOpc4, mnemonic, Xi8 , AL,
1082                                "{$src, %al|al, $src}">;
1083   def NAME#16i16 : BinOpAI_RFF<BaseOpc4, mnemonic, Xi16, AX,
1084                                "{$src, %ax|ax, $src}">;
1085   def NAME#32i32 : BinOpAI_RFF<BaseOpc4, mnemonic, Xi32, EAX,
1086                                "{$src, %eax|eax, $src}">;
1087   def NAME#64i32 : BinOpAI_RFF<BaseOpc4, mnemonic, Xi64, RAX,
1088                                "{$src, %rax|rax, $src}">;
1089 }
1090
1091 /// ArithBinOp_F - This is an arithmetic binary operator where the pattern is
1092 /// defined with "(set EFLAGS, (...".  It would be really nice to find a way
1093 /// to factor this with the other ArithBinOp_*.
1094 ///
1095 multiclass ArithBinOp_F<bits<8> BaseOpc, bits<8> BaseOpc2, bits<8> BaseOpc4,
1096                         string mnemonic, Format RegMRM, Format MemMRM,
1097                         SDNode opnode,
1098                         bit CommutableRR, bit ConvertibleToThreeAddress> {
1099   let Defs = [EFLAGS] in {
1100     let isCommutable = CommutableRR in {
1101       def NAME#8rr  : BinOpRR_F<BaseOpc, mnemonic, Xi8 , opnode>;
1102       let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
1103         def NAME#16rr : BinOpRR_F<BaseOpc, mnemonic, Xi16, opnode>;
1104         def NAME#32rr : BinOpRR_F<BaseOpc, mnemonic, Xi32, opnode>;
1105         def NAME#64rr : BinOpRR_F<BaseOpc, mnemonic, Xi64, opnode>;
1106       }
1107     } // isCommutable
1108
1109     def NAME#8rr_REV  : BinOpRR_F_Rev<BaseOpc2, mnemonic, Xi8>, FoldGenData<NAME#8rr>;
1110     def NAME#16rr_REV : BinOpRR_F_Rev<BaseOpc2, mnemonic, Xi16>, FoldGenData<NAME#16rr>;
1111     def NAME#32rr_REV : BinOpRR_F_Rev<BaseOpc2, mnemonic, Xi32>, FoldGenData<NAME#32rr>;
1112     def NAME#64rr_REV : BinOpRR_F_Rev<BaseOpc2, mnemonic, Xi64>, FoldGenData<NAME#64rr>;
1113
1114     def NAME#8rm   : BinOpRM_F<BaseOpc2, mnemonic, Xi8 , opnode>;
1115     def NAME#16rm  : BinOpRM_F<BaseOpc2, mnemonic, Xi16, opnode>;
1116     def NAME#32rm  : BinOpRM_F<BaseOpc2, mnemonic, Xi32, opnode>;
1117     def NAME#64rm  : BinOpRM_F<BaseOpc2, mnemonic, Xi64, opnode>;
1118
1119     def NAME#8ri   : BinOpRI_F<0x80, mnemonic, Xi8 , opnode, RegMRM>;
1120
1121     let isConvertibleToThreeAddress = ConvertibleToThreeAddress in {
1122       // NOTE: These are order specific, we want the ri8 forms to be listed
1123       // first so that they are slightly preferred to the ri forms.
1124       def NAME#16ri8 : BinOpRI8_F<0x82, mnemonic, Xi16, opnode, RegMRM>;
1125       def NAME#32ri8 : BinOpRI8_F<0x82, mnemonic, Xi32, opnode, RegMRM>;
1126       def NAME#64ri8 : BinOpRI8_F<0x82, mnemonic, Xi64, opnode, RegMRM>;
1127
1128       def NAME#16ri  : BinOpRI_F<0x80, mnemonic, Xi16, opnode, RegMRM>;
1129       def NAME#32ri  : BinOpRI_F<0x80, mnemonic, Xi32, opnode, RegMRM>;
1130       def NAME#64ri32: BinOpRI_F<0x80, mnemonic, Xi64, opnode, RegMRM>;
1131     }
1132
1133     def NAME#8mr    : BinOpMR_F<BaseOpc, mnemonic, Xi8 , opnode>;
1134     def NAME#16mr   : BinOpMR_F<BaseOpc, mnemonic, Xi16, opnode>;
1135     def NAME#32mr   : BinOpMR_F<BaseOpc, mnemonic, Xi32, opnode>;
1136     def NAME#64mr   : BinOpMR_F<BaseOpc, mnemonic, Xi64, opnode>;
1137
1138     // NOTE: These are order specific, we want the mi8 forms to be listed
1139     // first so that they are slightly preferred to the mi forms.
1140     def NAME#16mi8  : BinOpMI8_F<mnemonic, Xi16, opnode, MemMRM>;
1141     def NAME#32mi8  : BinOpMI8_F<mnemonic, Xi32, opnode, MemMRM>;
1142     let Predicates = [In64BitMode] in
1143     def NAME#64mi8  : BinOpMI8_F<mnemonic, Xi64, opnode, MemMRM>;
1144
1145     def NAME#8mi    : BinOpMI_F<0x80, mnemonic, Xi8 , opnode, MemMRM>;
1146     def NAME#16mi   : BinOpMI_F<0x80, mnemonic, Xi16, opnode, MemMRM>;
1147     def NAME#32mi   : BinOpMI_F<0x80, mnemonic, Xi32, opnode, MemMRM>;
1148     let Predicates = [In64BitMode] in
1149     def NAME#64mi32 : BinOpMI_F<0x80, mnemonic, Xi64, opnode, MemMRM>;
1150
1151     // These are for the disassembler since 0x82 opcode behaves like 0x80, but
1152     // not in 64-bit mode.
1153     let Predicates = [Not64BitMode], isCodeGenOnly = 1, ForceDisassemble = 1,
1154         hasSideEffects = 0 in {
1155       def NAME#8ri8 : BinOpRI8_F<0x82, mnemonic, Xi8, null_frag, RegMRM>;
1156       let mayLoad = 1 in
1157         def NAME#8mi8 : BinOpMI8_F<mnemonic, Xi8, null_frag, MemMRM>;
1158     }
1159   } // Defs = [EFLAGS]
1160
1161   def NAME#8i8   : BinOpAI_F<BaseOpc4, mnemonic, Xi8 , AL,
1162                              "{$src, %al|al, $src}">;
1163   def NAME#16i16 : BinOpAI_F<BaseOpc4, mnemonic, Xi16, AX,
1164                              "{$src, %ax|ax, $src}">;
1165   def NAME#32i32 : BinOpAI_F<BaseOpc4, mnemonic, Xi32, EAX,
1166                              "{$src, %eax|eax, $src}">;
1167   def NAME#64i32 : BinOpAI_F<BaseOpc4, mnemonic, Xi64, RAX,
1168                              "{$src, %rax|rax, $src}">;
1169 }
1170
1171
1172 defm AND : ArithBinOp_RF<0x20, 0x22, 0x24, "and", MRM4r, MRM4m,
1173                          X86and_flag, and, 1, 0, 0>;
1174 defm OR  : ArithBinOp_RF<0x08, 0x0A, 0x0C, "or", MRM1r, MRM1m,
1175                          X86or_flag, or, 1, 0, 0>;
1176 defm XOR : ArithBinOp_RF<0x30, 0x32, 0x34, "xor", MRM6r, MRM6m,
1177                          X86xor_flag, xor, 1, 0, 0>;
1178 defm ADD : ArithBinOp_RF<0x00, 0x02, 0x04, "add", MRM0r, MRM0m,
1179                          X86add_flag, add, 1, 1, 1>;
1180 let isCompare = 1 in {
1181 defm SUB : ArithBinOp_RF<0x28, 0x2A, 0x2C, "sub", MRM5r, MRM5m,
1182                          X86sub_flag, sub, 0, 1, 0>;
1183 }
1184
1185 // Arithmetic.
1186 defm ADC : ArithBinOp_RFF<0x10, 0x12, 0x14, "adc", MRM2r, MRM2m, X86adc_flag,
1187                           1, 0>;
1188 defm SBB : ArithBinOp_RFF<0x18, 0x1A, 0x1C, "sbb", MRM3r, MRM3m, X86sbb_flag,
1189                           0, 0>;
1190
1191 let isCompare = 1 in {
1192 defm CMP : ArithBinOp_F<0x38, 0x3A, 0x3C, "cmp", MRM7r, MRM7m, X86cmp, 0, 0>;
1193 }
1194
1195 // Patterns to recognize loads on the LHS of an ADC. We can't make X86adc_flag
1196 // commutable since it has EFLAGs as an input.
1197 def : Pat<(X86adc_flag (loadi8 addr:$src2), GR8:$src1, EFLAGS),
1198           (ADC8rm GR8:$src1, addr:$src2)>;
1199 def : Pat<(X86adc_flag (loadi16 addr:$src2), GR16:$src1, EFLAGS),
1200           (ADC16rm GR16:$src1, addr:$src2)>;
1201 def : Pat<(X86adc_flag (loadi32 addr:$src2), GR32:$src1, EFLAGS),
1202           (ADC32rm GR32:$src1, addr:$src2)>;
1203 def : Pat<(X86adc_flag (loadi64 addr:$src2), GR64:$src1, EFLAGS),
1204           (ADC64rm GR64:$src1, addr:$src2)>;
1205
1206 // Patterns to recognize RMW ADC with loads in operand 1.
1207 def : Pat<(store (X86adc_flag GR8:$src, (loadi8 addr:$dst), EFLAGS),
1208                  addr:$dst),
1209           (ADC8mr addr:$dst, GR8:$src)>;
1210 def : Pat<(store (X86adc_flag GR16:$src, (loadi16 addr:$dst), EFLAGS),
1211                  addr:$dst),
1212           (ADC16mr addr:$dst, GR16:$src)>;
1213 def : Pat<(store (X86adc_flag GR32:$src, (loadi32 addr:$dst), EFLAGS),
1214                  addr:$dst),
1215           (ADC32mr addr:$dst, GR32:$src)>;
1216 def : Pat<(store (X86adc_flag GR64:$src, (loadi64 addr:$dst), EFLAGS),
1217                  addr:$dst),
1218           (ADC64mr addr:$dst, GR64:$src)>;
1219
1220 //===----------------------------------------------------------------------===//
1221 // Semantically, test instructions are similar like AND, except they don't
1222 // generate a result.  From an encoding perspective, they are very different:
1223 // they don't have all the usual imm8 and REV forms, and are encoded into a
1224 // different space.
1225 def X86testpat : PatFrag<(ops node:$lhs, node:$rhs),
1226                          (X86cmp (and_su node:$lhs, node:$rhs), 0)>;
1227
1228 let isCompare = 1 in {
1229   let Defs = [EFLAGS] in {
1230     let isCommutable = 1 in {
1231       // Avoid selecting these and instead use a test+and. Post processing will
1232       // combine them. This gives bunch of other patterns that start with
1233       // and a chance to match.
1234       def TEST8rr  : BinOpRR_F<0x84, "test", Xi8 , null_frag>;
1235       def TEST16rr : BinOpRR_F<0x84, "test", Xi16, null_frag>;
1236       def TEST32rr : BinOpRR_F<0x84, "test", Xi32, null_frag>;
1237       def TEST64rr : BinOpRR_F<0x84, "test", Xi64, null_frag>;
1238     } // isCommutable
1239
1240     let hasSideEffects = 0, mayLoad = 1 in {
1241     def TEST8mr    : BinOpMR_F<0x84, "test", Xi8 , null_frag>;
1242     def TEST16mr   : BinOpMR_F<0x84, "test", Xi16, null_frag>;
1243     def TEST32mr   : BinOpMR_F<0x84, "test", Xi32, null_frag>;
1244     def TEST64mr   : BinOpMR_F<0x84, "test", Xi64, null_frag>;
1245     }
1246
1247     def TEST8ri    : BinOpRI_F<0xF6, "test", Xi8 , X86testpat, MRM0r>;
1248     def TEST16ri   : BinOpRI_F<0xF6, "test", Xi16, X86testpat, MRM0r>;
1249     def TEST32ri   : BinOpRI_F<0xF6, "test", Xi32, X86testpat, MRM0r>;
1250     let Predicates = [In64BitMode] in
1251     def TEST64ri32 : BinOpRI_F<0xF6, "test", Xi64, X86testpat, MRM0r>;
1252
1253     def TEST8mi    : BinOpMI_F<0xF6, "test", Xi8 , X86testpat, MRM0m>;
1254     def TEST16mi   : BinOpMI_F<0xF6, "test", Xi16, X86testpat, MRM0m>;
1255     def TEST32mi   : BinOpMI_F<0xF6, "test", Xi32, X86testpat, MRM0m>;
1256     let Predicates = [In64BitMode] in
1257     def TEST64mi32 : BinOpMI_F<0xF6, "test", Xi64, X86testpat, MRM0m>;
1258   } // Defs = [EFLAGS]
1259
1260   def TEST8i8    : BinOpAI_F<0xA8, "test", Xi8 , AL,
1261                              "{$src, %al|al, $src}">;
1262   def TEST16i16  : BinOpAI_F<0xA8, "test", Xi16, AX,
1263                              "{$src, %ax|ax, $src}">;
1264   def TEST32i32  : BinOpAI_F<0xA8, "test", Xi32, EAX,
1265                              "{$src, %eax|eax, $src}">;
1266   def TEST64i32  : BinOpAI_F<0xA8, "test", Xi64, RAX,
1267                              "{$src, %rax|rax, $src}">;
1268 } // isCompare
1269
1270 //===----------------------------------------------------------------------===//
1271 // ANDN Instruction
1272 //
1273 multiclass bmi_andn<string mnemonic, RegisterClass RC, X86MemOperand x86memop,
1274                     PatFrag ld_frag> {
1275   def rr : I<0xF2, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
1276             !strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1277             [(set RC:$dst, EFLAGS, (X86and_flag (not RC:$src1), RC:$src2))]>,
1278             Sched<[WriteALU]>;
1279   def rm : I<0xF2, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
1280             !strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
1281             [(set RC:$dst, EFLAGS,
1282              (X86and_flag (not RC:$src1), (ld_frag addr:$src2)))]>,
1283            Sched<[WriteALU.Folded, WriteALU.ReadAfterFold]>;
1284 }
1285
1286 // Complexity is reduced to give and with immediate a chance to match first.
1287 let Predicates = [HasBMI], Defs = [EFLAGS], AddedComplexity = -6 in {
1288   defm ANDN32 : bmi_andn<"andn{l}", GR32, i32mem, loadi32>, T8PS, VEX_4V;
1289   defm ANDN64 : bmi_andn<"andn{q}", GR64, i64mem, loadi64>, T8PS, VEX_4V, VEX_W;
1290 }
1291
1292 let Predicates = [HasBMI], AddedComplexity = -6 in {
1293   def : Pat<(and (not GR32:$src1), GR32:$src2),
1294             (ANDN32rr GR32:$src1, GR32:$src2)>;
1295   def : Pat<(and (not GR64:$src1), GR64:$src2),
1296             (ANDN64rr GR64:$src1, GR64:$src2)>;
1297   def : Pat<(and (not GR32:$src1), (loadi32 addr:$src2)),
1298             (ANDN32rm GR32:$src1, addr:$src2)>;
1299   def : Pat<(and (not GR64:$src1), (loadi64 addr:$src2)),
1300             (ANDN64rm GR64:$src1, addr:$src2)>;
1301 }
1302
1303 //===----------------------------------------------------------------------===//
1304 // MULX Instruction
1305 //
1306 multiclass bmi_mulx<string mnemonic, RegisterClass RC, X86MemOperand x86memop,
1307                     X86FoldableSchedWrite sched> {
1308 let hasSideEffects = 0 in {
1309   let isCommutable = 1 in
1310   def rr : I<0xF6, MRMSrcReg, (outs RC:$dst1, RC:$dst2), (ins RC:$src),
1311              !strconcat(mnemonic, "\t{$src, $dst2, $dst1|$dst1, $dst2, $src}"),
1312              []>, T8XD, VEX_4V, Sched<[sched, WriteIMulH]>;
1313
1314   let mayLoad = 1 in
1315   def rm : I<0xF6, MRMSrcMem, (outs RC:$dst1, RC:$dst2), (ins x86memop:$src),
1316              !strconcat(mnemonic, "\t{$src, $dst2, $dst1|$dst1, $dst2, $src}"),
1317              []>, T8XD, VEX_4V, Sched<[sched.Folded, WriteIMulH]>;
1318 }
1319 }
1320
1321 let Predicates = [HasBMI2] in {
1322   let Uses = [EDX] in
1323     defm MULX32 : bmi_mulx<"mulx{l}", GR32, i32mem, WriteIMul32>;
1324   let Uses = [RDX] in
1325     defm MULX64 : bmi_mulx<"mulx{q}", GR64, i64mem, WriteIMul64>, VEX_W;
1326 }
1327
1328 //===----------------------------------------------------------------------===//
1329 // ADCX and ADOX Instructions
1330 //
1331 // We don't have patterns for these as there is no advantage over ADC for
1332 // most code.
1333 let Predicates = [HasADX], Defs = [EFLAGS], Uses = [EFLAGS],
1334     Constraints = "$src1 = $dst", hasSideEffects = 0 in {
1335   let SchedRW = [WriteADC], isCommutable = 1 in {
1336   def ADCX32rr : I<0xF6, MRMSrcReg, (outs GR32:$dst),
1337                    (ins GR32:$src1, GR32:$src2),
1338                    "adcx{l}\t{$src2, $dst|$dst, $src2}", []>, T8PD;
1339   def ADCX64rr : RI<0xF6, MRMSrcReg, (outs GR64:$dst),
1340                     (ins GR64:$src1, GR64:$src2),
1341                     "adcx{q}\t{$src2, $dst|$dst, $src2}", []>, T8PD;
1342
1343   def ADOX32rr : I<0xF6, MRMSrcReg, (outs GR32:$dst),
1344                    (ins GR32:$src1, GR32:$src2),
1345                    "adox{l}\t{$src2, $dst|$dst, $src2}", []>, T8XS;
1346
1347   def ADOX64rr : RI<0xF6, MRMSrcReg, (outs GR64:$dst),
1348                     (ins GR64:$src1, GR64:$src2),
1349                     "adox{q}\t{$src2, $dst|$dst, $src2}", []>, T8XS;
1350   } // SchedRW
1351
1352   let mayLoad = 1, SchedRW = [WriteADC.Folded, WriteADC.ReadAfterFold] in {
1353   def ADCX32rm : I<0xF6, MRMSrcMem, (outs GR32:$dst),
1354                    (ins GR32:$src1, i32mem:$src2),
1355                    "adcx{l}\t{$src2, $dst|$dst, $src2}", []>, T8PD;
1356
1357   def ADCX64rm : RI<0xF6, MRMSrcMem, (outs GR64:$dst),
1358                     (ins GR64:$src1, i64mem:$src2),
1359                     "adcx{q}\t{$src2, $dst|$dst, $src2}", []>, T8PD;
1360
1361   def ADOX32rm : I<0xF6, MRMSrcMem, (outs GR32:$dst),
1362                    (ins GR32:$src1, i32mem:$src2),
1363                    "adox{l}\t{$src2, $dst|$dst, $src2}", []>, T8XS;
1364
1365   def ADOX64rm : RI<0xF6, MRMSrcMem, (outs GR64:$dst),
1366                     (ins GR64:$src1, i64mem:$src2),
1367                     "adox{q}\t{$src2, $dst|$dst, $src2}", []>, T8XS;
1368   } // mayLoad, SchedRW
1369 }