contrib/llvm-project/llvm/lib/Target/X86/X86InstrCompiler.td

   1 //===- X86InstrCompiler.td - Compiler Pseudos and Patterns -*- 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 various pseudo instructions used by the compiler,
  10 // as well as Pat patterns used during instruction selection.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 //===----------------------------------------------------------------------===//
  15 // Pattern Matching Support
  16
  17 def GetLo32XForm : SDNodeXForm<imm, [{
  18   // Transformation function: get the low 32 bits.
  19   return getI32Imm((uint32_t)N->getZExtValue(), SDLoc(N));
  20 }]>;
  21
  22
  23 //===----------------------------------------------------------------------===//
  24 // Random Pseudo Instructions.
  25
  26 // PIC base construction.  This expands to code that looks like this:
  27 //     call  $next_inst
  28 //     popl %destreg"
  29 let hasSideEffects = 0, isNotDuplicable = 1, Uses = [ESP, SSP],
  30     SchedRW = [WriteJump] in
  31   def MOVPC32r : Ii32<0xE8, Pseudo, (outs GR32:$reg), (ins i32imm:$label),
  32                       "", []>;
  33
  34 // ADJCALLSTACKDOWN/UP implicitly use/def ESP because they may be expanded into
  35 // a stack adjustment and the codegen must know that they may modify the stack
  36 // pointer before prolog-epilog rewriting occurs.
  37 // Pessimistically assume ADJCALLSTACKDOWN / ADJCALLSTACKUP will become
  38 // sub / add which can clobber EFLAGS.
  39 let Defs = [ESP, EFLAGS, SSP], Uses = [ESP, SSP], SchedRW = [WriteALU] in {
  40 def ADJCALLSTACKDOWN32 : I<0, Pseudo, (outs),
  41                            (ins i32imm:$amt1, i32imm:$amt2, i32imm:$amt3),
  42                            "#ADJCALLSTACKDOWN", []>, Requires<[NotLP64]>;
  43 def ADJCALLSTACKUP32   : I<0, Pseudo, (outs), (ins i32imm:$amt1, i32imm:$amt2),
  44                            "#ADJCALLSTACKUP",
  45                            [(X86callseq_end timm:$amt1, timm:$amt2)]>,
  46                            Requires<[NotLP64]>;
  47 }
  48 def : Pat<(X86callseq_start timm:$amt1, timm:$amt2),
  49        (ADJCALLSTACKDOWN32 i32imm:$amt1, i32imm:$amt2, 0)>, Requires<[NotLP64]>;
  50
  51
  52 // ADJCALLSTACKDOWN/UP implicitly use/def RSP because they may be expanded into
  53 // a stack adjustment and the codegen must know that they may modify the stack
  54 // pointer before prolog-epilog rewriting occurs.
  55 // Pessimistically assume ADJCALLSTACKDOWN / ADJCALLSTACKUP will become
  56 // sub / add which can clobber EFLAGS.
  57 let Defs = [RSP, EFLAGS, SSP], Uses = [RSP, SSP], SchedRW = [WriteALU] in {
  58 def ADJCALLSTACKDOWN64 : I<0, Pseudo, (outs),
  59                            (ins i32imm:$amt1, i32imm:$amt2, i32imm:$amt3),
  60                            "#ADJCALLSTACKDOWN", []>, Requires<[IsLP64]>;
  61 def ADJCALLSTACKUP64   : I<0, Pseudo, (outs), (ins i32imm:$amt1, i32imm:$amt2),
  62                            "#ADJCALLSTACKUP",
  63                            [(X86callseq_end timm:$amt1, timm:$amt2)]>,
  64                            Requires<[IsLP64]>;
  65 }
  66 def : Pat<(X86callseq_start timm:$amt1, timm:$amt2),
  67         (ADJCALLSTACKDOWN64 i32imm:$amt1, i32imm:$amt2, 0)>, Requires<[IsLP64]>;
  68
  69 let SchedRW = [WriteSystem] in {
  70
  71 // x86-64 va_start lowering magic.
  72 let usesCustomInserter = 1, Defs = [EFLAGS] in {
  73 def VASTART_SAVE_XMM_REGS : I<0, Pseudo,
  74                               (outs),
  75                               (ins GR8:$al,
  76                                    i64imm:$regsavefi, i64imm:$offset,
  77                                    variable_ops),
  78                               "#VASTART_SAVE_XMM_REGS $al, $regsavefi, $offset",
  79                               [(X86vastart_save_xmm_regs GR8:$al,
  80                                                          imm:$regsavefi,
  81                                                          imm:$offset),
  82                                (implicit EFLAGS)]>;
  83
  84 // The VAARG_64 pseudo-instruction takes the address of the va_list,
  85 // and places the address of the next argument into a register.
  86 let Defs = [EFLAGS] in
  87 def VAARG_64 : I<0, Pseudo,
  88                  (outs GR64:$dst),
  89                  (ins i8mem:$ap, i32imm:$size, i8imm:$mode, i32imm:$align),
  90                  "#VAARG_64 $dst, $ap, $size, $mode, $align",
  91                  [(set GR64:$dst,
  92                     (X86vaarg64 addr:$ap, imm:$size, imm:$mode, imm:$align)),
  93                   (implicit EFLAGS)]>;
  94
  95
  96 // When using segmented stacks these are lowered into instructions which first
  97 // check if the current stacklet has enough free memory. If it does, memory is
  98 // allocated by bumping the stack pointer. Otherwise memory is allocated from
  99 // the heap.
 100
 101 let Defs = [EAX, ESP, EFLAGS], Uses = [ESP] in
 102 def SEG_ALLOCA_32 : I<0, Pseudo, (outs GR32:$dst), (ins GR32:$size),
 103                       "# variable sized alloca for segmented stacks",
 104                       [(set GR32:$dst,
 105                          (X86SegAlloca GR32:$size))]>,
 106                     Requires<[NotLP64]>;
 107
 108 let Defs = [RAX, RSP, EFLAGS], Uses = [RSP] in
 109 def SEG_ALLOCA_64 : I<0, Pseudo, (outs GR64:$dst), (ins GR64:$size),
 110                       "# variable sized alloca for segmented stacks",
 111                       [(set GR64:$dst,
 112                          (X86SegAlloca GR64:$size))]>,
 113                     Requires<[In64BitMode]>;
 114 }
 115
 116 // Dynamic stack allocation yields a _chkstk or _alloca call for all Windows
 117 // targets.  These calls are needed to probe the stack when allocating more than
 118 // 4k bytes in one go. Touching the stack at 4K increments is necessary to
 119 // ensure that the guard pages used by the OS virtual memory manager are
 120 // allocated in correct sequence.
 121 // The main point of having separate instruction are extra unmodelled effects
 122 // (compared to ordinary calls) like stack pointer change.
 123
 124 let Defs = [EAX, ESP, EFLAGS], Uses = [ESP] in
 125 def WIN_ALLOCA_32 : I<0, Pseudo, (outs), (ins GR32:$size),
 126                      "# dynamic stack allocation",
 127                      [(X86WinAlloca GR32:$size)]>,
 128                      Requires<[NotLP64]>;
 129
 130 let Defs = [RAX, RSP, EFLAGS], Uses = [RSP] in
 131 def WIN_ALLOCA_64 : I<0, Pseudo, (outs), (ins GR64:$size),
 132                      "# dynamic stack allocation",
 133                      [(X86WinAlloca GR64:$size)]>,
 134                      Requires<[In64BitMode]>;
 135 } // SchedRW
 136
 137 // These instructions XOR the frame pointer into a GPR. They are used in some
 138 // stack protection schemes. These are post-RA pseudos because we only know the
 139 // frame register after register allocation.
 140 let Constraints = "$src = $dst", isMoveImm = 1, isPseudo = 1, Defs = [EFLAGS] in {
 141   def XOR32_FP : I<0, Pseudo, (outs GR32:$dst), (ins GR32:$src),
 142                   "xorl\t$$FP, $src", []>,
 143                   Requires<[NotLP64]>, Sched<[WriteALU]>;
 144   def XOR64_FP : I<0, Pseudo, (outs GR64:$dst), (ins GR64:$src),
 145                   "xorq\t$$FP $src", []>,
 146                   Requires<[In64BitMode]>, Sched<[WriteALU]>;
 147 }
 148
 149 //===----------------------------------------------------------------------===//
 150 // EH Pseudo Instructions
 151 //
 152 let SchedRW = [WriteSystem] in {
 153 let isTerminator = 1, isReturn = 1, isBarrier = 1,
 154     hasCtrlDep = 1, isCodeGenOnly = 1 in {
 155 def EH_RETURN   : I<0xC3, RawFrm, (outs), (ins GR32:$addr),
 156                     "ret\t#eh_return, addr: $addr",
 157                     [(X86ehret GR32:$addr)]>, Sched<[WriteJumpLd]>;
 158
 159 }
 160
 161 let isTerminator = 1, isReturn = 1, isBarrier = 1,
 162     hasCtrlDep = 1, isCodeGenOnly = 1 in {
 163 def EH_RETURN64   : I<0xC3, RawFrm, (outs), (ins GR64:$addr),
 164                      "ret\t#eh_return, addr: $addr",
 165                      [(X86ehret GR64:$addr)]>, Sched<[WriteJumpLd]>;
 166
 167 }
 168
 169 let isTerminator = 1, hasSideEffects = 1, isBarrier = 1, hasCtrlDep = 1,
 170     isCodeGenOnly = 1, isReturn = 1, isEHScopeReturn = 1 in {
 171   def CLEANUPRET : I<0, Pseudo, (outs), (ins), "# CLEANUPRET", [(cleanupret)]>;
 172
 173   // CATCHRET needs a custom inserter for SEH.
 174   let usesCustomInserter = 1 in
 175     def CATCHRET : I<0, Pseudo, (outs), (ins brtarget32:$dst, brtarget32:$from),
 176                      "# CATCHRET",
 177                      [(catchret bb:$dst, bb:$from)]>;
 178 }
 179
 180 let hasSideEffects = 1, hasCtrlDep = 1, isCodeGenOnly = 1,
 181     usesCustomInserter = 1 in
 182 def CATCHPAD : I<0, Pseudo, (outs), (ins), "# CATCHPAD", [(catchpad)]>;
 183
 184 // This instruction is responsible for re-establishing stack pointers after an
 185 // exception has been caught and we are rejoining normal control flow in the
 186 // parent function or funclet. It generally sets ESP and EBP, and optionally
 187 // ESI. It is only needed for 32-bit WinEH, as the runtime restores CSRs for us
 188 // elsewhere.
 189 let hasSideEffects = 1, hasCtrlDep = 1, isCodeGenOnly = 1 in
 190 def EH_RESTORE : I<0, Pseudo, (outs), (ins), "# EH_RESTORE", []>;
 191
 192 let hasSideEffects = 1, isBarrier = 1, isCodeGenOnly = 1,
 193     usesCustomInserter = 1 in {
 194   def EH_SjLj_SetJmp32  : I<0, Pseudo, (outs GR32:$dst), (ins i32mem:$buf),
 195                             "#EH_SJLJ_SETJMP32",
 196                             [(set GR32:$dst, (X86eh_sjlj_setjmp addr:$buf))]>,
 197                           Requires<[Not64BitMode]>;
 198   def EH_SjLj_SetJmp64  : I<0, Pseudo, (outs GR32:$dst), (ins i64mem:$buf),
 199                             "#EH_SJLJ_SETJMP64",
 200                             [(set GR32:$dst, (X86eh_sjlj_setjmp addr:$buf))]>,
 201                           Requires<[In64BitMode]>;
 202   let isTerminator = 1 in {
 203   def EH_SjLj_LongJmp32 : I<0, Pseudo, (outs), (ins i32mem:$buf),
 204                             "#EH_SJLJ_LONGJMP32",
 205                             [(X86eh_sjlj_longjmp addr:$buf)]>,
 206                           Requires<[Not64BitMode]>;
 207   def EH_SjLj_LongJmp64 : I<0, Pseudo, (outs), (ins i64mem:$buf),
 208                             "#EH_SJLJ_LONGJMP64",
 209                             [(X86eh_sjlj_longjmp addr:$buf)]>,
 210                           Requires<[In64BitMode]>;
 211   }
 212 }
 213
 214 let isBranch = 1, isTerminator = 1, isCodeGenOnly = 1 in {
 215   def EH_SjLj_Setup : I<0, Pseudo, (outs), (ins brtarget:$dst),
 216                         "#EH_SjLj_Setup\t$dst", []>;
 217 }
 218 } // SchedRW
 219
 220 //===----------------------------------------------------------------------===//
 221 // Pseudo instructions used by unwind info.
 222 //
 223 let isPseudo = 1, SchedRW = [WriteSystem] in {
 224   def SEH_PushReg : I<0, Pseudo, (outs), (ins i32imm:$reg),
 225                             "#SEH_PushReg $reg", []>;
 226   def SEH_SaveReg : I<0, Pseudo, (outs), (ins i32imm:$reg, i32imm:$dst),
 227                             "#SEH_SaveReg $reg, $dst", []>;
 228   def SEH_SaveXMM : I<0, Pseudo, (outs), (ins i32imm:$reg, i32imm:$dst),
 229                             "#SEH_SaveXMM $reg, $dst", []>;
 230   def SEH_StackAlloc : I<0, Pseudo, (outs), (ins i32imm:$size),
 231                             "#SEH_StackAlloc $size", []>;
 232   def SEH_StackAlign : I<0, Pseudo, (outs), (ins i32imm:$align),
 233                             "#SEH_StackAlign $align", []>;
 234   def SEH_SetFrame : I<0, Pseudo, (outs), (ins i32imm:$reg, i32imm:$offset),
 235                             "#SEH_SetFrame $reg, $offset", []>;
 236   def SEH_PushFrame : I<0, Pseudo, (outs), (ins i1imm:$mode),
 237                             "#SEH_PushFrame $mode", []>;
 238   def SEH_EndPrologue : I<0, Pseudo, (outs), (ins),
 239                             "#SEH_EndPrologue", []>;
 240   def SEH_Epilogue : I<0, Pseudo, (outs), (ins),
 241                             "#SEH_Epilogue", []>;
 242 }
 243
 244 //===----------------------------------------------------------------------===//
 245 // Pseudo instructions used by segmented stacks.
 246 //
 247
 248 // This is lowered into a RET instruction by MCInstLower.  We need
 249 // this so that we don't have to have a MachineBasicBlock which ends
 250 // with a RET and also has successors.
 251 let isPseudo = 1, SchedRW = [WriteJumpLd] in {
 252 def MORESTACK_RET: I<0, Pseudo, (outs), (ins), "", []>;
 253
 254 // This instruction is lowered to a RET followed by a MOV.  The two
 255 // instructions are not generated on a higher level since then the
 256 // verifier sees a MachineBasicBlock ending with a non-terminator.
 257 def MORESTACK_RET_RESTORE_R10 : I<0, Pseudo, (outs), (ins), "", []>;
 258 }
 259
 260 //===----------------------------------------------------------------------===//
 261 // Alias Instructions
 262 //===----------------------------------------------------------------------===//
 263
 264 // Alias instruction mapping movr0 to xor.
 265 // FIXME: remove when we can teach regalloc that xor reg, reg is ok.
 266 let Defs = [EFLAGS], isReMaterializable = 1, isAsCheapAsAMove = 1,
 267     isPseudo = 1, isMoveImm = 1, AddedComplexity = 10 in
 268 def MOV32r0  : I<0, Pseudo, (outs GR32:$dst), (ins), "",
 269                  [(set GR32:$dst, 0)]>, Sched<[WriteZero]>;
 270
 271 // Other widths can also make use of the 32-bit xor, which may have a smaller
 272 // encoding and avoid partial register updates.
 273 let AddedComplexity = 10 in {
 274 def : Pat<(i8 0), (EXTRACT_SUBREG (MOV32r0), sub_8bit)>;
 275 def : Pat<(i16 0), (EXTRACT_SUBREG (MOV32r0), sub_16bit)>;
 276 def : Pat<(i64 0), (SUBREG_TO_REG (i64 0), (MOV32r0), sub_32bit)>;
 277 }
 278
 279 let Predicates = [OptForSize, Not64BitMode],
 280     AddedComplexity = 10 in {
 281   let SchedRW = [WriteALU] in {
 282   // Pseudo instructions for materializing 1 and -1 using XOR+INC/DEC,
 283   // which only require 3 bytes compared to MOV32ri which requires 5.
 284   let Defs = [EFLAGS], isReMaterializable = 1, isPseudo = 1 in {
 285     def MOV32r1 : I<0, Pseudo, (outs GR32:$dst), (ins), "",
 286                         [(set GR32:$dst, 1)]>;
 287     def MOV32r_1 : I<0, Pseudo, (outs GR32:$dst), (ins), "",
 288                         [(set GR32:$dst, -1)]>;
 289   }
 290   } // SchedRW
 291
 292   // MOV16ri is 4 bytes, so the instructions above are smaller.
 293   def : Pat<(i16 1), (EXTRACT_SUBREG (MOV32r1), sub_16bit)>;
 294   def : Pat<(i16 -1), (EXTRACT_SUBREG (MOV32r_1), sub_16bit)>;
 295 }
 296
 297 let isReMaterializable = 1, isPseudo = 1, AddedComplexity = 5,
 298     SchedRW = [WriteALU] in {
 299 // AddedComplexity higher than MOV64ri but lower than MOV32r0 and MOV32r1.
 300 def MOV32ImmSExti8 : I<0, Pseudo, (outs GR32:$dst), (ins i32i8imm:$src), "",
 301                        [(set GR32:$dst, i32immSExt8:$src)]>,
 302                        Requires<[OptForMinSize, NotWin64WithoutFP]>;
 303 def MOV64ImmSExti8 : I<0, Pseudo, (outs GR64:$dst), (ins i64i8imm:$src), "",
 304                        [(set GR64:$dst, i64immSExt8:$src)]>,
 305                        Requires<[OptForMinSize, NotWin64WithoutFP]>;
 306 }
 307
 308 // Materialize i64 constant where top 32-bits are zero. This could theoretically
 309 // use MOV32ri with a SUBREG_TO_REG to represent the zero-extension, however
 310 // that would make it more difficult to rematerialize.
 311 let isReMaterializable = 1, isAsCheapAsAMove = 1,
 312     isPseudo = 1, hasSideEffects = 0, SchedRW = [WriteMove] in
 313 def MOV32ri64 : I<0, Pseudo, (outs GR64:$dst), (ins i64i32imm:$src), "", []>;
 314
 315 // This 64-bit pseudo-move can be used for both a 64-bit constant that is
 316 // actually the zero-extension of a 32-bit constant and for labels in the
 317 // x86-64 small code model.
 318 def mov64imm32 : ComplexPattern<i64, 1, "selectMOV64Imm32", [imm, X86Wrapper]>;
 319
 320 def : Pat<(i64 mov64imm32:$src), (MOV32ri64 mov64imm32:$src)>;
 321
 322 // Use sbb to materialize carry bit.
 323 let Uses = [EFLAGS], Defs = [EFLAGS], isPseudo = 1, SchedRW = [WriteALU] in {
 324 // FIXME: These are pseudo ops that should be replaced with Pat<> patterns.
 325 // However, Pat<> can't replicate the destination reg into the inputs of the
 326 // result.
 327 def SETB_C8r : I<0, Pseudo, (outs GR8:$dst), (ins), "",
 328                  [(set GR8:$dst, (X86setcc_c X86_COND_B, EFLAGS))]>;
 329 def SETB_C16r : I<0, Pseudo, (outs GR16:$dst), (ins), "",
 330                  [(set GR16:$dst, (X86setcc_c X86_COND_B, EFLAGS))]>;
 331 def SETB_C32r : I<0, Pseudo, (outs GR32:$dst), (ins), "",
 332                  [(set GR32:$dst, (X86setcc_c X86_COND_B, EFLAGS))]>;
 333 def SETB_C64r : I<0, Pseudo, (outs GR64:$dst), (ins), "",
 334                  [(set GR64:$dst, (X86setcc_c X86_COND_B, EFLAGS))]>;
 335 } // isCodeGenOnly
 336
 337
 338 def : Pat<(i16 (anyext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
 339           (SETB_C16r)>;
 340 def : Pat<(i32 (anyext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
 341           (SETB_C32r)>;
 342 def : Pat<(i64 (anyext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
 343           (SETB_C64r)>;
 344
 345 def : Pat<(i16 (sext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
 346           (SETB_C16r)>;
 347 def : Pat<(i32 (sext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
 348           (SETB_C32r)>;
 349 def : Pat<(i64 (sext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
 350           (SETB_C64r)>;
 351
 352 // We canonicalize 'setb' to "(and (sbb reg,reg), 1)" on the hope that the and
 353 // will be eliminated and that the sbb can be extended up to a wider type.  When
 354 // this happens, it is great.  However, if we are left with an 8-bit sbb and an
 355 // and, we might as well just match it as a setb.
 356 def : Pat<(and (i8 (X86setcc_c X86_COND_B, EFLAGS)), 1),
 357           (SETCCr (i8 2))>;
 358
 359 // Patterns to give priority when both inputs are zero so that we don't use
 360 // an immediate for the RHS.
 361 // TODO: Should we use a 32-bit sbb for 8/16 to push the extract_subreg out?
 362 def : Pat<(X86sbb_flag (i8 0), (i8 0), EFLAGS),
 363           (SBB8rr (EXTRACT_SUBREG (MOV32r0), sub_8bit),
 364                   (EXTRACT_SUBREG (MOV32r0), sub_8bit))>;
 365 def : Pat<(X86sbb_flag (i16 0), (i16 0), EFLAGS),
 366           (SBB16rr (EXTRACT_SUBREG (MOV32r0), sub_16bit),
 367                    (EXTRACT_SUBREG (MOV32r0), sub_16bit))>;
 368 def : Pat<(X86sbb_flag (i32 0), (i32 0), EFLAGS),
 369           (SBB32rr (MOV32r0), (MOV32r0))>;
 370 def : Pat<(X86sbb_flag (i64 0), (i64 0), EFLAGS),
 371           (SBB64rr (SUBREG_TO_REG (i64 0), (MOV32r0), sub_32bit),
 372                    (SUBREG_TO_REG (i64 0), (MOV32r0), sub_32bit))>;
 373
 374 //===----------------------------------------------------------------------===//
 375 // String Pseudo Instructions
 376 //
 377 let SchedRW = [WriteMicrocoded] in {
 378 let Defs = [ECX,EDI,ESI], Uses = [ECX,EDI,ESI], isCodeGenOnly = 1 in {
 379 def REP_MOVSB_32 : I<0xA4, RawFrm, (outs), (ins),
 380                     "{rep;movsb (%esi), %es:(%edi)|rep movsb es:[edi], [esi]}",
 381                     [(X86rep_movs i8)]>, REP, AdSize32,
 382                    Requires<[NotLP64]>;
 383 def REP_MOVSW_32 : I<0xA5, RawFrm, (outs), (ins),
 384                     "{rep;movsw (%esi), %es:(%edi)|rep movsw es:[edi], [esi]}",
 385                     [(X86rep_movs i16)]>, REP, AdSize32, OpSize16,
 386                    Requires<[NotLP64]>;
 387 def REP_MOVSD_32 : I<0xA5, RawFrm, (outs), (ins),
 388                     "{rep;movsl (%esi), %es:(%edi)|rep movsd es:[edi], [esi]}",
 389                     [(X86rep_movs i32)]>, REP, AdSize32, OpSize32,
 390                    Requires<[NotLP64]>;
 391 def REP_MOVSQ_32 : RI<0xA5, RawFrm, (outs), (ins),
 392                     "{rep;movsq (%esi), %es:(%edi)|rep movsq es:[edi], [esi]}",
 393                     [(X86rep_movs i64)]>, REP, AdSize32,
 394                    Requires<[NotLP64, In64BitMode]>;
 395 }
 396
 397 let Defs = [RCX,RDI,RSI], Uses = [RCX,RDI,RSI], isCodeGenOnly = 1 in {
 398 def REP_MOVSB_64 : I<0xA4, RawFrm, (outs), (ins),
 399                     "{rep;movsb (%rsi), %es:(%rdi)|rep movsb es:[rdi], [rsi]}",
 400                     [(X86rep_movs i8)]>, REP, AdSize64,
 401                    Requires<[IsLP64]>;
 402 def REP_MOVSW_64 : I<0xA5, RawFrm, (outs), (ins),
 403                     "{rep;movsw (%rsi), %es:(%rdi)|rep movsw es:[rdi], [rsi]}",
 404                     [(X86rep_movs i16)]>, REP, AdSize64, OpSize16,
 405                    Requires<[IsLP64]>;
 406 def REP_MOVSD_64 : I<0xA5, RawFrm, (outs), (ins),
 407                     "{rep;movsl (%rsi), %es:(%rdi)|rep movsdi es:[rdi], [rsi]}",
 408                     [(X86rep_movs i32)]>, REP, AdSize64, OpSize32,
 409                    Requires<[IsLP64]>;
 410 def REP_MOVSQ_64 : RI<0xA5, RawFrm, (outs), (ins),
 411                     "{rep;movsq (%rsi), %es:(%rdi)|rep movsq es:[rdi], [rsi]}",
 412                     [(X86rep_movs i64)]>, REP, AdSize64,
 413                    Requires<[IsLP64]>;
 414 }
 415
 416 // FIXME: Should use "(X86rep_stos AL)" as the pattern.
 417 let Defs = [ECX,EDI], isCodeGenOnly = 1 in {
 418   let Uses = [AL,ECX,EDI] in
 419   def REP_STOSB_32 : I<0xAA, RawFrm, (outs), (ins),
 420                        "{rep;stosb %al, %es:(%edi)|rep stosb es:[edi], al}",
 421                       [(X86rep_stos i8)]>, REP, AdSize32,
 422                      Requires<[NotLP64]>;
 423   let Uses = [AX,ECX,EDI] in
 424   def REP_STOSW_32 : I<0xAB, RawFrm, (outs), (ins),
 425                       "{rep;stosw %ax, %es:(%edi)|rep stosw es:[edi], ax}",
 426                       [(X86rep_stos i16)]>, REP, AdSize32, OpSize16,
 427                      Requires<[NotLP64]>;
 428   let Uses = [EAX,ECX,EDI] in
 429   def REP_STOSD_32 : I<0xAB, RawFrm, (outs), (ins),
 430                       "{rep;stosl %eax, %es:(%edi)|rep stosd es:[edi], eax}",
 431                       [(X86rep_stos i32)]>, REP, AdSize32, OpSize32,
 432                      Requires<[NotLP64]>;
 433   let Uses = [RAX,RCX,RDI] in
 434   def REP_STOSQ_32 : RI<0xAB, RawFrm, (outs), (ins),
 435                         "{rep;stosq %rax, %es:(%edi)|rep stosq es:[edi], rax}",
 436                         [(X86rep_stos i64)]>, REP, AdSize32,
 437                         Requires<[NotLP64, In64BitMode]>;
 438 }
 439
 440 let Defs = [RCX,RDI], isCodeGenOnly = 1 in {
 441   let Uses = [AL,RCX,RDI] in
 442   def REP_STOSB_64 : I<0xAA, RawFrm, (outs), (ins),
 443                        "{rep;stosb %al, %es:(%rdi)|rep stosb es:[rdi], al}",
 444                        [(X86rep_stos i8)]>, REP, AdSize64,
 445                        Requires<[IsLP64]>;
 446   let Uses = [AX,RCX,RDI] in
 447   def REP_STOSW_64 : I<0xAB, RawFrm, (outs), (ins),
 448                        "{rep;stosw %ax, %es:(%rdi)|rep stosw es:[rdi], ax}",
 449                        [(X86rep_stos i16)]>, REP, AdSize64, OpSize16,
 450                        Requires<[IsLP64]>;
 451   let Uses = [RAX,RCX,RDI] in
 452   def REP_STOSD_64 : I<0xAB, RawFrm, (outs), (ins),
 453                       "{rep;stosl %eax, %es:(%rdi)|rep stosd es:[rdi], eax}",
 454                        [(X86rep_stos i32)]>, REP, AdSize64, OpSize32,
 455                        Requires<[IsLP64]>;
 456
 457   let Uses = [RAX,RCX,RDI] in
 458   def REP_STOSQ_64 : RI<0xAB, RawFrm, (outs), (ins),
 459                         "{rep;stosq %rax, %es:(%rdi)|rep stosq es:[rdi], rax}",
 460                         [(X86rep_stos i64)]>, REP, AdSize64,
 461                         Requires<[IsLP64]>;
 462 }
 463 } // SchedRW
 464
 465 //===----------------------------------------------------------------------===//
 466 // Thread Local Storage Instructions
 467 //
 468 let SchedRW = [WriteSystem] in {
 469
 470 // ELF TLS Support
 471 // All calls clobber the non-callee saved registers. ESP is marked as
 472 // a use to prevent stack-pointer assignments that appear immediately
 473 // before calls from potentially appearing dead.
 474 let Defs = [EAX, ECX, EDX, FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7,
 475             ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7,
 476             MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7,
 477             XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
 478             XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, EFLAGS, DF],
 479     usesCustomInserter = 1, Uses = [ESP, SSP] in {
 480 def TLS_addr32 : I<0, Pseudo, (outs), (ins i32mem:$sym),
 481                   "# TLS_addr32",
 482                   [(X86tlsaddr tls32addr:$sym)]>,
 483                   Requires<[Not64BitMode]>;
 484 def TLS_base_addr32 : I<0, Pseudo, (outs), (ins i32mem:$sym),
 485                   "# TLS_base_addr32",
 486                   [(X86tlsbaseaddr tls32baseaddr:$sym)]>,
 487                   Requires<[Not64BitMode]>;
 488 }
 489
 490 // All calls clobber the non-callee saved registers. RSP is marked as
 491 // a use to prevent stack-pointer assignments that appear immediately
 492 // before calls from potentially appearing dead.
 493 let Defs = [RAX, RCX, RDX, RSI, RDI, R8, R9, R10, R11,
 494             FP0, FP1, FP2, FP3, FP4, FP5, FP6, FP7,
 495             ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7,
 496             MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7,
 497             XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7,
 498             XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15, EFLAGS, DF],
 499     usesCustomInserter = 1, Uses = [RSP, SSP] in {
 500 def TLS_addr64 : I<0, Pseudo, (outs), (ins i64mem:$sym),
 501                    "# TLS_addr64",
 502                   [(X86tlsaddr tls64addr:$sym)]>,
 503                   Requires<[In64BitMode]>;
 504 def TLS_base_addr64 : I<0, Pseudo, (outs), (ins i64mem:$sym),
 505                    "# TLS_base_addr64",
 506                   [(X86tlsbaseaddr tls64baseaddr:$sym)]>,
 507                   Requires<[In64BitMode]>;
 508 }
 509
 510 // Darwin TLS Support
 511 // For i386, the address of the thunk is passed on the stack, on return the
 512 // address of the variable is in %eax.  %ecx is trashed during the function
 513 // call.  All other registers are preserved.
 514 let Defs = [EAX, ECX, EFLAGS, DF],
 515     Uses = [ESP, SSP],
 516     usesCustomInserter = 1 in
 517 def TLSCall_32 : I<0, Pseudo, (outs), (ins i32mem:$sym),
 518                 "# TLSCall_32",
 519                 [(X86TLSCall addr:$sym)]>,
 520                 Requires<[Not64BitMode]>;
 521
 522 // For x86_64, the address of the thunk is passed in %rdi, but the
 523 // pseudo directly use the symbol, so do not add an implicit use of
 524 // %rdi. The lowering will do the right thing with RDI.
 525 // On return the address of the variable is in %rax.  All other
 526 // registers are preserved.
 527 let Defs = [RAX, EFLAGS, DF],
 528     Uses = [RSP, SSP],
 529     usesCustomInserter = 1 in
 530 def TLSCall_64 : I<0, Pseudo, (outs), (ins i64mem:$sym),
 531                   "# TLSCall_64",
 532                   [(X86TLSCall addr:$sym)]>,
 533                   Requires<[In64BitMode]>;
 534 } // SchedRW
 535
 536 //===----------------------------------------------------------------------===//
 537 // Conditional Move Pseudo Instructions
 538
 539 // CMOV* - Used to implement the SELECT DAG operation.  Expanded after
 540 // instruction selection into a branch sequence.
 541 multiclass CMOVrr_PSEUDO<RegisterClass RC, ValueType VT> {
 542   def CMOV#NAME  : I<0, Pseudo,
 543                     (outs RC:$dst), (ins RC:$t, RC:$f, i8imm:$cond),
 544                     "#CMOV_"#NAME#" PSEUDO!",
 545                     [(set RC:$dst, (VT (X86cmov RC:$t, RC:$f, timm:$cond,
 546                                                 EFLAGS)))]>;
 547 }
 548
 549 let usesCustomInserter = 1, hasNoSchedulingInfo = 1, Uses = [EFLAGS] in {
 550   // X86 doesn't have 8-bit conditional moves. Use a customInserter to
 551   // emit control flow. An alternative to this is to mark i8 SELECT as Promote,
 552   // however that requires promoting the operands, and can induce additional
 553   // i8 register pressure.
 554   defm _GR8 : CMOVrr_PSEUDO<GR8, i8>;
 555
 556   let Predicates = [NoCMov] in {
 557     defm _GR32 : CMOVrr_PSEUDO<GR32, i32>;
 558     defm _GR16 : CMOVrr_PSEUDO<GR16, i16>;
 559   } // Predicates = [NoCMov]
 560
 561   // fcmov doesn't handle all possible EFLAGS, provide a fallback if there is no
 562   // SSE1/SSE2.
 563   let Predicates = [FPStackf32] in
 564     defm _RFP32 : CMOVrr_PSEUDO<RFP32, f32>;
 565
 566   let Predicates = [FPStackf64] in
 567     defm _RFP64 : CMOVrr_PSEUDO<RFP64, f64>;
 568
 569   defm _RFP80 : CMOVrr_PSEUDO<RFP80, f80>;
 570
 571   let Predicates = [NoAVX512] in {
 572     defm _FR32   : CMOVrr_PSEUDO<FR32, f32>;
 573     defm _FR64   : CMOVrr_PSEUDO<FR64, f64>;
 574   }
 575   let Predicates = [HasAVX512] in {
 576     defm _FR32X  : CMOVrr_PSEUDO<FR32X, f32>;
 577     defm _FR64X  : CMOVrr_PSEUDO<FR64X, f64>;
 578   }
 579   let Predicates = [NoVLX] in {
 580     defm _VR128  : CMOVrr_PSEUDO<VR128, v2i64>;
 581     defm _VR256  : CMOVrr_PSEUDO<VR256, v4i64>;
 582   }
 583   let Predicates = [HasVLX] in {
 584     defm _VR128X : CMOVrr_PSEUDO<VR128X, v2i64>;
 585     defm _VR256X : CMOVrr_PSEUDO<VR256X, v4i64>;
 586   }
 587   defm _VR512  : CMOVrr_PSEUDO<VR512, v8i64>;
 588   defm _VK2    : CMOVrr_PSEUDO<VK2,  v2i1>;
 589   defm _VK4    : CMOVrr_PSEUDO<VK4,  v4i1>;
 590   defm _VK8    : CMOVrr_PSEUDO<VK8,  v8i1>;
 591   defm _VK16   : CMOVrr_PSEUDO<VK16, v16i1>;
 592   defm _VK32   : CMOVrr_PSEUDO<VK32, v32i1>;
 593   defm _VK64   : CMOVrr_PSEUDO<VK64, v64i1>;
 594 } // usesCustomInserter = 1, hasNoSchedulingInfo = 1, Uses = [EFLAGS]
 595
 596 def : Pat<(f128 (X86cmov VR128:$t, VR128:$f, timm:$cond, EFLAGS)),
 597           (CMOV_VR128 VR128:$t, VR128:$f, timm:$cond)>;
 598
 599 let Predicates = [NoVLX] in {
 600   def : Pat<(v16i8 (X86cmov VR128:$t, VR128:$f, timm:$cond, EFLAGS)),
 601             (CMOV_VR128 VR128:$t, VR128:$f, timm:$cond)>;
 602   def : Pat<(v8i16 (X86cmov VR128:$t, VR128:$f, timm:$cond, EFLAGS)),
 603             (CMOV_VR128 VR128:$t, VR128:$f, timm:$cond)>;
 604   def : Pat<(v4i32 (X86cmov VR128:$t, VR128:$f, timm:$cond, EFLAGS)),
 605             (CMOV_VR128 VR128:$t, VR128:$f, timm:$cond)>;
 606   def : Pat<(v4f32 (X86cmov VR128:$t, VR128:$f, timm:$cond, EFLAGS)),
 607             (CMOV_VR128 VR128:$t, VR128:$f, timm:$cond)>;
 608   def : Pat<(v2f64 (X86cmov VR128:$t, VR128:$f, timm:$cond, EFLAGS)),
 609             (CMOV_VR128 VR128:$t, VR128:$f, timm:$cond)>;
 610
 611   def : Pat<(v32i8 (X86cmov VR256:$t, VR256:$f, timm:$cond, EFLAGS)),
 612             (CMOV_VR256 VR256:$t, VR256:$f, timm:$cond)>;
 613   def : Pat<(v16i16 (X86cmov VR256:$t, VR256:$f, timm:$cond, EFLAGS)),
 614             (CMOV_VR256 VR256:$t, VR256:$f, timm:$cond)>;
 615   def : Pat<(v8i32 (X86cmov VR256:$t, VR256:$f, timm:$cond, EFLAGS)),
 616             (CMOV_VR256 VR256:$t, VR256:$f, timm:$cond)>;
 617   def : Pat<(v8f32 (X86cmov VR256:$t, VR256:$f, timm:$cond, EFLAGS)),
 618             (CMOV_VR256 VR256:$t, VR256:$f, timm:$cond)>;
 619   def : Pat<(v4f64 (X86cmov VR256:$t, VR256:$f, timm:$cond, EFLAGS)),
 620             (CMOV_VR256 VR256:$t, VR256:$f, timm:$cond)>;
 621 }
 622 let Predicates = [HasVLX] in {
 623   def : Pat<(v16i8 (X86cmov VR128X:$t, VR128X:$f, timm:$cond, EFLAGS)),
 624             (CMOV_VR128X VR128X:$t, VR128X:$f, timm:$cond)>;
 625   def : Pat<(v8i16 (X86cmov VR128X:$t, VR128X:$f, timm:$cond, EFLAGS)),
 626             (CMOV_VR128X VR128X:$t, VR128X:$f, timm:$cond)>;
 627   def : Pat<(v4i32 (X86cmov VR128X:$t, VR128X:$f, timm:$cond, EFLAGS)),
 628             (CMOV_VR128X VR128X:$t, VR128X:$f, timm:$cond)>;
 629   def : Pat<(v4f32 (X86cmov VR128X:$t, VR128X:$f, timm:$cond, EFLAGS)),
 630             (CMOV_VR128X VR128X:$t, VR128X:$f, timm:$cond)>;
 631   def : Pat<(v2f64 (X86cmov VR128X:$t, VR128X:$f, timm:$cond, EFLAGS)),
 632             (CMOV_VR128X VR128X:$t, VR128X:$f, timm:$cond)>;
 633
 634   def : Pat<(v32i8 (X86cmov VR256X:$t, VR256X:$f, timm:$cond, EFLAGS)),
 635             (CMOV_VR256X VR256X:$t, VR256X:$f, timm:$cond)>;
 636   def : Pat<(v16i16 (X86cmov VR256X:$t, VR256X:$f, timm:$cond, EFLAGS)),
 637             (CMOV_VR256X VR256X:$t, VR256X:$f, timm:$cond)>;
 638   def : Pat<(v8i32 (X86cmov VR256X:$t, VR256X:$f, timm:$cond, EFLAGS)),
 639             (CMOV_VR256X VR256X:$t, VR256X:$f, timm:$cond)>;
 640   def : Pat<(v8f32 (X86cmov VR256X:$t, VR256X:$f, timm:$cond, EFLAGS)),
 641             (CMOV_VR256X VR256X:$t, VR256X:$f, timm:$cond)>;
 642   def : Pat<(v4f64 (X86cmov VR256X:$t, VR256X:$f, timm:$cond, EFLAGS)),
 643             (CMOV_VR256X VR256X:$t, VR256X:$f, timm:$cond)>;
 644 }
 645
 646 def : Pat<(v64i8 (X86cmov VR512:$t, VR512:$f, timm:$cond, EFLAGS)),
 647           (CMOV_VR512 VR512:$t, VR512:$f, timm:$cond)>;
 648 def : Pat<(v32i16 (X86cmov VR512:$t, VR512:$f, timm:$cond, EFLAGS)),
 649           (CMOV_VR512 VR512:$t, VR512:$f, timm:$cond)>;
 650 def : Pat<(v16i32 (X86cmov VR512:$t, VR512:$f, timm:$cond, EFLAGS)),
 651           (CMOV_VR512 VR512:$t, VR512:$f, timm:$cond)>;
 652 def : Pat<(v16f32 (X86cmov VR512:$t, VR512:$f, timm:$cond, EFLAGS)),
 653           (CMOV_VR512 VR512:$t, VR512:$f, timm:$cond)>;
 654 def : Pat<(v8f64 (X86cmov VR512:$t, VR512:$f, timm:$cond, EFLAGS)),
 655           (CMOV_VR512 VR512:$t, VR512:$f, timm:$cond)>;
 656
 657 //===----------------------------------------------------------------------===//
 658 // Normal-Instructions-With-Lock-Prefix Pseudo Instructions
 659 //===----------------------------------------------------------------------===//
 660
 661 // FIXME: Use normal instructions and add lock prefix dynamically.
 662
 663 // Memory barriers
 664
 665 let isCodeGenOnly = 1, Defs = [EFLAGS] in
 666 def OR32mi8Locked  : Ii8<0x83, MRM1m, (outs), (ins i32mem:$dst, i32i8imm:$zero),
 667                          "or{l}\t{$zero, $dst|$dst, $zero}", []>,
 668                          Requires<[Not64BitMode]>, OpSize32, LOCK,
 669                          Sched<[WriteALURMW]>;
 670
 671 let hasSideEffects = 1 in
 672 def Int_MemBarrier : I<0, Pseudo, (outs), (ins),
 673                      "#MEMBARRIER",
 674                      [(X86MemBarrier)]>, Sched<[WriteLoad]>;
 675
 676 // RegOpc corresponds to the mr version of the instruction
 677 // ImmOpc corresponds to the mi version of the instruction
 678 // ImmOpc8 corresponds to the mi8 version of the instruction
 679 // ImmMod corresponds to the instruction format of the mi and mi8 versions
 680 multiclass LOCK_ArithBinOp<bits<8> RegOpc, bits<8> ImmOpc, bits<8> ImmOpc8,
 681                            Format ImmMod, SDNode Op, string mnemonic> {
 682 let Defs = [EFLAGS], mayLoad = 1, mayStore = 1, isCodeGenOnly = 1,
 683     SchedRW = [WriteALURMW] in {
 684
 685 def NAME#8mr : I<{RegOpc{7}, RegOpc{6}, RegOpc{5}, RegOpc{4},
 686                   RegOpc{3}, RegOpc{2}, RegOpc{1}, 0 },
 687                   MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src2),
 688                   !strconcat(mnemonic, "{b}\t",
 689                              "{$src2, $dst|$dst, $src2}"),
 690                   [(set EFLAGS, (Op addr:$dst, GR8:$src2))]>, LOCK;
 691
 692 def NAME#16mr : I<{RegOpc{7}, RegOpc{6}, RegOpc{5}, RegOpc{4},
 693                    RegOpc{3}, RegOpc{2}, RegOpc{1}, 1 },
 694                    MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src2),
 695                    !strconcat(mnemonic, "{w}\t",
 696                               "{$src2, $dst|$dst, $src2}"),
 697                    [(set EFLAGS, (Op addr:$dst, GR16:$src2))]>,
 698                    OpSize16, LOCK;
 699
 700 def NAME#32mr : I<{RegOpc{7}, RegOpc{6}, RegOpc{5}, RegOpc{4},
 701                    RegOpc{3}, RegOpc{2}, RegOpc{1}, 1 },
 702                    MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src2),
 703                    !strconcat(mnemonic, "{l}\t",
 704                               "{$src2, $dst|$dst, $src2}"),
 705                    [(set EFLAGS, (Op addr:$dst, GR32:$src2))]>,
 706                    OpSize32, LOCK;
 707
 708 def NAME#64mr : RI<{RegOpc{7}, RegOpc{6}, RegOpc{5}, RegOpc{4},
 709                     RegOpc{3}, RegOpc{2}, RegOpc{1}, 1 },
 710                     MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src2),
 711                     !strconcat(mnemonic, "{q}\t",
 712                                "{$src2, $dst|$dst, $src2}"),
 713                     [(set EFLAGS, (Op addr:$dst, GR64:$src2))]>, LOCK;
 714
 715 // NOTE: These are order specific, we want the mi8 forms to be listed
 716 // first so that they are slightly preferred to the mi forms.
 717 def NAME#16mi8 : Ii8<{ImmOpc8{7}, ImmOpc8{6}, ImmOpc8{5}, ImmOpc8{4},
 718                       ImmOpc8{3}, ImmOpc8{2}, ImmOpc8{1}, 1 },
 719                       ImmMod, (outs), (ins i16mem :$dst, i16i8imm :$src2),
 720                       !strconcat(mnemonic, "{w}\t",
 721                                  "{$src2, $dst|$dst, $src2}"),
 722                       [(set EFLAGS, (Op addr:$dst, i16immSExt8:$src2))]>,
 723                       OpSize16, LOCK;
 724
 725 def NAME#32mi8 : Ii8<{ImmOpc8{7}, ImmOpc8{6}, ImmOpc8{5}, ImmOpc8{4},
 726                       ImmOpc8{3}, ImmOpc8{2}, ImmOpc8{1}, 1 },
 727                       ImmMod, (outs), (ins i32mem :$dst, i32i8imm :$src2),
 728                       !strconcat(mnemonic, "{l}\t",
 729                                  "{$src2, $dst|$dst, $src2}"),
 730                       [(set EFLAGS, (Op addr:$dst, i32immSExt8:$src2))]>,
 731                       OpSize32, LOCK;
 732
 733 def NAME#64mi8 : RIi8<{ImmOpc8{7}, ImmOpc8{6}, ImmOpc8{5}, ImmOpc8{4},
 734                        ImmOpc8{3}, ImmOpc8{2}, ImmOpc8{1}, 1 },
 735                        ImmMod, (outs), (ins i64mem :$dst, i64i8imm :$src2),
 736                        !strconcat(mnemonic, "{q}\t",
 737                                   "{$src2, $dst|$dst, $src2}"),
 738                        [(set EFLAGS, (Op addr:$dst, i64immSExt8:$src2))]>,
 739                        LOCK;
 740
 741 def NAME#8mi : Ii8<{ImmOpc{7}, ImmOpc{6}, ImmOpc{5}, ImmOpc{4},
 742                     ImmOpc{3}, ImmOpc{2}, ImmOpc{1}, 0 },
 743                     ImmMod, (outs), (ins i8mem :$dst, i8imm :$src2),
 744                     !strconcat(mnemonic, "{b}\t",
 745                                "{$src2, $dst|$dst, $src2}"),
 746                     [(set EFLAGS, (Op addr:$dst, (i8 imm:$src2)))]>, LOCK;
 747
 748 def NAME#16mi : Ii16<{ImmOpc{7}, ImmOpc{6}, ImmOpc{5}, ImmOpc{4},
 749                       ImmOpc{3}, ImmOpc{2}, ImmOpc{1}, 1 },
 750                       ImmMod, (outs), (ins i16mem :$dst, i16imm :$src2),
 751                       !strconcat(mnemonic, "{w}\t",
 752                                  "{$src2, $dst|$dst, $src2}"),
 753                       [(set EFLAGS, (Op addr:$dst, (i16 imm:$src2)))]>,
 754                       OpSize16, LOCK;
 755
 756 def NAME#32mi : Ii32<{ImmOpc{7}, ImmOpc{6}, ImmOpc{5}, ImmOpc{4},
 757                       ImmOpc{3}, ImmOpc{2}, ImmOpc{1}, 1 },
 758                       ImmMod, (outs), (ins i32mem :$dst, i32imm :$src2),
 759                       !strconcat(mnemonic, "{l}\t",
 760                                  "{$src2, $dst|$dst, $src2}"),
 761                       [(set EFLAGS, (Op addr:$dst, (i32 imm:$src2)))]>,
 762                       OpSize32, LOCK;
 763
 764 def NAME#64mi32 : RIi32S<{ImmOpc{7}, ImmOpc{6}, ImmOpc{5}, ImmOpc{4},
 765                           ImmOpc{3}, ImmOpc{2}, ImmOpc{1}, 1 },
 766                           ImmMod, (outs), (ins i64mem :$dst, i64i32imm :$src2),
 767                           !strconcat(mnemonic, "{q}\t",
 768                                      "{$src2, $dst|$dst, $src2}"),
 769                           [(set EFLAGS, (Op addr:$dst, i64immSExt32:$src2))]>,
 770                           LOCK;
 771 }
 772
 773 }
 774
 775 defm LOCK_ADD : LOCK_ArithBinOp<0x00, 0x80, 0x83, MRM0m, X86lock_add, "add">;
 776 defm LOCK_SUB : LOCK_ArithBinOp<0x28, 0x80, 0x83, MRM5m, X86lock_sub, "sub">;
 777 defm LOCK_OR  : LOCK_ArithBinOp<0x08, 0x80, 0x83, MRM1m, X86lock_or , "or">;
 778 defm LOCK_AND : LOCK_ArithBinOp<0x20, 0x80, 0x83, MRM4m, X86lock_and, "and">;
 779 defm LOCK_XOR : LOCK_ArithBinOp<0x30, 0x80, 0x83, MRM6m, X86lock_xor, "xor">;
 780
 781 def X86lock_add_nocf : PatFrag<(ops node:$lhs, node:$rhs),
 782                                (X86lock_add node:$lhs, node:$rhs), [{
 783   return hasNoCarryFlagUses(SDValue(N, 0));
 784 }]>;
 785
 786 def X86lock_sub_nocf : PatFrag<(ops node:$lhs, node:$rhs),
 787                                (X86lock_sub node:$lhs, node:$rhs), [{
 788   return hasNoCarryFlagUses(SDValue(N, 0));
 789 }]>;
 790
 791 let Predicates = [UseIncDec] in {
 792   let Defs = [EFLAGS], mayLoad = 1, mayStore = 1, isCodeGenOnly = 1,
 793       SchedRW = [WriteALURMW]  in {
 794     def LOCK_INC8m  : I<0xFE, MRM0m, (outs), (ins i8mem :$dst),
 795                         "inc{b}\t$dst",
 796                         [(set EFLAGS, (X86lock_add_nocf addr:$dst, (i8 1)))]>,
 797                         LOCK;
 798     def LOCK_INC16m : I<0xFF, MRM0m, (outs), (ins i16mem:$dst),
 799                         "inc{w}\t$dst",
 800                         [(set EFLAGS, (X86lock_add_nocf addr:$dst, (i16 1)))]>,
 801                         OpSize16, LOCK;
 802     def LOCK_INC32m : I<0xFF, MRM0m, (outs), (ins i32mem:$dst),
 803                         "inc{l}\t$dst",
 804                         [(set EFLAGS, (X86lock_add_nocf addr:$dst, (i32 1)))]>,
 805                         OpSize32, LOCK;
 806     def LOCK_INC64m : RI<0xFF, MRM0m, (outs), (ins i64mem:$dst),
 807                          "inc{q}\t$dst",
 808                          [(set EFLAGS, (X86lock_add_nocf addr:$dst, (i64 1)))]>,
 809                          LOCK;
 810
 811     def LOCK_DEC8m  : I<0xFE, MRM1m, (outs), (ins i8mem :$dst),
 812                         "dec{b}\t$dst",
 813                         [(set EFLAGS, (X86lock_sub_nocf addr:$dst, (i8 1)))]>,
 814                         LOCK;
 815     def LOCK_DEC16m : I<0xFF, MRM1m, (outs), (ins i16mem:$dst),
 816                         "dec{w}\t$dst",
 817                         [(set EFLAGS, (X86lock_sub_nocf addr:$dst, (i16 1)))]>,
 818                         OpSize16, LOCK;
 819     def LOCK_DEC32m : I<0xFF, MRM1m, (outs), (ins i32mem:$dst),
 820                         "dec{l}\t$dst",
 821                         [(set EFLAGS, (X86lock_sub_nocf addr:$dst, (i32 1)))]>,
 822                         OpSize32, LOCK;
 823     def LOCK_DEC64m : RI<0xFF, MRM1m, (outs), (ins i64mem:$dst),
 824                          "dec{q}\t$dst",
 825                          [(set EFLAGS, (X86lock_sub_nocf addr:$dst, (i64 1)))]>,
 826                          LOCK;
 827   }
 828
 829   // Additional patterns for -1 constant.
 830   def : Pat<(X86lock_add addr:$dst, (i8  -1)), (LOCK_DEC8m  addr:$dst)>;
 831   def : Pat<(X86lock_add addr:$dst, (i16 -1)), (LOCK_DEC16m addr:$dst)>;
 832   def : Pat<(X86lock_add addr:$dst, (i32 -1)), (LOCK_DEC32m addr:$dst)>;
 833   def : Pat<(X86lock_add addr:$dst, (i64 -1)), (LOCK_DEC64m addr:$dst)>;
 834   def : Pat<(X86lock_sub addr:$dst, (i8  -1)), (LOCK_INC8m  addr:$dst)>;
 835   def : Pat<(X86lock_sub addr:$dst, (i16 -1)), (LOCK_INC16m addr:$dst)>;
 836   def : Pat<(X86lock_sub addr:$dst, (i32 -1)), (LOCK_INC32m addr:$dst)>;
 837   def : Pat<(X86lock_sub addr:$dst, (i64 -1)), (LOCK_INC64m addr:$dst)>;
 838 }
 839
 840 // Atomic compare and swap.
 841 multiclass LCMPXCHG_UnOp<bits<8> Opc, Format Form, string mnemonic,
 842                          SDPatternOperator frag, X86MemOperand x86memop> {
 843 let isCodeGenOnly = 1, usesCustomInserter = 1 in {
 844   def NAME : I<Opc, Form, (outs), (ins x86memop:$ptr),
 845                !strconcat(mnemonic, "\t$ptr"),
 846                [(frag addr:$ptr)]>, TB, LOCK;
 847 }
 848 }
 849
 850 multiclass LCMPXCHG_BinOp<bits<8> Opc8, bits<8> Opc, Format Form,
 851                           string mnemonic, SDPatternOperator frag> {
 852 let isCodeGenOnly = 1, SchedRW = [WriteCMPXCHGRMW] in {
 853   let Defs = [AL, EFLAGS], Uses = [AL] in
 854   def NAME#8  : I<Opc8, Form, (outs), (ins i8mem:$ptr, GR8:$swap),
 855                   !strconcat(mnemonic, "{b}\t{$swap, $ptr|$ptr, $swap}"),
 856                   [(frag addr:$ptr, GR8:$swap, 1)]>, TB, LOCK;
 857   let Defs = [AX, EFLAGS], Uses = [AX] in
 858   def NAME#16 : I<Opc, Form, (outs), (ins i16mem:$ptr, GR16:$swap),
 859                   !strconcat(mnemonic, "{w}\t{$swap, $ptr|$ptr, $swap}"),
 860                   [(frag addr:$ptr, GR16:$swap, 2)]>, TB, OpSize16, LOCK;
 861   let Defs = [EAX, EFLAGS], Uses = [EAX] in
 862   def NAME#32 : I<Opc, Form, (outs), (ins i32mem:$ptr, GR32:$swap),
 863                   !strconcat(mnemonic, "{l}\t{$swap, $ptr|$ptr, $swap}"),
 864                   [(frag addr:$ptr, GR32:$swap, 4)]>, TB, OpSize32, LOCK;
 865   let Defs = [RAX, EFLAGS], Uses = [RAX] in
 866   def NAME#64 : RI<Opc, Form, (outs), (ins i64mem:$ptr, GR64:$swap),
 867                    !strconcat(mnemonic, "{q}\t{$swap, $ptr|$ptr, $swap}"),
 868                    [(frag addr:$ptr, GR64:$swap, 8)]>, TB, LOCK;
 869 }
 870 }
 871
 872 let Defs = [EAX, EDX, EFLAGS], Uses = [EAX, EBX, ECX, EDX],
 873     Predicates = [HasCmpxchg8b], SchedRW = [WriteCMPXCHGRMW] in {
 874 defm LCMPXCHG8B : LCMPXCHG_UnOp<0xC7, MRM1m, "cmpxchg8b", X86cas8, i64mem>;
 875 }
 876
 877 // This pseudo must be used when the frame uses RBX as
 878 // the base pointer. Indeed, in such situation RBX is a reserved
 879 // register and the register allocator will ignore any use/def of
 880 // it. In other words, the register will not fix the clobbering of
 881 // RBX that will happen when setting the arguments for the instrucion.
 882 //
 883 // Unlike the actual related instuction, we mark that this one
 884 // defines EBX (instead of using EBX).
 885 // The rationale is that we will define RBX during the expansion of
 886 // the pseudo. The argument feeding EBX is ebx_input.
 887 //
 888 // The additional argument, $ebx_save, is a temporary register used to
 889 // save the value of RBX across the actual instruction.
 890 //
 891 // To make sure the register assigned to $ebx_save does not interfere with
 892 // the definition of the actual instruction, we use a definition $dst which
 893 // is tied to $rbx_save. That way, the live-range of $rbx_save spans across
 894 // the instruction and we are sure we will have a valid register to restore
 895 // the value of RBX.
 896 let Defs = [EAX, EDX, EBX, EFLAGS], Uses = [EAX, ECX, EDX],
 897     Predicates = [HasCmpxchg8b], SchedRW = [WriteCMPXCHGRMW],
 898     isCodeGenOnly = 1, isPseudo = 1, Constraints = "$ebx_save = $dst",
 899     usesCustomInserter = 1 in {
 900 def LCMPXCHG8B_SAVE_EBX :
 901     I<0, Pseudo, (outs GR32:$dst),
 902       (ins i64mem:$ptr, GR32:$ebx_input, GR32:$ebx_save),
 903       !strconcat("cmpxchg8b", "\t$ptr"),
 904       [(set GR32:$dst, (X86cas8save_ebx addr:$ptr, GR32:$ebx_input,
 905                                         GR32:$ebx_save))]>;
 906 }
 907
 908
 909 let Defs = [RAX, RDX, EFLAGS], Uses = [RAX, RBX, RCX, RDX],
 910     Predicates = [HasCmpxchg16b,In64BitMode], SchedRW = [WriteCMPXCHGRMW] in {
 911 defm LCMPXCHG16B : LCMPXCHG_UnOp<0xC7, MRM1m, "cmpxchg16b",
 912                                  X86cas16, i128mem>, REX_W;
 913 }
 914
 915 // Same as LCMPXCHG8B_SAVE_RBX but for the 16 Bytes variant.
 916 let Defs = [RAX, RDX, RBX, EFLAGS], Uses = [RAX, RCX, RDX],
 917     Predicates = [HasCmpxchg16b,In64BitMode], SchedRW = [WriteCMPXCHGRMW],
 918     isCodeGenOnly = 1, isPseudo = 1, Constraints = "$rbx_save = $dst",
 919     usesCustomInserter = 1 in {
 920 def LCMPXCHG16B_SAVE_RBX :
 921     I<0, Pseudo, (outs GR64:$dst),
 922       (ins i128mem:$ptr, GR64:$rbx_input, GR64:$rbx_save),
 923       !strconcat("cmpxchg16b", "\t$ptr"),
 924       [(set GR64:$dst, (X86cas16save_rbx addr:$ptr, GR64:$rbx_input,
 925                                                     GR64:$rbx_save))]>;
 926 }
 927
 928 defm LCMPXCHG : LCMPXCHG_BinOp<0xB0, 0xB1, MRMDestMem, "cmpxchg", X86cas>;
 929
 930 // Atomic exchange and add
 931 multiclass ATOMIC_LOAD_BINOP<bits<8> opc8, bits<8> opc, string mnemonic,
 932                              string frag> {
 933   let Constraints = "$val = $dst", Defs = [EFLAGS], isCodeGenOnly = 1,
 934       SchedRW = [WriteALURMW] in {
 935     def NAME#8  : I<opc8, MRMSrcMem, (outs GR8:$dst),
 936                     (ins GR8:$val, i8mem:$ptr),
 937                     !strconcat(mnemonic, "{b}\t{$val, $ptr|$ptr, $val}"),
 938                     [(set GR8:$dst,
 939                           (!cast<PatFrag>(frag # "_8") addr:$ptr, GR8:$val))]>;
 940     def NAME#16 : I<opc, MRMSrcMem, (outs GR16:$dst),
 941                     (ins GR16:$val, i16mem:$ptr),
 942                     !strconcat(mnemonic, "{w}\t{$val, $ptr|$ptr, $val}"),
 943                     [(set
 944                        GR16:$dst,
 945                        (!cast<PatFrag>(frag # "_16") addr:$ptr, GR16:$val))]>,
 946                     OpSize16;
 947     def NAME#32 : I<opc, MRMSrcMem, (outs GR32:$dst),
 948                     (ins GR32:$val, i32mem:$ptr),
 949                     !strconcat(mnemonic, "{l}\t{$val, $ptr|$ptr, $val}"),
 950                     [(set
 951                        GR32:$dst,
 952                        (!cast<PatFrag>(frag # "_32") addr:$ptr, GR32:$val))]>,
 953                     OpSize32;
 954     def NAME#64 : RI<opc, MRMSrcMem, (outs GR64:$dst),
 955                      (ins GR64:$val, i64mem:$ptr),
 956                      !strconcat(mnemonic, "{q}\t{$val, $ptr|$ptr, $val}"),
 957                      [(set
 958                         GR64:$dst,
 959                         (!cast<PatFrag>(frag # "_64") addr:$ptr, GR64:$val))]>;
 960   }
 961 }
 962
 963 defm LXADD : ATOMIC_LOAD_BINOP<0xc0, 0xc1, "xadd", "atomic_load_add">, TB, LOCK;
 964
 965 /* The following multiclass tries to make sure that in code like
 966  *    x.store (immediate op x.load(acquire), release)
 967  * and
 968  *    x.store (register op x.load(acquire), release)
 969  * an operation directly on memory is generated instead of wasting a register.
 970  * It is not automatic as atomic_store/load are only lowered to MOV instructions
 971  * extremely late to prevent them from being accidentally reordered in the backend
 972  * (see below the RELEASE_MOV* / ACQUIRE_MOV* pseudo-instructions)
 973  */
 974 multiclass RELEASE_BINOP_MI<string Name, SDNode op> {
 975   def : Pat<(atomic_store_8 addr:$dst,
 976              (op (atomic_load_8 addr:$dst), (i8 imm:$src))),
 977             (!cast<Instruction>(Name#"8mi") addr:$dst, imm:$src)>;
 978   def : Pat<(atomic_store_16 addr:$dst,
 979              (op (atomic_load_16 addr:$dst), (i16 imm:$src))),
 980             (!cast<Instruction>(Name#"16mi") addr:$dst, imm:$src)>;
 981   def : Pat<(atomic_store_32 addr:$dst,
 982              (op (atomic_load_32 addr:$dst), (i32 imm:$src))),
 983             (!cast<Instruction>(Name#"32mi") addr:$dst, imm:$src)>;
 984   def : Pat<(atomic_store_64 addr:$dst,
 985              (op (atomic_load_64 addr:$dst), (i64immSExt32:$src))),
 986             (!cast<Instruction>(Name#"64mi32") addr:$dst, (i64immSExt32:$src))>;
 987
 988   def : Pat<(atomic_store_8 addr:$dst,
 989              (op (atomic_load_8 addr:$dst), (i8 GR8:$src))),
 990             (!cast<Instruction>(Name#"8mr") addr:$dst, GR8:$src)>;
 991   def : Pat<(atomic_store_16 addr:$dst,
 992              (op (atomic_load_16 addr:$dst), (i16 GR16:$src))),
 993             (!cast<Instruction>(Name#"16mr") addr:$dst, GR16:$src)>;
 994   def : Pat<(atomic_store_32 addr:$dst,
 995              (op (atomic_load_32 addr:$dst), (i32 GR32:$src))),
 996             (!cast<Instruction>(Name#"32mr") addr:$dst, GR32:$src)>;
 997   def : Pat<(atomic_store_64 addr:$dst,
 998              (op (atomic_load_64 addr:$dst), (i64 GR64:$src))),
 999             (!cast<Instruction>(Name#"64mr") addr:$dst, GR64:$src)>;
1000 }
1001 defm : RELEASE_BINOP_MI<"ADD", add>;
1002 defm : RELEASE_BINOP_MI<"AND", and>;
1003 defm : RELEASE_BINOP_MI<"OR",  or>;
1004 defm : RELEASE_BINOP_MI<"XOR", xor>;
1005 defm : RELEASE_BINOP_MI<"SUB", sub>;
1006
1007 // Atomic load + floating point patterns.
1008 // FIXME: This could also handle SIMD operations with *ps and *pd instructions.
1009 multiclass ATOMIC_LOAD_FP_BINOP_MI<string Name, SDNode op> {
1010   def : Pat<(op FR32:$src1, (bitconvert (i32 (atomic_load_32 addr:$src2)))),
1011             (!cast<Instruction>(Name#"SSrm") FR32:$src1, addr:$src2)>,
1012             Requires<[UseSSE1]>;
1013   def : Pat<(op FR32:$src1, (bitconvert (i32 (atomic_load_32 addr:$src2)))),
1014             (!cast<Instruction>("V"#Name#"SSrm") FR32:$src1, addr:$src2)>,
1015             Requires<[UseAVX]>;
1016   def : Pat<(op FR32X:$src1, (bitconvert (i32 (atomic_load_32 addr:$src2)))),
1017             (!cast<Instruction>("V"#Name#"SSZrm") FR32X:$src1, addr:$src2)>,
1018             Requires<[HasAVX512]>;
1019
1020   def : Pat<(op FR64:$src1, (bitconvert (i64 (atomic_load_64 addr:$src2)))),
1021             (!cast<Instruction>(Name#"SDrm") FR64:$src1, addr:$src2)>,
1022             Requires<[UseSSE1]>;
1023   def : Pat<(op FR64:$src1, (bitconvert (i64 (atomic_load_64 addr:$src2)))),
1024             (!cast<Instruction>("V"#Name#"SDrm") FR64:$src1, addr:$src2)>,
1025             Requires<[UseAVX]>;
1026   def : Pat<(op FR64X:$src1, (bitconvert (i64 (atomic_load_64 addr:$src2)))),
1027             (!cast<Instruction>("V"#Name#"SDZrm") FR64X:$src1, addr:$src2)>,
1028             Requires<[HasAVX512]>;
1029 }
1030 defm : ATOMIC_LOAD_FP_BINOP_MI<"ADD", fadd>;
1031 // FIXME: Add fsub, fmul, fdiv, ...
1032
1033 multiclass RELEASE_UNOP<string Name, dag dag8, dag dag16, dag dag32,
1034                         dag dag64> {
1035   def : Pat<(atomic_store_8 addr:$dst, dag8),
1036             (!cast<Instruction>(Name#8m) addr:$dst)>;
1037   def : Pat<(atomic_store_16 addr:$dst, dag16),
1038             (!cast<Instruction>(Name#16m) addr:$dst)>;
1039   def : Pat<(atomic_store_32 addr:$dst, dag32),
1040             (!cast<Instruction>(Name#32m) addr:$dst)>;
1041   def : Pat<(atomic_store_64 addr:$dst, dag64),
1042             (!cast<Instruction>(Name#64m) addr:$dst)>;
1043 }
1044
1045 let Predicates = [UseIncDec] in {
1046   defm : RELEASE_UNOP<"INC",
1047       (add (atomic_load_8  addr:$dst), (i8 1)),
1048       (add (atomic_load_16 addr:$dst), (i16 1)),
1049       (add (atomic_load_32 addr:$dst), (i32 1)),
1050       (add (atomic_load_64 addr:$dst), (i64 1))>;
1051   defm : RELEASE_UNOP<"DEC",
1052       (add (atomic_load_8  addr:$dst), (i8 -1)),
1053       (add (atomic_load_16 addr:$dst), (i16 -1)),
1054       (add (atomic_load_32 addr:$dst), (i32 -1)),
1055       (add (atomic_load_64 addr:$dst), (i64 -1))>;
1056 }
1057
1058 defm : RELEASE_UNOP<"NEG",
1059     (ineg (i8 (atomic_load_8  addr:$dst))),
1060     (ineg (i16 (atomic_load_16 addr:$dst))),
1061     (ineg (i32 (atomic_load_32 addr:$dst))),
1062     (ineg (i64 (atomic_load_64 addr:$dst)))>;
1063 defm : RELEASE_UNOP<"NOT",
1064     (not (i8 (atomic_load_8  addr:$dst))),
1065     (not (i16 (atomic_load_16 addr:$dst))),
1066     (not (i32 (atomic_load_32 addr:$dst))),
1067     (not (i64 (atomic_load_64 addr:$dst)))>;
1068
1069 def : Pat<(atomic_store_8 addr:$dst, (i8 imm:$src)),
1070           (MOV8mi addr:$dst, imm:$src)>;
1071 def : Pat<(atomic_store_16 addr:$dst, (i16 imm:$src)),
1072           (MOV16mi addr:$dst, imm:$src)>;
1073 def : Pat<(atomic_store_32 addr:$dst, (i32 imm:$src)),
1074           (MOV32mi addr:$dst, imm:$src)>;
1075 def : Pat<(atomic_store_64 addr:$dst, (i64immSExt32:$src)),
1076           (MOV64mi32 addr:$dst, i64immSExt32:$src)>;
1077
1078 def : Pat<(atomic_store_8 addr:$dst, GR8:$src),
1079           (MOV8mr addr:$dst, GR8:$src)>;
1080 def : Pat<(atomic_store_16 addr:$dst, GR16:$src),
1081           (MOV16mr addr:$dst, GR16:$src)>;
1082 def : Pat<(atomic_store_32 addr:$dst, GR32:$src),
1083           (MOV32mr addr:$dst, GR32:$src)>;
1084 def : Pat<(atomic_store_64 addr:$dst, GR64:$src),
1085           (MOV64mr addr:$dst, GR64:$src)>;
1086
1087 def : Pat<(i8  (atomic_load_8 addr:$src)),  (MOV8rm addr:$src)>;
1088 def : Pat<(i16 (atomic_load_16 addr:$src)), (MOV16rm addr:$src)>;
1089 def : Pat<(i32 (atomic_load_32 addr:$src)), (MOV32rm addr:$src)>;
1090 def : Pat<(i64 (atomic_load_64 addr:$src)), (MOV64rm addr:$src)>;
1091
1092 // Floating point loads/stores.
1093 def : Pat<(atomic_store_32 addr:$dst, (i32 (bitconvert (f32 FR32:$src)))),
1094           (MOVSSmr addr:$dst, FR32:$src)>, Requires<[UseSSE1]>;
1095 def : Pat<(atomic_store_32 addr:$dst, (i32 (bitconvert (f32 FR32:$src)))),
1096           (VMOVSSmr addr:$dst, FR32:$src)>, Requires<[UseAVX]>;
1097 def : Pat<(atomic_store_32 addr:$dst, (i32 (bitconvert (f32 FR32:$src)))),
1098           (VMOVSSZmr addr:$dst, FR32:$src)>, Requires<[HasAVX512]>;
1099
1100 def : Pat<(atomic_store_64 addr:$dst, (i64 (bitconvert (f64 FR64:$src)))),
1101           (MOVSDmr addr:$dst, FR64:$src)>, Requires<[UseSSE2]>;
1102 def : Pat<(atomic_store_64 addr:$dst, (i64 (bitconvert (f64 FR64:$src)))),
1103           (VMOVSDmr addr:$dst, FR64:$src)>, Requires<[UseAVX]>;
1104 def : Pat<(atomic_store_64 addr:$dst, (i64 (bitconvert (f64 FR64:$src)))),
1105           (VMOVSDmr addr:$dst, FR64:$src)>, Requires<[HasAVX512]>;
1106
1107 def : Pat<(f32 (bitconvert (i32 (atomic_load_32 addr:$src)))),
1108           (MOVSSrm_alt addr:$src)>, Requires<[UseSSE1]>;
1109 def : Pat<(f32 (bitconvert (i32 (atomic_load_32 addr:$src)))),
1110           (VMOVSSrm_alt addr:$src)>, Requires<[UseAVX]>;
1111 def : Pat<(f32 (bitconvert (i32 (atomic_load_32 addr:$src)))),
1112           (VMOVSSZrm_alt addr:$src)>, Requires<[HasAVX512]>;
1113
1114 def : Pat<(f64 (bitconvert (i64 (atomic_load_64 addr:$src)))),
1115           (MOVSDrm_alt addr:$src)>, Requires<[UseSSE2]>;
1116 def : Pat<(f64 (bitconvert (i64 (atomic_load_64 addr:$src)))),
1117           (VMOVSDrm_alt addr:$src)>, Requires<[UseAVX]>;
1118 def : Pat<(f64 (bitconvert (i64 (atomic_load_64 addr:$src)))),
1119           (VMOVSDZrm_alt addr:$src)>, Requires<[HasAVX512]>;
1120
1121 //===----------------------------------------------------------------------===//
1122 // DAG Pattern Matching Rules
1123 //===----------------------------------------------------------------------===//
1124
1125 // Use AND/OR to store 0/-1 in memory when optimizing for minsize. This saves
1126 // binary size compared to a regular MOV, but it introduces an unnecessary
1127 // load, so is not suitable for regular or optsize functions.
1128 let Predicates = [OptForMinSize] in {
1129 def : Pat<(simple_store (i16 0), addr:$dst), (AND16mi8 addr:$dst, 0)>;
1130 def : Pat<(simple_store (i32 0), addr:$dst), (AND32mi8 addr:$dst, 0)>;
1131 def : Pat<(simple_store (i64 0), addr:$dst), (AND64mi8 addr:$dst, 0)>;
1132 def : Pat<(simple_store (i16 -1), addr:$dst), (OR16mi8 addr:$dst, -1)>;
1133 def : Pat<(simple_store (i32 -1), addr:$dst), (OR32mi8 addr:$dst, -1)>;
1134 def : Pat<(simple_store (i64 -1), addr:$dst), (OR64mi8 addr:$dst, -1)>;
1135 }
1136
1137 // In kernel code model, we can get the address of a label
1138 // into a register with 'movq'.  FIXME: This is a hack, the 'imm' predicate of
1139 // the MOV64ri32 should accept these.
1140 def : Pat<(i64 (X86Wrapper tconstpool  :$dst)),
1141           (MOV64ri32 tconstpool  :$dst)>, Requires<[KernelCode]>;
1142 def : Pat<(i64 (X86Wrapper tjumptable  :$dst)),
1143           (MOV64ri32 tjumptable  :$dst)>, Requires<[KernelCode]>;
1144 def : Pat<(i64 (X86Wrapper tglobaladdr :$dst)),
1145           (MOV64ri32 tglobaladdr :$dst)>, Requires<[KernelCode]>;
1146 def : Pat<(i64 (X86Wrapper texternalsym:$dst)),
1147           (MOV64ri32 texternalsym:$dst)>, Requires<[KernelCode]>;
1148 def : Pat<(i64 (X86Wrapper mcsym:$dst)),
1149           (MOV64ri32 mcsym:$dst)>, Requires<[KernelCode]>;
1150 def : Pat<(i64 (X86Wrapper tblockaddress:$dst)),
1151           (MOV64ri32 tblockaddress:$dst)>, Requires<[KernelCode]>;
1152
1153 // If we have small model and -static mode, it is safe to store global addresses
1154 // directly as immediates.  FIXME: This is really a hack, the 'imm' predicate
1155 // for MOV64mi32 should handle this sort of thing.
1156 def : Pat<(store (i64 (X86Wrapper tconstpool:$src)), addr:$dst),
1157           (MOV64mi32 addr:$dst, tconstpool:$src)>,
1158           Requires<[NearData, IsNotPIC]>;
1159 def : Pat<(store (i64 (X86Wrapper tjumptable:$src)), addr:$dst),
1160           (MOV64mi32 addr:$dst, tjumptable:$src)>,
1161           Requires<[NearData, IsNotPIC]>;
1162 def : Pat<(store (i64 (X86Wrapper tglobaladdr:$src)), addr:$dst),
1163           (MOV64mi32 addr:$dst, tglobaladdr:$src)>,
1164           Requires<[NearData, IsNotPIC]>;
1165 def : Pat<(store (i64 (X86Wrapper texternalsym:$src)), addr:$dst),
1166           (MOV64mi32 addr:$dst, texternalsym:$src)>,
1167           Requires<[NearData, IsNotPIC]>;
1168 def : Pat<(store (i64 (X86Wrapper mcsym:$src)), addr:$dst),
1169           (MOV64mi32 addr:$dst, mcsym:$src)>,
1170           Requires<[NearData, IsNotPIC]>;
1171 def : Pat<(store (i64 (X86Wrapper tblockaddress:$src)), addr:$dst),
1172           (MOV64mi32 addr:$dst, tblockaddress:$src)>,
1173           Requires<[NearData, IsNotPIC]>;
1174
1175 def : Pat<(i32 (X86RecoverFrameAlloc mcsym:$dst)), (MOV32ri mcsym:$dst)>;
1176 def : Pat<(i64 (X86RecoverFrameAlloc mcsym:$dst)), (MOV64ri mcsym:$dst)>;
1177
1178 // Calls
1179
1180 // tls has some funny stuff here...
1181 // This corresponds to movabs $foo@tpoff, %rax
1182 def : Pat<(i64 (X86Wrapper tglobaltlsaddr :$dst)),
1183           (MOV64ri32 tglobaltlsaddr :$dst)>;
1184 // This corresponds to add $foo@tpoff, %rax
1185 def : Pat<(add GR64:$src1, (X86Wrapper tglobaltlsaddr :$dst)),
1186           (ADD64ri32 GR64:$src1, tglobaltlsaddr :$dst)>;
1187
1188
1189 // Direct PC relative function call for small code model. 32-bit displacement
1190 // sign extended to 64-bit.
1191 def : Pat<(X86call (i64 tglobaladdr:$dst)),
1192           (CALL64pcrel32 tglobaladdr:$dst)>;
1193 def : Pat<(X86call (i64 texternalsym:$dst)),
1194           (CALL64pcrel32 texternalsym:$dst)>;
1195
1196 // Tailcall stuff. The TCRETURN instructions execute after the epilog, so they
1197 // can never use callee-saved registers. That is the purpose of the GR64_TC
1198 // register classes.
1199 //
1200 // The only volatile register that is never used by the calling convention is
1201 // %r11. This happens when calling a vararg function with 6 arguments.
1202 //
1203 // Match an X86tcret that uses less than 7 volatile registers.
1204 def X86tcret_6regs : PatFrag<(ops node:$ptr, node:$off),
1205                              (X86tcret node:$ptr, node:$off), [{
1206   // X86tcret args: (*chain, ptr, imm, regs..., glue)
1207   unsigned NumRegs = 0;
1208   for (unsigned i = 3, e = N->getNumOperands(); i != e; ++i)
1209     if (isa<RegisterSDNode>(N->getOperand(i)) && ++NumRegs > 6)
1210       return false;
1211   return true;
1212 }]>;
1213
1214 def : Pat<(X86tcret ptr_rc_tailcall:$dst, imm:$off),
1215           (TCRETURNri ptr_rc_tailcall:$dst, imm:$off)>,
1216           Requires<[Not64BitMode, NotUseIndirectThunkCalls]>;
1217
1218 // FIXME: This is disabled for 32-bit PIC mode because the global base
1219 // register which is part of the address mode may be assigned a
1220 // callee-saved register.
1221 def : Pat<(X86tcret (load addr:$dst), imm:$off),
1222           (TCRETURNmi addr:$dst, imm:$off)>,
1223           Requires<[Not64BitMode, IsNotPIC, NotUseIndirectThunkCalls]>;
1224
1225 def : Pat<(X86tcret (i32 tglobaladdr:$dst), imm:$off),
1226           (TCRETURNdi tglobaladdr:$dst, imm:$off)>,
1227           Requires<[NotLP64]>;
1228
1229 def : Pat<(X86tcret (i32 texternalsym:$dst), imm:$off),
1230           (TCRETURNdi texternalsym:$dst, imm:$off)>,
1231           Requires<[NotLP64]>;
1232
1233 def : Pat<(X86tcret ptr_rc_tailcall:$dst, imm:$off),
1234           (TCRETURNri64 ptr_rc_tailcall:$dst, imm:$off)>,
1235           Requires<[In64BitMode, NotUseIndirectThunkCalls]>;
1236
1237 // Don't fold loads into X86tcret requiring more than 6 regs.
1238 // There wouldn't be enough scratch registers for base+index.
1239 def : Pat<(X86tcret_6regs (load addr:$dst), imm:$off),
1240           (TCRETURNmi64 addr:$dst, imm:$off)>,
1241           Requires<[In64BitMode, NotUseIndirectThunkCalls]>;
1242
1243 def : Pat<(X86tcret ptr_rc_tailcall:$dst, imm:$off),
1244           (INDIRECT_THUNK_TCRETURN64 ptr_rc_tailcall:$dst, imm:$off)>,
1245           Requires<[In64BitMode, UseIndirectThunkCalls]>;
1246
1247 def : Pat<(X86tcret ptr_rc_tailcall:$dst, imm:$off),
1248           (INDIRECT_THUNK_TCRETURN32 ptr_rc_tailcall:$dst, imm:$off)>,
1249           Requires<[Not64BitMode, UseIndirectThunkCalls]>;
1250
1251 def : Pat<(X86tcret (i64 tglobaladdr:$dst), imm:$off),
1252           (TCRETURNdi64 tglobaladdr:$dst, imm:$off)>,
1253           Requires<[IsLP64]>;
1254
1255 def : Pat<(X86tcret (i64 texternalsym:$dst), imm:$off),
1256           (TCRETURNdi64 texternalsym:$dst, imm:$off)>,
1257           Requires<[IsLP64]>;
1258
1259 // Normal calls, with various flavors of addresses.
1260 def : Pat<(X86call (i32 tglobaladdr:$dst)),
1261           (CALLpcrel32 tglobaladdr:$dst)>;
1262 def : Pat<(X86call (i32 texternalsym:$dst)),
1263           (CALLpcrel32 texternalsym:$dst)>;
1264 def : Pat<(X86call (i32 imm:$dst)),
1265           (CALLpcrel32 imm:$dst)>, Requires<[CallImmAddr]>;
1266
1267 // Comparisons.
1268
1269 // TEST R,R is smaller than CMP R,0
1270 def : Pat<(X86cmp GR8:$src1, 0),
1271           (TEST8rr GR8:$src1, GR8:$src1)>;
1272 def : Pat<(X86cmp GR16:$src1, 0),
1273           (TEST16rr GR16:$src1, GR16:$src1)>;
1274 def : Pat<(X86cmp GR32:$src1, 0),
1275           (TEST32rr GR32:$src1, GR32:$src1)>;
1276 def : Pat<(X86cmp GR64:$src1, 0),
1277           (TEST64rr GR64:$src1, GR64:$src1)>;
1278
1279 // zextload bool -> zextload byte
1280 // i1 stored in one byte in zero-extended form.
1281 // Upper bits cleanup should be executed before Store.
1282 def : Pat<(zextloadi8i1  addr:$src), (MOV8rm addr:$src)>;
1283 def : Pat<(zextloadi16i1 addr:$src),
1284           (EXTRACT_SUBREG (MOVZX32rm8 addr:$src), sub_16bit)>;
1285 def : Pat<(zextloadi32i1 addr:$src), (MOVZX32rm8 addr:$src)>;
1286 def : Pat<(zextloadi64i1 addr:$src),
1287           (SUBREG_TO_REG (i64 0), (MOVZX32rm8 addr:$src), sub_32bit)>;
1288
1289 // extload bool -> extload byte
1290 // When extloading from 16-bit and smaller memory locations into 64-bit
1291 // registers, use zero-extending loads so that the entire 64-bit register is
1292 // defined, avoiding partial-register updates.
1293
1294 def : Pat<(extloadi8i1 addr:$src),   (MOV8rm      addr:$src)>;
1295 def : Pat<(extloadi16i1 addr:$src),
1296           (EXTRACT_SUBREG (MOVZX32rm8 addr:$src), sub_16bit)>;
1297 def : Pat<(extloadi32i1 addr:$src),  (MOVZX32rm8  addr:$src)>;
1298 def : Pat<(extloadi16i8 addr:$src),
1299           (EXTRACT_SUBREG (MOVZX32rm8 addr:$src), sub_16bit)>;
1300 def : Pat<(extloadi32i8 addr:$src),  (MOVZX32rm8  addr:$src)>;
1301 def : Pat<(extloadi32i16 addr:$src), (MOVZX32rm16 addr:$src)>;
1302
1303 // For other extloads, use subregs, since the high contents of the register are
1304 // defined after an extload.
1305 // NOTE: The extloadi64i32 pattern needs to be first as it will try to form
1306 // 32-bit loads for 4 byte aligned i8/i16 loads.
1307 def : Pat<(extloadi64i32 addr:$src),
1308           (SUBREG_TO_REG (i64 0), (MOV32rm addr:$src), sub_32bit)>;
1309 def : Pat<(extloadi64i1 addr:$src),
1310           (SUBREG_TO_REG (i64 0), (MOVZX32rm8 addr:$src), sub_32bit)>;
1311 def : Pat<(extloadi64i8 addr:$src),
1312           (SUBREG_TO_REG (i64 0), (MOVZX32rm8 addr:$src), sub_32bit)>;
1313 def : Pat<(extloadi64i16 addr:$src),
1314           (SUBREG_TO_REG (i64 0), (MOVZX32rm16 addr:$src), sub_32bit)>;
1315
1316 // anyext. Define these to do an explicit zero-extend to
1317 // avoid partial-register updates.
1318 def : Pat<(i16 (anyext GR8 :$src)), (EXTRACT_SUBREG
1319                                      (MOVZX32rr8 GR8 :$src), sub_16bit)>;
1320 def : Pat<(i32 (anyext GR8 :$src)), (MOVZX32rr8  GR8 :$src)>;
1321
1322 // Except for i16 -> i32 since isel expect i16 ops to be promoted to i32.
1323 def : Pat<(i32 (anyext GR16:$src)),
1324           (INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR16:$src, sub_16bit)>;
1325
1326 def : Pat<(i64 (anyext GR8 :$src)),
1327           (SUBREG_TO_REG (i64 0), (MOVZX32rr8  GR8  :$src), sub_32bit)>;
1328 def : Pat<(i64 (anyext GR16:$src)),
1329           (SUBREG_TO_REG (i64 0), (MOVZX32rr16 GR16 :$src), sub_32bit)>;
1330 def : Pat<(i64 (anyext GR32:$src)),
1331           (INSERT_SUBREG (i64 (IMPLICIT_DEF)), GR32:$src, sub_32bit)>;
1332
1333 // If this is an anyext of the remainder of an 8-bit sdivrem, use a MOVSX
1334 // instead of a MOVZX. The sdivrem lowering will emit emit a MOVSX to move
1335 // %ah to the lower byte of a register. By using a MOVSX here we allow a
1336 // post-isel peephole to merge the two MOVSX instructions into one.
1337 def anyext_sdiv : PatFrag<(ops node:$lhs), (anyext node:$lhs),[{
1338   return (N->getOperand(0).getOpcode() == ISD::SDIVREM &&
1339           N->getOperand(0).getResNo() == 1);
1340 }]>;
1341 def : Pat<(i32 (anyext_sdiv GR8:$src)), (MOVSX32rr8 GR8:$src)>;
1342
1343 // Any instruction that defines a 32-bit result leaves the high half of the
1344 // register. Truncate can be lowered to EXTRACT_SUBREG. CopyFromReg may
1345 // be copying from a truncate. Any other 32-bit operation will zero-extend
1346 // up to 64 bits. AssertSext/AssertZext aren't saying anything about the upper
1347 // 32 bits, they're probably just qualifying a CopyFromReg.
1348 def def32 : PatLeaf<(i32 GR32:$src), [{
1349   return N->getOpcode() != ISD::TRUNCATE &&
1350          N->getOpcode() != TargetOpcode::EXTRACT_SUBREG &&
1351          N->getOpcode() != ISD::CopyFromReg &&
1352          N->getOpcode() != ISD::AssertSext &&
1353          N->getOpcode() != ISD::AssertZext;
1354 }]>;
1355
1356 // In the case of a 32-bit def that is known to implicitly zero-extend,
1357 // we can use a SUBREG_TO_REG.
1358 def : Pat<(i64 (zext def32:$src)),
1359           (SUBREG_TO_REG (i64 0), GR32:$src, sub_32bit)>;
1360 def : Pat<(i64 (and (anyext def32:$src), 0x00000000FFFFFFFF)),
1361           (SUBREG_TO_REG (i64 0), GR32:$src, sub_32bit)>;
1362
1363 //===----------------------------------------------------------------------===//
1364 // Pattern match OR as ADD
1365 //===----------------------------------------------------------------------===//
1366
1367 // If safe, we prefer to pattern match OR as ADD at isel time. ADD can be
1368 // 3-addressified into an LEA instruction to avoid copies.  However, we also
1369 // want to finally emit these instructions as an or at the end of the code
1370 // generator to make the generated code easier to read.  To do this, we select
1371 // into "disjoint bits" pseudo ops.
1372
1373 // Treat an 'or' node is as an 'add' if the or'ed bits are known to be zero.
1374 def or_is_add : PatFrag<(ops node:$lhs, node:$rhs), (or node:$lhs, node:$rhs),[{
1375   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N->getOperand(1)))
1376     return CurDAG->MaskedValueIsZero(N->getOperand(0), CN->getAPIntValue());
1377
1378   KnownBits Known0 = CurDAG->computeKnownBits(N->getOperand(0), 0);
1379   KnownBits Known1 = CurDAG->computeKnownBits(N->getOperand(1), 0);
1380   return (~Known0.Zero & ~Known1.Zero) == 0;
1381 }]>;
1382
1383
1384 // (or x1, x2) -> (add x1, x2) if two operands are known not to share bits.
1385 // Try this before the selecting to OR.
1386 let SchedRW = [WriteALU] in {
1387
1388 let isConvertibleToThreeAddress = 1, isPseudo = 1,
1389     Constraints = "$src1 = $dst", Defs = [EFLAGS] in {
1390 let isCommutable = 1 in {
1391 def ADD8rr_DB   : I<0, Pseudo, (outs GR8:$dst), (ins GR8:$src1, GR8:$src2),
1392                     "", // orb/addb REG, REG
1393                     [(set GR8:$dst, (or_is_add GR8:$src1, GR8:$src2))]>;
1394 def ADD16rr_DB  : I<0, Pseudo, (outs GR16:$dst), (ins GR16:$src1, GR16:$src2),
1395                     "", // orw/addw REG, REG
1396                     [(set GR16:$dst, (or_is_add GR16:$src1, GR16:$src2))]>;
1397 def ADD32rr_DB  : I<0, Pseudo, (outs GR32:$dst), (ins GR32:$src1, GR32:$src2),
1398                     "", // orl/addl REG, REG
1399                     [(set GR32:$dst, (or_is_add GR32:$src1, GR32:$src2))]>;
1400 def ADD64rr_DB  : I<0, Pseudo, (outs GR64:$dst), (ins GR64:$src1, GR64:$src2),
1401                     "", // orq/addq REG, REG
1402                     [(set GR64:$dst, (or_is_add GR64:$src1, GR64:$src2))]>;
1403 } // isCommutable
1404
1405 // NOTE: These are order specific, we want the ri8 forms to be listed
1406 // first so that they are slightly preferred to the ri forms.
1407
1408 def ADD8ri_DB :   I<0, Pseudo,
1409                     (outs GR8:$dst), (ins GR8:$src1, i8imm:$src2),
1410                     "", // orb/addb REG, imm8
1411                     [(set GR8:$dst, (or_is_add GR8:$src1, imm:$src2))]>;
1412 def ADD16ri8_DB : I<0, Pseudo,
1413                     (outs GR16:$dst), (ins GR16:$src1, i16i8imm:$src2),
1414                     "", // orw/addw REG, imm8
1415                     [(set GR16:$dst,(or_is_add GR16:$src1,i16immSExt8:$src2))]>;
1416 def ADD16ri_DB  : I<0, Pseudo, (outs GR16:$dst), (ins GR16:$src1, i16imm:$src2),
1417                     "", // orw/addw REG, imm
1418                     [(set GR16:$dst, (or_is_add GR16:$src1, imm:$src2))]>;
1419
1420 def ADD32ri8_DB : I<0, Pseudo,
1421                     (outs GR32:$dst), (ins GR32:$src1, i32i8imm:$src2),
1422                     "", // orl/addl REG, imm8
1423                     [(set GR32:$dst,(or_is_add GR32:$src1,i32immSExt8:$src2))]>;
1424 def ADD32ri_DB  : I<0, Pseudo, (outs GR32:$dst), (ins GR32:$src1, i32imm:$src2),
1425                     "", // orl/addl REG, imm
1426                     [(set GR32:$dst, (or_is_add GR32:$src1, imm:$src2))]>;
1427
1428
1429 def ADD64ri8_DB : I<0, Pseudo,
1430                     (outs GR64:$dst), (ins GR64:$src1, i64i8imm:$src2),
1431                     "", // orq/addq REG, imm8
1432                     [(set GR64:$dst, (or_is_add GR64:$src1,
1433                                                 i64immSExt8:$src2))]>;
1434 def ADD64ri32_DB : I<0, Pseudo,
1435                      (outs GR64:$dst), (ins GR64:$src1, i64i32imm:$src2),
1436                      "", // orq/addq REG, imm
1437                      [(set GR64:$dst, (or_is_add GR64:$src1,
1438                                                  i64immSExt32:$src2))]>;
1439 }
1440 } // AddedComplexity, SchedRW
1441
1442 //===----------------------------------------------------------------------===//
1443 // Pattern match SUB as XOR
1444 //===----------------------------------------------------------------------===//
1445
1446 // An immediate in the LHS of a subtract can't be encoded in the instruction.
1447 // If there is no possibility of a borrow we can use an XOR instead of a SUB
1448 // to enable the immediate to be folded.
1449 // TODO: Move this to a DAG combine?
1450
1451 def sub_is_xor : PatFrag<(ops node:$lhs, node:$rhs), (sub node:$lhs, node:$rhs),[{
1452   if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N->getOperand(0))) {
1453     KnownBits Known = CurDAG->computeKnownBits(N->getOperand(1));
1454
1455     // If all possible ones in the RHS are set in the LHS then there can't be
1456     // a borrow and we can use xor.
1457     return (~Known.Zero).isSubsetOf(CN->getAPIntValue());
1458   }
1459
1460   return false;
1461 }]>;
1462
1463 let AddedComplexity = 5 in {
1464 def : Pat<(sub_is_xor imm:$src2, GR8:$src1),
1465           (XOR8ri GR8:$src1, imm:$src2)>;
1466 def : Pat<(sub_is_xor i16immSExt8:$src2, GR16:$src1),
1467           (XOR16ri8 GR16:$src1, i16immSExt8:$src2)>;
1468 def : Pat<(sub_is_xor imm:$src2, GR16:$src1),
1469           (XOR16ri GR16:$src1, imm:$src2)>;
1470 def : Pat<(sub_is_xor i32immSExt8:$src2, GR32:$src1),
1471           (XOR32ri8 GR32:$src1, i32immSExt8:$src2)>;
1472 def : Pat<(sub_is_xor imm:$src2, GR32:$src1),
1473           (XOR32ri GR32:$src1, imm:$src2)>;
1474 def : Pat<(sub_is_xor i64immSExt8:$src2, GR64:$src1),
1475           (XOR64ri8 GR64:$src1, i64immSExt8:$src2)>;
1476 def : Pat<(sub_is_xor i64immSExt32:$src2, GR64:$src1),
1477           (XOR64ri32 GR64:$src1, i64immSExt32:$src2)>;
1478 }
1479
1480 //===----------------------------------------------------------------------===//
1481 // Some peepholes
1482 //===----------------------------------------------------------------------===//
1483
1484 // Odd encoding trick: -128 fits into an 8-bit immediate field while
1485 // +128 doesn't, so in this special case use a sub instead of an add.
1486 def : Pat<(add GR16:$src1, 128),
1487           (SUB16ri8 GR16:$src1, -128)>;
1488 def : Pat<(store (add (loadi16 addr:$dst), 128), addr:$dst),
1489           (SUB16mi8 addr:$dst, -128)>;
1490
1491 def : Pat<(add GR32:$src1, 128),
1492           (SUB32ri8 GR32:$src1, -128)>;
1493 def : Pat<(store (add (loadi32 addr:$dst), 128), addr:$dst),
1494           (SUB32mi8 addr:$dst, -128)>;
1495
1496 def : Pat<(add GR64:$src1, 128),
1497           (SUB64ri8 GR64:$src1, -128)>;
1498 def : Pat<(store (add (loadi64 addr:$dst), 128), addr:$dst),
1499           (SUB64mi8 addr:$dst, -128)>;
1500
1501 def : Pat<(X86add_flag_nocf GR16:$src1, 128),
1502           (SUB16ri8 GR16:$src1, -128)>;
1503 def : Pat<(X86add_flag_nocf GR32:$src1, 128),
1504           (SUB32ri8 GR32:$src1, -128)>;
1505 def : Pat<(X86add_flag_nocf GR64:$src1, 128),
1506           (SUB64ri8 GR64:$src1, -128)>;
1507
1508 // The same trick applies for 32-bit immediate fields in 64-bit
1509 // instructions.
1510 def : Pat<(add GR64:$src1, 0x0000000080000000),
1511           (SUB64ri32 GR64:$src1, 0xffffffff80000000)>;
1512 def : Pat<(store (add (loadi64 addr:$dst), 0x0000000080000000), addr:$dst),
1513           (SUB64mi32 addr:$dst, 0xffffffff80000000)>;
1514
1515 def : Pat<(X86add_flag_nocf GR64:$src1, 0x0000000080000000),
1516           (SUB64ri32 GR64:$src1, 0xffffffff80000000)>;
1517
1518 // To avoid needing to materialize an immediate in a register, use a 32-bit and
1519 // with implicit zero-extension instead of a 64-bit and if the immediate has at
1520 // least 32 bits of leading zeros. If in addition the last 32 bits can be
1521 // represented with a sign extension of a 8 bit constant, use that.
1522 // This can also reduce instruction size by eliminating the need for the REX
1523 // prefix.
1524
1525 // AddedComplexity is needed to give priority over i64immSExt8 and i64immSExt32.
1526 let AddedComplexity = 1 in {
1527 def : Pat<(and GR64:$src, i64immZExt32SExt8:$imm),
1528           (SUBREG_TO_REG
1529             (i64 0),
1530             (AND32ri8
1531               (EXTRACT_SUBREG GR64:$src, sub_32bit),
1532               (i32 (GetLo32XForm imm:$imm))),
1533             sub_32bit)>;
1534
1535 def : Pat<(and GR64:$src, i64immZExt32:$imm),
1536           (SUBREG_TO_REG
1537             (i64 0),
1538             (AND32ri
1539               (EXTRACT_SUBREG GR64:$src, sub_32bit),
1540               (i32 (GetLo32XForm imm:$imm))),
1541             sub_32bit)>;
1542 } // AddedComplexity = 1
1543
1544
1545 // AddedComplexity is needed due to the increased complexity on the
1546 // i64immZExt32SExt8 and i64immZExt32 patterns above. Applying this to all
1547 // the MOVZX patterns keeps thems together in DAGIsel tables.
1548 let AddedComplexity = 1 in {
1549 // r & (2^16-1) ==> movz
1550 def : Pat<(and GR32:$src1, 0xffff),
1551           (MOVZX32rr16 (EXTRACT_SUBREG GR32:$src1, sub_16bit))>;
1552 // r & (2^8-1) ==> movz
1553 def : Pat<(and GR32:$src1, 0xff),
1554           (MOVZX32rr8 (EXTRACT_SUBREG GR32:$src1, sub_8bit))>;
1555 // r & (2^8-1) ==> movz
1556 def : Pat<(and GR16:$src1, 0xff),
1557            (EXTRACT_SUBREG (MOVZX32rr8 (EXTRACT_SUBREG GR16:$src1, sub_8bit)),
1558              sub_16bit)>;
1559
1560 // r & (2^32-1) ==> movz
1561 def : Pat<(and GR64:$src, 0x00000000FFFFFFFF),
1562           (SUBREG_TO_REG (i64 0),
1563                          (MOV32rr (EXTRACT_SUBREG GR64:$src, sub_32bit)),
1564                          sub_32bit)>;
1565 // r & (2^16-1) ==> movz
1566 def : Pat<(and GR64:$src, 0xffff),
1567           (SUBREG_TO_REG (i64 0),
1568                       (MOVZX32rr16 (i16 (EXTRACT_SUBREG GR64:$src, sub_16bit))),
1569                       sub_32bit)>;
1570 // r & (2^8-1) ==> movz
1571 def : Pat<(and GR64:$src, 0xff),
1572           (SUBREG_TO_REG (i64 0),
1573                          (MOVZX32rr8 (i8 (EXTRACT_SUBREG GR64:$src, sub_8bit))),
1574                          sub_32bit)>;
1575 } // AddedComplexity = 1
1576
1577
1578 // Try to use BTS/BTR/BTC for single bit operations on the upper 32-bits.
1579
1580 def BTRXForm : SDNodeXForm<imm, [{
1581   // Transformation function: Find the lowest 0.
1582   return getI64Imm((uint8_t)N->getAPIntValue().countTrailingOnes(), SDLoc(N));
1583 }]>;
1584
1585 def BTCBTSXForm : SDNodeXForm<imm, [{
1586   // Transformation function: Find the lowest 1.
1587   return getI64Imm((uint8_t)N->getAPIntValue().countTrailingZeros(), SDLoc(N));
1588 }]>;
1589
1590 def BTRMask64 : ImmLeaf<i64, [{
1591   return !isUInt<32>(Imm) && !isInt<32>(Imm) && isPowerOf2_64(~Imm);
1592 }]>;
1593
1594 def BTCBTSMask64 : ImmLeaf<i64, [{
1595   return !isInt<32>(Imm) && isPowerOf2_64(Imm);
1596 }]>;
1597
1598 // For now only do this for optsize.
1599 let AddedComplexity = 1, Predicates=[OptForSize] in {
1600   def : Pat<(and GR64:$src1, BTRMask64:$mask),
1601             (BTR64ri8 GR64:$src1, (BTRXForm imm:$mask))>;
1602   def : Pat<(or GR64:$src1, BTCBTSMask64:$mask),
1603             (BTS64ri8 GR64:$src1, (BTCBTSXForm imm:$mask))>;
1604   def : Pat<(xor GR64:$src1, BTCBTSMask64:$mask),
1605             (BTC64ri8 GR64:$src1, (BTCBTSXForm imm:$mask))>;
1606 }
1607
1608
1609 // sext_inreg patterns
1610 def : Pat<(sext_inreg GR32:$src, i16),
1611           (MOVSX32rr16 (EXTRACT_SUBREG GR32:$src, sub_16bit))>;
1612 def : Pat<(sext_inreg GR32:$src, i8),
1613           (MOVSX32rr8 (EXTRACT_SUBREG GR32:$src, sub_8bit))>;
1614
1615 def : Pat<(sext_inreg GR16:$src, i8),
1616            (EXTRACT_SUBREG (MOVSX32rr8 (EXTRACT_SUBREG GR16:$src, sub_8bit)),
1617              sub_16bit)>;
1618
1619 def : Pat<(sext_inreg GR64:$src, i32),
1620           (MOVSX64rr32 (EXTRACT_SUBREG GR64:$src, sub_32bit))>;
1621 def : Pat<(sext_inreg GR64:$src, i16),
1622           (MOVSX64rr16 (EXTRACT_SUBREG GR64:$src, sub_16bit))>;
1623 def : Pat<(sext_inreg GR64:$src, i8),
1624           (MOVSX64rr8 (EXTRACT_SUBREG GR64:$src, sub_8bit))>;
1625
1626 // sext, sext_load, zext, zext_load
1627 def: Pat<(i16 (sext GR8:$src)),
1628           (EXTRACT_SUBREG (MOVSX32rr8 GR8:$src), sub_16bit)>;
1629 def: Pat<(sextloadi16i8 addr:$src),
1630           (EXTRACT_SUBREG (MOVSX32rm8 addr:$src), sub_16bit)>;
1631 def: Pat<(i16 (zext GR8:$src)),
1632           (EXTRACT_SUBREG (MOVZX32rr8 GR8:$src), sub_16bit)>;
1633 def: Pat<(zextloadi16i8 addr:$src),
1634           (EXTRACT_SUBREG (MOVZX32rm8 addr:$src), sub_16bit)>;
1635
1636 // trunc patterns
1637 def : Pat<(i16 (trunc GR32:$src)),
1638           (EXTRACT_SUBREG GR32:$src, sub_16bit)>;
1639 def : Pat<(i8 (trunc GR32:$src)),
1640           (EXTRACT_SUBREG (i32 (COPY_TO_REGCLASS GR32:$src, GR32_ABCD)),
1641                           sub_8bit)>,
1642       Requires<[Not64BitMode]>;
1643 def : Pat<(i8 (trunc GR16:$src)),
1644           (EXTRACT_SUBREG (i16 (COPY_TO_REGCLASS GR16:$src, GR16_ABCD)),
1645                           sub_8bit)>,
1646       Requires<[Not64BitMode]>;
1647 def : Pat<(i32 (trunc GR64:$src)),
1648           (EXTRACT_SUBREG GR64:$src, sub_32bit)>;
1649 def : Pat<(i16 (trunc GR64:$src)),
1650           (EXTRACT_SUBREG GR64:$src, sub_16bit)>;
1651 def : Pat<(i8 (trunc GR64:$src)),
1652           (EXTRACT_SUBREG GR64:$src, sub_8bit)>;
1653 def : Pat<(i8 (trunc GR32:$src)),
1654           (EXTRACT_SUBREG GR32:$src, sub_8bit)>,
1655       Requires<[In64BitMode]>;
1656 def : Pat<(i8 (trunc GR16:$src)),
1657           (EXTRACT_SUBREG GR16:$src, sub_8bit)>,
1658       Requires<[In64BitMode]>;
1659
1660 def immff00_ffff  : ImmLeaf<i32, [{
1661   return Imm >= 0xff00 && Imm <= 0xffff;
1662 }]>;
1663
1664 // h-register tricks
1665 def : Pat<(i8 (trunc (srl_su GR16:$src, (i8 8)))),
1666           (EXTRACT_SUBREG GR16:$src, sub_8bit_hi)>,
1667       Requires<[Not64BitMode]>;
1668 def : Pat<(i8 (trunc (srl_su (i32 (anyext GR16:$src)), (i8 8)))),
1669           (EXTRACT_SUBREG GR16:$src, sub_8bit_hi)>,
1670       Requires<[Not64BitMode]>;
1671 def : Pat<(i8 (trunc (srl_su GR32:$src, (i8 8)))),
1672           (EXTRACT_SUBREG GR32:$src, sub_8bit_hi)>,
1673       Requires<[Not64BitMode]>;
1674 def : Pat<(srl GR16:$src, (i8 8)),
1675           (EXTRACT_SUBREG
1676             (MOVZX32rr8_NOREX (EXTRACT_SUBREG GR16:$src, sub_8bit_hi)),
1677             sub_16bit)>;
1678 def : Pat<(i32 (zext (srl_su GR16:$src, (i8 8)))),
1679           (MOVZX32rr8_NOREX (EXTRACT_SUBREG GR16:$src, sub_8bit_hi))>;
1680 def : Pat<(i32 (anyext (srl_su GR16:$src, (i8 8)))),
1681           (MOVZX32rr8_NOREX (EXTRACT_SUBREG GR16:$src, sub_8bit_hi))>;
1682 def : Pat<(and (srl_su GR32:$src, (i8 8)), (i32 255)),
1683           (MOVZX32rr8_NOREX (EXTRACT_SUBREG GR32:$src, sub_8bit_hi))>;
1684 def : Pat<(srl (and_su GR32:$src, immff00_ffff), (i8 8)),
1685           (MOVZX32rr8_NOREX (EXTRACT_SUBREG GR32:$src, sub_8bit_hi))>;
1686
1687 // h-register tricks.
1688 // For now, be conservative on x86-64 and use an h-register extract only if the
1689 // value is immediately zero-extended or stored, which are somewhat common
1690 // cases. This uses a bunch of code to prevent a register requiring a REX prefix
1691 // from being allocated in the same instruction as the h register, as there's
1692 // currently no way to describe this requirement to the register allocator.
1693
1694 // h-register extract and zero-extend.
1695 def : Pat<(and (srl_su GR64:$src, (i8 8)), (i64 255)),
1696           (SUBREG_TO_REG
1697             (i64 0),
1698             (MOVZX32rr8_NOREX
1699               (EXTRACT_SUBREG GR64:$src, sub_8bit_hi)),
1700             sub_32bit)>;
1701 def : Pat<(i64 (zext (srl_su GR16:$src, (i8 8)))),
1702           (SUBREG_TO_REG
1703             (i64 0),
1704             (MOVZX32rr8_NOREX
1705               (EXTRACT_SUBREG GR16:$src, sub_8bit_hi)),
1706             sub_32bit)>;
1707 def : Pat<(i64 (anyext (srl_su GR16:$src, (i8 8)))),
1708           (SUBREG_TO_REG
1709             (i64 0),
1710             (MOVZX32rr8_NOREX
1711               (EXTRACT_SUBREG GR16:$src, sub_8bit_hi)),
1712             sub_32bit)>;
1713
1714 // h-register extract and store.
1715 def : Pat<(store (i8 (trunc_su (srl_su GR64:$src, (i8 8)))), addr:$dst),
1716           (MOV8mr_NOREX
1717             addr:$dst,
1718             (EXTRACT_SUBREG GR64:$src, sub_8bit_hi))>;
1719 def : Pat<(store (i8 (trunc_su (srl_su GR32:$src, (i8 8)))), addr:$dst),
1720           (MOV8mr_NOREX
1721             addr:$dst,
1722             (EXTRACT_SUBREG GR32:$src, sub_8bit_hi))>,
1723       Requires<[In64BitMode]>;
1724 def : Pat<(store (i8 (trunc_su (srl_su GR16:$src, (i8 8)))), addr:$dst),
1725           (MOV8mr_NOREX
1726             addr:$dst,
1727             (EXTRACT_SUBREG GR16:$src, sub_8bit_hi))>,
1728       Requires<[In64BitMode]>;
1729
1730
1731 // (shl x, 1) ==> (add x, x)
1732 // Note that if x is undef (immediate or otherwise), we could theoretically
1733 // end up with the two uses of x getting different values, producing a result
1734 // where the least significant bit is not 0. However, the probability of this
1735 // happening is considered low enough that this is officially not a
1736 // "real problem".
1737 def : Pat<(shl GR8 :$src1, (i8 1)), (ADD8rr  GR8 :$src1, GR8 :$src1)>;
1738 def : Pat<(shl GR16:$src1, (i8 1)), (ADD16rr GR16:$src1, GR16:$src1)>;
1739 def : Pat<(shl GR32:$src1, (i8 1)), (ADD32rr GR32:$src1, GR32:$src1)>;
1740 def : Pat<(shl GR64:$src1, (i8 1)), (ADD64rr GR64:$src1, GR64:$src1)>;
1741
1742 def shiftMask8 : PatFrag<(ops node:$lhs), (and node:$lhs, imm), [{
1743   return isUnneededShiftMask(N, 3);
1744 }]>;
1745
1746 def shiftMask16 : PatFrag<(ops node:$lhs), (and node:$lhs, imm), [{
1747   return isUnneededShiftMask(N, 4);
1748 }]>;
1749
1750 def shiftMask32 : PatFrag<(ops node:$lhs), (and node:$lhs, imm), [{
1751   return isUnneededShiftMask(N, 5);
1752 }]>;
1753
1754 def shiftMask64 : PatFrag<(ops node:$lhs), (and node:$lhs, imm), [{
1755   return isUnneededShiftMask(N, 6);
1756 }]>;
1757
1758
1759 // Shift amount is implicitly masked.
1760 multiclass MaskedShiftAmountPats<SDNode frag, string name> {
1761   // (shift x (and y, 31)) ==> (shift x, y)
1762   def : Pat<(frag GR8:$src1, (shiftMask32 CL)),
1763             (!cast<Instruction>(name # "8rCL") GR8:$src1)>;
1764   def : Pat<(frag GR16:$src1, (shiftMask32 CL)),
1765             (!cast<Instruction>(name # "16rCL") GR16:$src1)>;
1766   def : Pat<(frag GR32:$src1, (shiftMask32 CL)),
1767             (!cast<Instruction>(name # "32rCL") GR32:$src1)>;
1768   def : Pat<(store (frag (loadi8 addr:$dst), (shiftMask32 CL)), addr:$dst),
1769             (!cast<Instruction>(name # "8mCL") addr:$dst)>;
1770   def : Pat<(store (frag (loadi16 addr:$dst), (shiftMask32 CL)), addr:$dst),
1771             (!cast<Instruction>(name # "16mCL") addr:$dst)>;
1772   def : Pat<(store (frag (loadi32 addr:$dst), (shiftMask32 CL)), addr:$dst),
1773             (!cast<Instruction>(name # "32mCL") addr:$dst)>;
1774
1775   // (shift x (and y, 63)) ==> (shift x, y)
1776   def : Pat<(frag GR64:$src1, (shiftMask64 CL)),
1777             (!cast<Instruction>(name # "64rCL") GR64:$src1)>;
1778   def : Pat<(store (frag (loadi64 addr:$dst), (shiftMask64 CL)), addr:$dst),
1779             (!cast<Instruction>(name # "64mCL") addr:$dst)>;
1780 }
1781
1782 defm : MaskedShiftAmountPats<shl, "SHL">;
1783 defm : MaskedShiftAmountPats<srl, "SHR">;
1784 defm : MaskedShiftAmountPats<sra, "SAR">;
1785
1786 // ROL/ROR instructions allow a stronger mask optimization than shift for 8- and
1787 // 16-bit. We can remove a mask of any (bitwidth - 1) on the rotation amount
1788 // because over-rotating produces the same result. This is noted in the Intel
1789 // docs with: "tempCOUNT <- (COUNT & COUNTMASK) MOD SIZE". Masking the rotation
1790 // amount could affect EFLAGS results, but that does not matter because we are
1791 // not tracking flags for these nodes.
1792 multiclass MaskedRotateAmountPats<SDNode frag, string name> {
1793   // (rot x (and y, BitWidth - 1)) ==> (rot x, y)
1794   def : Pat<(frag GR8:$src1, (shiftMask8 CL)),
1795   (!cast<Instruction>(name # "8rCL") GR8:$src1)>;
1796   def : Pat<(frag GR16:$src1, (shiftMask16 CL)),
1797   (!cast<Instruction>(name # "16rCL") GR16:$src1)>;
1798   def : Pat<(frag GR32:$src1, (shiftMask32 CL)),
1799   (!cast<Instruction>(name # "32rCL") GR32:$src1)>;
1800   def : Pat<(store (frag (loadi8 addr:$dst), (shiftMask8 CL)), addr:$dst),
1801   (!cast<Instruction>(name # "8mCL") addr:$dst)>;
1802   def : Pat<(store (frag (loadi16 addr:$dst), (shiftMask16 CL)), addr:$dst),
1803   (!cast<Instruction>(name # "16mCL") addr:$dst)>;
1804   def : Pat<(store (frag (loadi32 addr:$dst), (shiftMask32 CL)), addr:$dst),
1805   (!cast<Instruction>(name # "32mCL") addr:$dst)>;
1806
1807   // (rot x (and y, 63)) ==> (rot x, y)
1808   def : Pat<(frag GR64:$src1, (shiftMask64 CL)),
1809   (!cast<Instruction>(name # "64rCL") GR64:$src1)>;
1810   def : Pat<(store (frag (loadi64 addr:$dst), (shiftMask64 CL)), addr:$dst),
1811   (!cast<Instruction>(name # "64mCL") addr:$dst)>;
1812 }
1813
1814
1815 defm : MaskedRotateAmountPats<rotl, "ROL">;
1816 defm : MaskedRotateAmountPats<rotr, "ROR">;
1817
1818 // Double shift amount is implicitly masked.
1819 multiclass MaskedDoubleShiftAmountPats<SDNode frag, string name> {
1820   // (shift x (and y, 31)) ==> (shift x, y)
1821   def : Pat<(frag GR16:$src1, GR16:$src2, (shiftMask32 CL)),
1822             (!cast<Instruction>(name # "16rrCL") GR16:$src1, GR16:$src2)>;
1823   def : Pat<(frag GR32:$src1, GR32:$src2, (shiftMask32 CL)),
1824             (!cast<Instruction>(name # "32rrCL") GR32:$src1, GR32:$src2)>;
1825
1826   // (shift x (and y, 63)) ==> (shift x, y)
1827   def : Pat<(frag GR64:$src1, GR64:$src2, (shiftMask32 CL)),
1828             (!cast<Instruction>(name # "64rrCL") GR64:$src1, GR64:$src2)>;
1829 }
1830
1831 defm : MaskedDoubleShiftAmountPats<X86shld, "SHLD">;
1832 defm : MaskedDoubleShiftAmountPats<X86shrd, "SHRD">;
1833
1834 let Predicates = [HasBMI2] in {
1835   let AddedComplexity = 1 in {
1836     def : Pat<(sra GR32:$src1, (shiftMask32 GR8:$src2)),
1837               (SARX32rr GR32:$src1,
1838                         (INSERT_SUBREG
1839                           (i32 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1840     def : Pat<(sra GR64:$src1, (shiftMask64 GR8:$src2)),
1841               (SARX64rr GR64:$src1,
1842                         (INSERT_SUBREG
1843                           (i64 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1844
1845     def : Pat<(srl GR32:$src1, (shiftMask32 GR8:$src2)),
1846               (SHRX32rr GR32:$src1,
1847                         (INSERT_SUBREG
1848                           (i32 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1849     def : Pat<(srl GR64:$src1, (shiftMask64 GR8:$src2)),
1850               (SHRX64rr GR64:$src1,
1851                         (INSERT_SUBREG
1852                           (i64 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1853
1854     def : Pat<(shl GR32:$src1, (shiftMask32 GR8:$src2)),
1855               (SHLX32rr GR32:$src1,
1856                         (INSERT_SUBREG
1857                           (i32 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1858     def : Pat<(shl GR64:$src1, (shiftMask64 GR8:$src2)),
1859               (SHLX64rr GR64:$src1,
1860                         (INSERT_SUBREG
1861                           (i64 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1862   }
1863
1864   def : Pat<(sra (loadi32 addr:$src1), (shiftMask32 GR8:$src2)),
1865             (SARX32rm addr:$src1,
1866                       (INSERT_SUBREG
1867                         (i32 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1868   def : Pat<(sra (loadi64 addr:$src1), (shiftMask64 GR8:$src2)),
1869             (SARX64rm addr:$src1,
1870                       (INSERT_SUBREG
1871                         (i64 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1872
1873   def : Pat<(srl (loadi32 addr:$src1), (shiftMask32 GR8:$src2)),
1874             (SHRX32rm addr:$src1,
1875                       (INSERT_SUBREG
1876                         (i32 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1877   def : Pat<(srl (loadi64 addr:$src1), (shiftMask64 GR8:$src2)),
1878             (SHRX64rm addr:$src1,
1879                       (INSERT_SUBREG
1880                         (i64 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1881
1882   def : Pat<(shl (loadi32 addr:$src1), (shiftMask32 GR8:$src2)),
1883             (SHLX32rm addr:$src1,
1884                       (INSERT_SUBREG
1885                         (i32 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1886   def : Pat<(shl (loadi64 addr:$src1), (shiftMask64 GR8:$src2)),
1887             (SHLX64rm addr:$src1,
1888                       (INSERT_SUBREG
1889                         (i64 (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1890 }
1891
1892 // Use BTR/BTS/BTC for clearing/setting/toggling a bit in a variable location.
1893 multiclass one_bit_patterns<RegisterClass RC, ValueType VT, Instruction BTR,
1894                             Instruction BTS, Instruction BTC,
1895                             PatFrag ShiftMask> {
1896   def : Pat<(and RC:$src1, (rotl -2, GR8:$src2)),
1897             (BTR RC:$src1,
1898                  (INSERT_SUBREG (VT (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1899   def : Pat<(or RC:$src1, (shl 1, GR8:$src2)),
1900             (BTS RC:$src1,
1901                  (INSERT_SUBREG (VT (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1902   def : Pat<(xor RC:$src1, (shl 1, GR8:$src2)),
1903             (BTC RC:$src1,
1904                  (INSERT_SUBREG (VT (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1905
1906   // Similar to above, but removing unneeded masking of the shift amount.
1907   def : Pat<(and RC:$src1, (rotl -2, (ShiftMask GR8:$src2))),
1908             (BTR RC:$src1,
1909                  (INSERT_SUBREG (VT (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1910   def : Pat<(or RC:$src1, (shl 1, (ShiftMask GR8:$src2))),
1911             (BTS RC:$src1,
1912                 (INSERT_SUBREG (VT (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1913   def : Pat<(xor RC:$src1, (shl 1, (ShiftMask GR8:$src2))),
1914             (BTC RC:$src1,
1915                 (INSERT_SUBREG (VT (IMPLICIT_DEF)), GR8:$src2, sub_8bit))>;
1916 }
1917
1918 defm : one_bit_patterns<GR16, i16, BTR16rr, BTS16rr, BTC16rr, shiftMask16>;
1919 defm : one_bit_patterns<GR32, i32, BTR32rr, BTS32rr, BTC32rr, shiftMask32>;
1920 defm : one_bit_patterns<GR64, i64, BTR64rr, BTS64rr, BTC64rr, shiftMask64>;
1921
1922
1923 // (anyext (setcc_carry)) -> (setcc_carry)
1924 def : Pat<(i16 (anyext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
1925           (SETB_C16r)>;
1926 def : Pat<(i32 (anyext (i8 (X86setcc_c X86_COND_B, EFLAGS)))),
1927           (SETB_C32r)>;
1928 def : Pat<(i32 (anyext (i16 (X86setcc_c X86_COND_B, EFLAGS)))),
1929           (SETB_C32r)>;
1930
1931 //===----------------------------------------------------------------------===//
1932 // EFLAGS-defining Patterns
1933 //===----------------------------------------------------------------------===//
1934
1935 // add reg, reg
1936 def : Pat<(add GR8 :$src1, GR8 :$src2), (ADD8rr  GR8 :$src1, GR8 :$src2)>;
1937 def : Pat<(add GR16:$src1, GR16:$src2), (ADD16rr GR16:$src1, GR16:$src2)>;
1938 def : Pat<(add GR32:$src1, GR32:$src2), (ADD32rr GR32:$src1, GR32:$src2)>;
1939 def : Pat<(add GR64:$src1, GR64:$src2), (ADD64rr GR64:$src1, GR64:$src2)>;
1940
1941 // add reg, mem
1942 def : Pat<(add GR8:$src1, (loadi8 addr:$src2)),
1943           (ADD8rm GR8:$src1, addr:$src2)>;
1944 def : Pat<(add GR16:$src1, (loadi16 addr:$src2)),
1945           (ADD16rm GR16:$src1, addr:$src2)>;
1946 def : Pat<(add GR32:$src1, (loadi32 addr:$src2)),
1947           (ADD32rm GR32:$src1, addr:$src2)>;
1948 def : Pat<(add GR64:$src1, (loadi64 addr:$src2)),
1949           (ADD64rm GR64:$src1, addr:$src2)>;
1950
1951 // add reg, imm
1952 def : Pat<(add GR8 :$src1, imm:$src2), (ADD8ri  GR8:$src1 , imm:$src2)>;
1953 def : Pat<(add GR16:$src1, imm:$src2), (ADD16ri GR16:$src1, imm:$src2)>;
1954 def : Pat<(add GR32:$src1, imm:$src2), (ADD32ri GR32:$src1, imm:$src2)>;
1955 def : Pat<(add GR16:$src1, i16immSExt8:$src2),
1956           (ADD16ri8 GR16:$src1, i16immSExt8:$src2)>;
1957 def : Pat<(add GR32:$src1, i32immSExt8:$src2),
1958           (ADD32ri8 GR32:$src1, i32immSExt8:$src2)>;
1959 def : Pat<(add GR64:$src1, i64immSExt8:$src2),
1960           (ADD64ri8 GR64:$src1, i64immSExt8:$src2)>;
1961 def : Pat<(add GR64:$src1, i64immSExt32:$src2),
1962           (ADD64ri32 GR64:$src1, i64immSExt32:$src2)>;
1963
1964 // sub reg, reg
1965 def : Pat<(sub GR8 :$src1, GR8 :$src2), (SUB8rr  GR8 :$src1, GR8 :$src2)>;
1966 def : Pat<(sub GR16:$src1, GR16:$src2), (SUB16rr GR16:$src1, GR16:$src2)>;
1967 def : Pat<(sub GR32:$src1, GR32:$src2), (SUB32rr GR32:$src1, GR32:$src2)>;
1968 def : Pat<(sub GR64:$src1, GR64:$src2), (SUB64rr GR64:$src1, GR64:$src2)>;
1969
1970 // sub reg, mem
1971 def : Pat<(sub GR8:$src1, (loadi8 addr:$src2)),
1972           (SUB8rm GR8:$src1, addr:$src2)>;
1973 def : Pat<(sub GR16:$src1, (loadi16 addr:$src2)),
1974           (SUB16rm GR16:$src1, addr:$src2)>;
1975 def : Pat<(sub GR32:$src1, (loadi32 addr:$src2)),
1976           (SUB32rm GR32:$src1, addr:$src2)>;
1977 def : Pat<(sub GR64:$src1, (loadi64 addr:$src2)),
1978           (SUB64rm GR64:$src1, addr:$src2)>;
1979
1980 // sub reg, imm
1981 def : Pat<(sub GR8:$src1, imm:$src2),
1982           (SUB8ri GR8:$src1, imm:$src2)>;
1983 def : Pat<(sub GR16:$src1, imm:$src2),
1984           (SUB16ri GR16:$src1, imm:$src2)>;
1985 def : Pat<(sub GR32:$src1, imm:$src2),
1986           (SUB32ri GR32:$src1, imm:$src2)>;
1987 def : Pat<(sub GR16:$src1, i16immSExt8:$src2),
1988           (SUB16ri8 GR16:$src1, i16immSExt8:$src2)>;
1989 def : Pat<(sub GR32:$src1, i32immSExt8:$src2),
1990           (SUB32ri8 GR32:$src1, i32immSExt8:$src2)>;
1991 def : Pat<(sub GR64:$src1, i64immSExt8:$src2),
1992           (SUB64ri8 GR64:$src1, i64immSExt8:$src2)>;
1993 def : Pat<(sub GR64:$src1, i64immSExt32:$src2),
1994           (SUB64ri32 GR64:$src1, i64immSExt32:$src2)>;
1995
1996 // sub 0, reg
1997 def : Pat<(X86sub_flag 0, GR8 :$src), (NEG8r  GR8 :$src)>;
1998 def : Pat<(X86sub_flag 0, GR16:$src), (NEG16r GR16:$src)>;
1999 def : Pat<(X86sub_flag 0, GR32:$src), (NEG32r GR32:$src)>;
2000 def : Pat<(X86sub_flag 0, GR64:$src), (NEG64r GR64:$src)>;
2001
2002 // sub reg, relocImm
2003 def : Pat<(X86sub_flag GR64:$src1, i64relocImmSExt8_su:$src2),
2004           (SUB64ri8 GR64:$src1, i64relocImmSExt8_su:$src2)>;
2005
2006 // mul reg, reg
2007 def : Pat<(mul GR16:$src1, GR16:$src2),
2008           (IMUL16rr GR16:$src1, GR16:$src2)>;
2009 def : Pat<(mul GR32:$src1, GR32:$src2),
2010           (IMUL32rr GR32:$src1, GR32:$src2)>;
2011 def : Pat<(mul GR64:$src1, GR64:$src2),
2012           (IMUL64rr GR64:$src1, GR64:$src2)>;
2013
2014 // mul reg, mem
2015 def : Pat<(mul GR16:$src1, (loadi16 addr:$src2)),
2016           (IMUL16rm GR16:$src1, addr:$src2)>;
2017 def : Pat<(mul GR32:$src1, (loadi32 addr:$src2)),
2018           (IMUL32rm GR32:$src1, addr:$src2)>;
2019 def : Pat<(mul GR64:$src1, (loadi64 addr:$src2)),
2020           (IMUL64rm GR64:$src1, addr:$src2)>;
2021
2022 // mul reg, imm
2023 def : Pat<(mul GR16:$src1, imm:$src2),
2024           (IMUL16rri GR16:$src1, imm:$src2)>;
2025 def : Pat<(mul GR32:$src1, imm:$src2),
2026           (IMUL32rri GR32:$src1, imm:$src2)>;
2027 def : Pat<(mul GR16:$src1, i16immSExt8:$src2),
2028           (IMUL16rri8 GR16:$src1, i16immSExt8:$src2)>;
2029 def : Pat<(mul GR32:$src1, i32immSExt8:$src2),
2030           (IMUL32rri8 GR32:$src1, i32immSExt8:$src2)>;
2031 def : Pat<(mul GR64:$src1, i64immSExt8:$src2),
2032           (IMUL64rri8 GR64:$src1, i64immSExt8:$src2)>;
2033 def : Pat<(mul GR64:$src1, i64immSExt32:$src2),
2034           (IMUL64rri32 GR64:$src1, i64immSExt32:$src2)>;
2035
2036 // reg = mul mem, imm
2037 def : Pat<(mul (loadi16 addr:$src1), imm:$src2),
2038           (IMUL16rmi addr:$src1, imm:$src2)>;
2039 def : Pat<(mul (loadi32 addr:$src1), imm:$src2),
2040           (IMUL32rmi addr:$src1, imm:$src2)>;
2041 def : Pat<(mul (loadi16 addr:$src1), i16immSExt8:$src2),
2042           (IMUL16rmi8 addr:$src1, i16immSExt8:$src2)>;
2043 def : Pat<(mul (loadi32 addr:$src1), i32immSExt8:$src2),
2044           (IMUL32rmi8 addr:$src1, i32immSExt8:$src2)>;
2045 def : Pat<(mul (loadi64 addr:$src1), i64immSExt8:$src2),
2046           (IMUL64rmi8 addr:$src1, i64immSExt8:$src2)>;
2047 def : Pat<(mul (loadi64 addr:$src1), i64immSExt32:$src2),
2048           (IMUL64rmi32 addr:$src1, i64immSExt32:$src2)>;
2049
2050 // Increment/Decrement reg.
2051 // Do not make INC/DEC if it is slow
2052 let Predicates = [UseIncDec] in {
2053   def : Pat<(add GR8:$src, 1),   (INC8r GR8:$src)>;
2054   def : Pat<(add GR16:$src, 1),  (INC16r GR16:$src)>;
2055   def : Pat<(add GR32:$src, 1),  (INC32r GR32:$src)>;
2056   def : Pat<(add GR64:$src, 1),  (INC64r GR64:$src)>;
2057   def : Pat<(add GR8:$src, -1),  (DEC8r GR8:$src)>;
2058   def : Pat<(add GR16:$src, -1), (DEC16r GR16:$src)>;
2059   def : Pat<(add GR32:$src, -1), (DEC32r GR32:$src)>;
2060   def : Pat<(add GR64:$src, -1), (DEC64r GR64:$src)>;
2061
2062   def : Pat<(X86add_flag_nocf GR8:$src, -1),  (DEC8r GR8:$src)>;
2063   def : Pat<(X86add_flag_nocf GR16:$src, -1), (DEC16r GR16:$src)>;
2064   def : Pat<(X86add_flag_nocf GR32:$src, -1), (DEC32r GR32:$src)>;
2065   def : Pat<(X86add_flag_nocf GR64:$src, -1), (DEC64r GR64:$src)>;
2066   def : Pat<(X86sub_flag_nocf GR8:$src, -1),  (INC8r GR8:$src)>;
2067   def : Pat<(X86sub_flag_nocf GR16:$src, -1), (INC16r GR16:$src)>;
2068   def : Pat<(X86sub_flag_nocf GR32:$src, -1), (INC32r GR32:$src)>;
2069   def : Pat<(X86sub_flag_nocf GR64:$src, -1), (INC64r GR64:$src)>;
2070 }
2071
2072 // or reg/reg.
2073 def : Pat<(or GR8 :$src1, GR8 :$src2), (OR8rr  GR8 :$src1, GR8 :$src2)>;
2074 def : Pat<(or GR16:$src1, GR16:$src2), (OR16rr GR16:$src1, GR16:$src2)>;
2075 def : Pat<(or GR32:$src1, GR32:$src2), (OR32rr GR32:$src1, GR32:$src2)>;
2076 def : Pat<(or GR64:$src1, GR64:$src2), (OR64rr GR64:$src1, GR64:$src2)>;
2077
2078 // or reg/mem
2079 def : Pat<(or GR8:$src1, (loadi8 addr:$src2)),
2080           (OR8rm GR8:$src1, addr:$src2)>;
2081 def : Pat<(or GR16:$src1, (loadi16 addr:$src2)),
2082           (OR16rm GR16:$src1, addr:$src2)>;
2083 def : Pat<(or GR32:$src1, (loadi32 addr:$src2)),
2084           (OR32rm GR32:$src1, addr:$src2)>;
2085 def : Pat<(or GR64:$src1, (loadi64 addr:$src2)),
2086           (OR64rm GR64:$src1, addr:$src2)>;
2087
2088 // or reg/imm
2089 def : Pat<(or GR8:$src1 , imm:$src2), (OR8ri  GR8 :$src1, imm:$src2)>;
2090 def : Pat<(or GR16:$src1, imm:$src2), (OR16ri GR16:$src1, imm:$src2)>;
2091 def : Pat<(or GR32:$src1, imm:$src2), (OR32ri GR32:$src1, imm:$src2)>;
2092 def : Pat<(or GR16:$src1, i16immSExt8:$src2),
2093           (OR16ri8 GR16:$src1, i16immSExt8:$src2)>;
2094 def : Pat<(or GR32:$src1, i32immSExt8:$src2),
2095           (OR32ri8 GR32:$src1, i32immSExt8:$src2)>;
2096 def : Pat<(or GR64:$src1, i64immSExt8:$src2),
2097           (OR64ri8 GR64:$src1, i64immSExt8:$src2)>;
2098 def : Pat<(or GR64:$src1, i64immSExt32:$src2),
2099           (OR64ri32 GR64:$src1, i64immSExt32:$src2)>;
2100
2101 // xor reg/reg
2102 def : Pat<(xor GR8 :$src1, GR8 :$src2), (XOR8rr  GR8 :$src1, GR8 :$src2)>;
2103 def : Pat<(xor GR16:$src1, GR16:$src2), (XOR16rr GR16:$src1, GR16:$src2)>;
2104 def : Pat<(xor GR32:$src1, GR32:$src2), (XOR32rr GR32:$src1, GR32:$src2)>;
2105 def : Pat<(xor GR64:$src1, GR64:$src2), (XOR64rr GR64:$src1, GR64:$src2)>;
2106
2107 // xor reg/mem
2108 def : Pat<(xor GR8:$src1, (loadi8 addr:$src2)),
2109           (XOR8rm GR8:$src1, addr:$src2)>;
2110 def : Pat<(xor GR16:$src1, (loadi16 addr:$src2)),
2111           (XOR16rm GR16:$src1, addr:$src2)>;
2112 def : Pat<(xor GR32:$src1, (loadi32 addr:$src2)),
2113           (XOR32rm GR32:$src1, addr:$src2)>;
2114 def : Pat<(xor GR64:$src1, (loadi64 addr:$src2)),
2115           (XOR64rm GR64:$src1, addr:$src2)>;
2116
2117 // xor reg/imm
2118 def : Pat<(xor GR8:$src1, imm:$src2),
2119           (XOR8ri GR8:$src1, imm:$src2)>;
2120 def : Pat<(xor GR16:$src1, imm:$src2),
2121           (XOR16ri GR16:$src1, imm:$src2)>;
2122 def : Pat<(xor GR32:$src1, imm:$src2),
2123           (XOR32ri GR32:$src1, imm:$src2)>;
2124 def : Pat<(xor GR16:$src1, i16immSExt8:$src2),
2125           (XOR16ri8 GR16:$src1, i16immSExt8:$src2)>;
2126 def : Pat<(xor GR32:$src1, i32immSExt8:$src2),
2127           (XOR32ri8 GR32:$src1, i32immSExt8:$src2)>;
2128 def : Pat<(xor GR64:$src1, i64immSExt8:$src2),
2129           (XOR64ri8 GR64:$src1, i64immSExt8:$src2)>;
2130 def : Pat<(xor GR64:$src1, i64immSExt32:$src2),
2131           (XOR64ri32 GR64:$src1, i64immSExt32:$src2)>;
2132
2133 // and reg/reg
2134 def : Pat<(and GR8 :$src1, GR8 :$src2), (AND8rr  GR8 :$src1, GR8 :$src2)>;
2135 def : Pat<(and GR16:$src1, GR16:$src2), (AND16rr GR16:$src1, GR16:$src2)>;
2136 def : Pat<(and GR32:$src1, GR32:$src2), (AND32rr GR32:$src1, GR32:$src2)>;
2137 def : Pat<(and GR64:$src1, GR64:$src2), (AND64rr GR64:$src1, GR64:$src2)>;
2138
2139 // and reg/mem
2140 def : Pat<(and GR8:$src1, (loadi8 addr:$src2)),
2141           (AND8rm GR8:$src1, addr:$src2)>;
2142 def : Pat<(and GR16:$src1, (loadi16 addr:$src2)),
2143           (AND16rm GR16:$src1, addr:$src2)>;
2144 def : Pat<(and GR32:$src1, (loadi32 addr:$src2)),
2145           (AND32rm GR32:$src1, addr:$src2)>;
2146 def : Pat<(and GR64:$src1, (loadi64 addr:$src2)),
2147           (AND64rm GR64:$src1, addr:$src2)>;
2148
2149 // and reg/imm
2150 def : Pat<(and GR8:$src1, imm:$src2),
2151           (AND8ri GR8:$src1, imm:$src2)>;
2152 def : Pat<(and GR16:$src1, imm:$src2),
2153           (AND16ri GR16:$src1, imm:$src2)>;
2154 def : Pat<(and GR32:$src1, imm:$src2),
2155           (AND32ri GR32:$src1, imm:$src2)>;
2156 def : Pat<(and GR16:$src1, i16immSExt8:$src2),
2157           (AND16ri8 GR16:$src1, i16immSExt8:$src2)>;
2158 def : Pat<(and GR32:$src1, i32immSExt8:$src2),
2159           (AND32ri8 GR32:$src1, i32immSExt8:$src2)>;
2160 def : Pat<(and GR64:$src1, i64immSExt8:$src2),
2161           (AND64ri8 GR64:$src1, i64immSExt8:$src2)>;
2162 def : Pat<(and GR64:$src1, i64immSExt32:$src2),
2163           (AND64ri32 GR64:$src1, i64immSExt32:$src2)>;
2164
2165 // Bit scan instruction patterns to match explicit zero-undef behavior.
2166 def : Pat<(cttz_zero_undef GR16:$src), (BSF16rr GR16:$src)>;
2167 def : Pat<(cttz_zero_undef GR32:$src), (BSF32rr GR32:$src)>;
2168 def : Pat<(cttz_zero_undef GR64:$src), (BSF64rr GR64:$src)>;
2169 def : Pat<(cttz_zero_undef (loadi16 addr:$src)), (BSF16rm addr:$src)>;
2170 def : Pat<(cttz_zero_undef (loadi32 addr:$src)), (BSF32rm addr:$src)>;
2171 def : Pat<(cttz_zero_undef (loadi64 addr:$src)), (BSF64rm addr:$src)>;
2172
2173 // When HasMOVBE is enabled it is possible to get a non-legalized
2174 // register-register 16 bit bswap. This maps it to a ROL instruction.
2175 let Predicates = [HasMOVBE] in {
2176  def : Pat<(bswap GR16:$src), (ROL16ri GR16:$src, (i8 8))>;
2177 }