lib/Target/X86/X86InstrInfo.td

   1 //===-- X86InstrInfo.td - Main X86 Instruction Definition --*- tablegen -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file describes the X86 instruction set, defining the instructions, and
  11 // properties of the instructions which are needed for code generation, machine
  12 // code emission, and analysis.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 //===----------------------------------------------------------------------===//
  17 // X86 specific DAG Nodes.
  18 //
  19
  20 def SDTIntShiftDOp: SDTypeProfile<1, 3,
  21                                   [SDTCisSameAs<0, 1>, SDTCisSameAs<0, 2>,
  22                                    SDTCisInt<0>, SDTCisInt<3>]>;
  23
  24 def SDTX86CmpTest : SDTypeProfile<1, 2, [SDTCisVT<0, i32>, SDTCisSameAs<1, 2>]>;
  25
  26 def SDTX86Cmps : SDTypeProfile<1, 3, [SDTCisFP<0>, SDTCisSameAs<1, 2>, SDTCisVT<3, i8>]>;
  27 //def SDTX86Cmpss : SDTypeProfile<1, 3, [SDTCisVT<0, f32>, SDTCisSameAs<1, 2>, SDTCisVT<3, i8>]>;
  28
  29 def SDTX86Cmov    : SDTypeProfile<1, 4,
  30                                   [SDTCisSameAs<0, 1>, SDTCisSameAs<1, 2>,
  31                                    SDTCisVT<3, i8>, SDTCisVT<4, i32>]>;
  32
  33 // Unary and binary operator instructions that set EFLAGS as a side-effect.
  34 def SDTUnaryArithWithFlags : SDTypeProfile<2, 1,
  35                                            [SDTCisSameAs<0, 2>,
  36                                             SDTCisInt<0>, SDTCisVT<1, i32>]>;
  37
  38 def SDTBinaryArithWithFlags : SDTypeProfile<2, 2,
  39                                             [SDTCisSameAs<0, 2>,
  40                                              SDTCisSameAs<0, 3>,
  41                                              SDTCisInt<0>, SDTCisVT<1, i32>]>;
  42
  43 // SDTBinaryArithWithFlagsInOut - RES1, EFLAGS = op LHS, RHS, EFLAGS
  44 def SDTBinaryArithWithFlagsInOut : SDTypeProfile<2, 3,
  45                                             [SDTCisSameAs<0, 2>,
  46                                              SDTCisSameAs<0, 3>,
  47                                              SDTCisInt<0>,
  48                                              SDTCisVT<1, i32>,
  49                                              SDTCisVT<4, i32>]>;
  50 // RES1, RES2, FLAGS = op LHS, RHS
  51 def SDT2ResultBinaryArithWithFlags : SDTypeProfile<3, 2,
  52                                             [SDTCisSameAs<0, 1>,
  53                                              SDTCisSameAs<0, 2>,
  54                                              SDTCisSameAs<0, 3>,
  55                                              SDTCisInt<0>, SDTCisVT<1, i32>]>;
  56 def SDTX86BrCond  : SDTypeProfile<0, 3,
  57                                   [SDTCisVT<0, OtherVT>,
  58                                    SDTCisVT<1, i8>, SDTCisVT<2, i32>]>;
  59
  60 def SDTX86SetCC   : SDTypeProfile<1, 2,
  61                                   [SDTCisVT<0, i8>,
  62                                    SDTCisVT<1, i8>, SDTCisVT<2, i32>]>;
  63 def SDTX86SetCC_C : SDTypeProfile<1, 2,
  64                                   [SDTCisInt<0>,
  65                                    SDTCisVT<1, i8>, SDTCisVT<2, i32>]>;
  66
  67 def SDTX86sahf : SDTypeProfile<1, 1, [SDTCisVT<0, i32>, SDTCisVT<1, i8>]>;
  68
  69 def SDTX86rdrand : SDTypeProfile<2, 0, [SDTCisInt<0>, SDTCisVT<1, i32>]>;
  70
  71 def SDTX86cas : SDTypeProfile<0, 3, [SDTCisPtrTy<0>, SDTCisInt<1>,
  72                                      SDTCisVT<2, i8>]>;
  73 def SDTX86caspair : SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>;
  74
  75 def SDTX86atomicBinary : SDTypeProfile<2, 3, [SDTCisInt<0>, SDTCisInt<1>,
  76                                 SDTCisPtrTy<2>, SDTCisInt<3>,SDTCisInt<4>]>;
  77 def SDTX86Ret     : SDTypeProfile<0, -1, [SDTCisVT<0, i16>]>;
  78
  79 def SDT_X86CallSeqStart : SDCallSeqStart<[SDTCisVT<0, i32>]>;
  80 def SDT_X86CallSeqEnd   : SDCallSeqEnd<[SDTCisVT<0, i32>,
  81                                         SDTCisVT<1, i32>]>;
  82
  83 def SDT_X86Call   : SDTypeProfile<0, -1, [SDTCisVT<0, iPTR>]>;
  84
  85 def SDT_X86VASTART_SAVE_XMM_REGS : SDTypeProfile<0, -1, [SDTCisVT<0, i8>,
  86                                                          SDTCisVT<1, iPTR>,
  87                                                          SDTCisVT<2, iPTR>]>;
  88
  89 def SDT_X86VAARG_64 : SDTypeProfile<1, -1, [SDTCisPtrTy<0>,
  90                                             SDTCisPtrTy<1>,
  91                                             SDTCisVT<2, i32>,
  92                                             SDTCisVT<3, i8>,
  93                                             SDTCisVT<4, i32>]>;
  94
  95 def SDTX86RepStr  : SDTypeProfile<0, 1, [SDTCisVT<0, OtherVT>]>;
  96
  97 def SDTX86Void    : SDTypeProfile<0, 0, []>;
  98
  99 def SDTX86Wrapper : SDTypeProfile<1, 1, [SDTCisSameAs<0, 1>, SDTCisPtrTy<0>]>;
 100
 101 def SDT_X86TLSADDR : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
 102
 103 def SDT_X86TLSBASEADDR : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
 104
 105 def SDT_X86TLSCALL : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
 106
 107 def SDT_X86SEG_ALLOCA : SDTypeProfile<1, 1, [SDTCisVT<0, iPTR>, SDTCisVT<1, iPTR>]>;
 108
 109 def SDT_X86WIN_FTOL : SDTypeProfile<0, 1, [SDTCisFP<0>]>;
 110
 111 def SDT_X86EHRET : SDTypeProfile<0, 1, [SDTCisInt<0>]>;
 112
 113 def SDT_X86TCRET : SDTypeProfile<0, 2, [SDTCisPtrTy<0>, SDTCisVT<1, i32>]>;
 114
 115 def SDT_X86MEMBARRIER : SDTypeProfile<0, 0, []>;
 116
 117 def X86MemBarrier : SDNode<"X86ISD::MEMBARRIER", SDT_X86MEMBARRIER,
 118                             [SDNPHasChain,SDNPSideEffect]>;
 119 def X86MFence : SDNode<"X86ISD::MFENCE", SDT_X86MEMBARRIER,
 120                         [SDNPHasChain]>;
 121 def X86SFence : SDNode<"X86ISD::SFENCE", SDT_X86MEMBARRIER,
 122                         [SDNPHasChain]>;
 123 def X86LFence : SDNode<"X86ISD::LFENCE", SDT_X86MEMBARRIER,
 124                         [SDNPHasChain]>;
 125
 126
 127 def X86bsf     : SDNode<"X86ISD::BSF",      SDTUnaryArithWithFlags>;
 128 def X86bsr     : SDNode<"X86ISD::BSR",      SDTUnaryArithWithFlags>;
 129 def X86shld    : SDNode<"X86ISD::SHLD",     SDTIntShiftDOp>;
 130 def X86shrd    : SDNode<"X86ISD::SHRD",     SDTIntShiftDOp>;
 131
 132 def X86cmp     : SDNode<"X86ISD::CMP" ,     SDTX86CmpTest>;
 133 def X86bt      : SDNode<"X86ISD::BT",       SDTX86CmpTest>;
 134
 135 def X86cmov    : SDNode<"X86ISD::CMOV",     SDTX86Cmov>;
 136 def X86brcond  : SDNode<"X86ISD::BRCOND",   SDTX86BrCond,
 137                         [SDNPHasChain]>;
 138 def X86setcc   : SDNode<"X86ISD::SETCC",    SDTX86SetCC>;
 139 def X86setcc_c : SDNode<"X86ISD::SETCC_CARRY", SDTX86SetCC_C>;
 140
 141 def X86sahf    : SDNode<"X86ISD::SAHF",     SDTX86sahf>;
 142
 143 def X86rdrand  : SDNode<"X86ISD::RDRAND",   SDTX86rdrand,
 144                         [SDNPHasChain, SDNPSideEffect]>;
 145
 146 def X86rdseed  : SDNode<"X86ISD::RDSEED",   SDTX86rdrand,
 147                         [SDNPHasChain, SDNPSideEffect]>;
 148
 149 def X86cas : SDNode<"X86ISD::LCMPXCHG_DAG", SDTX86cas,
 150                         [SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
 151                          SDNPMayLoad, SDNPMemOperand]>;
 152 def X86cas8 : SDNode<"X86ISD::LCMPXCHG8_DAG", SDTX86caspair,
 153                         [SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
 154                          SDNPMayLoad, SDNPMemOperand]>;
 155 def X86cas16 : SDNode<"X86ISD::LCMPXCHG16_DAG", SDTX86caspair,
 156                         [SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
 157                          SDNPMayLoad, SDNPMemOperand]>;
 158
 159 def X86retflag : SDNode<"X86ISD::RET_FLAG", SDTX86Ret,
 160                         [SDNPHasChain, SDNPOptInGlue, SDNPVariadic]>;
 161
 162 def X86vastart_save_xmm_regs :
 163                  SDNode<"X86ISD::VASTART_SAVE_XMM_REGS",
 164                         SDT_X86VASTART_SAVE_XMM_REGS,
 165                         [SDNPHasChain, SDNPVariadic]>;
 166 def X86vaarg64 :
 167                  SDNode<"X86ISD::VAARG_64", SDT_X86VAARG_64,
 168                         [SDNPHasChain, SDNPMayLoad, SDNPMayStore,
 169                          SDNPMemOperand]>;
 170 def X86callseq_start :
 171                  SDNode<"ISD::CALLSEQ_START", SDT_X86CallSeqStart,
 172                         [SDNPHasChain, SDNPOutGlue]>;
 173 def X86callseq_end :
 174                  SDNode<"ISD::CALLSEQ_END",   SDT_X86CallSeqEnd,
 175                         [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 176
 177 def X86call    : SDNode<"X86ISD::CALL",     SDT_X86Call,
 178                         [SDNPHasChain, SDNPOutGlue, SDNPOptInGlue,
 179                          SDNPVariadic]>;
 180
 181 def X86rep_stos: SDNode<"X86ISD::REP_STOS", SDTX86RepStr,
 182                         [SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore]>;
 183 def X86rep_movs: SDNode<"X86ISD::REP_MOVS", SDTX86RepStr,
 184                         [SDNPHasChain, SDNPInGlue, SDNPOutGlue, SDNPMayStore,
 185                          SDNPMayLoad]>;
 186
 187 def X86rdtsc   : SDNode<"X86ISD::RDTSC_DAG", SDTX86Void,
 188                         [SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
 189 def X86rdtscp  : SDNode<"X86ISD::RDTSCP_DAG", SDTX86Void,
 190                         [SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
 191 def X86rdpmc   : SDNode<"X86ISD::RDPMC_DAG", SDTX86Void,
 192                         [SDNPHasChain, SDNPOutGlue, SDNPSideEffect]>;
 193
 194 def X86Wrapper    : SDNode<"X86ISD::Wrapper",     SDTX86Wrapper>;
 195 def X86WrapperRIP : SDNode<"X86ISD::WrapperRIP",  SDTX86Wrapper>;
 196
 197 def X86tlsaddr : SDNode<"X86ISD::TLSADDR", SDT_X86TLSADDR,
 198                         [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 199
 200 def X86tlsbaseaddr : SDNode<"X86ISD::TLSBASEADDR", SDT_X86TLSBASEADDR,
 201                         [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 202
 203 def X86ehret : SDNode<"X86ISD::EH_RETURN", SDT_X86EHRET,
 204                         [SDNPHasChain]>;
 205
 206 def X86eh_sjlj_setjmp  : SDNode<"X86ISD::EH_SJLJ_SETJMP",
 207                                 SDTypeProfile<1, 1, [SDTCisInt<0>,
 208                                                      SDTCisPtrTy<1>]>,
 209                                 [SDNPHasChain, SDNPSideEffect]>;
 210 def X86eh_sjlj_longjmp : SDNode<"X86ISD::EH_SJLJ_LONGJMP",
 211                                 SDTypeProfile<0, 1, [SDTCisPtrTy<0>]>,
 212                                 [SDNPHasChain, SDNPSideEffect]>;
 213
 214 def X86tcret : SDNode<"X86ISD::TC_RETURN", SDT_X86TCRET,
 215                         [SDNPHasChain,  SDNPOptInGlue, SDNPVariadic]>;
 216
 217 def X86add_flag  : SDNode<"X86ISD::ADD",  SDTBinaryArithWithFlags,
 218                           [SDNPCommutative]>;
 219 def X86sub_flag  : SDNode<"X86ISD::SUB",  SDTBinaryArithWithFlags>;
 220 def X86smul_flag : SDNode<"X86ISD::SMUL", SDTBinaryArithWithFlags,
 221                           [SDNPCommutative]>;
 222 def X86umul_flag : SDNode<"X86ISD::UMUL", SDT2ResultBinaryArithWithFlags,
 223                           [SDNPCommutative]>;
 224 def X86adc_flag  : SDNode<"X86ISD::ADC",  SDTBinaryArithWithFlagsInOut>;
 225 def X86sbb_flag  : SDNode<"X86ISD::SBB",  SDTBinaryArithWithFlagsInOut>;
 226
 227 def X86inc_flag  : SDNode<"X86ISD::INC",  SDTUnaryArithWithFlags>;
 228 def X86dec_flag  : SDNode<"X86ISD::DEC",  SDTUnaryArithWithFlags>;
 229 def X86or_flag   : SDNode<"X86ISD::OR",   SDTBinaryArithWithFlags,
 230                           [SDNPCommutative]>;
 231 def X86xor_flag  : SDNode<"X86ISD::XOR",  SDTBinaryArithWithFlags,
 232                           [SDNPCommutative]>;
 233 def X86and_flag  : SDNode<"X86ISD::AND",  SDTBinaryArithWithFlags,
 234                           [SDNPCommutative]>;
 235
 236 def X86bextr  : SDNode<"X86ISD::BEXTR",  SDTIntBinOp>;
 237
 238 def X86mul_imm : SDNode<"X86ISD::MUL_IMM", SDTIntBinOp>;
 239
 240 def X86WinAlloca : SDNode<"X86ISD::WIN_ALLOCA", SDTX86Void,
 241                           [SDNPHasChain, SDNPInGlue, SDNPOutGlue]>;
 242
 243 def X86SegAlloca : SDNode<"X86ISD::SEG_ALLOCA", SDT_X86SEG_ALLOCA,
 244                           [SDNPHasChain]>;
 245
 246 def X86TLSCall : SDNode<"X86ISD::TLSCALL", SDT_X86TLSCALL,
 247                         [SDNPHasChain, SDNPOptInGlue, SDNPOutGlue]>;
 248
 249 def X86WinFTOL : SDNode<"X86ISD::WIN_FTOL", SDT_X86WIN_FTOL,
 250                         [SDNPHasChain, SDNPOutGlue]>;
 251
 252 //===----------------------------------------------------------------------===//
 253 // X86 Operand Definitions.
 254 //
 255
 256 // A version of ptr_rc which excludes SP, ESP, and RSP. This is used for
 257 // the index operand of an address, to conform to x86 encoding restrictions.
 258 def ptr_rc_nosp : PointerLikeRegClass<1>;
 259
 260 // *mem - Operand definitions for the funky X86 addressing mode operands.
 261 //
 262 def X86MemAsmOperand : AsmOperandClass {
 263  let Name = "Mem";
 264 }
 265 let RenderMethod = "addMemOperands" in {
 266   def X86Mem8AsmOperand   : AsmOperandClass { let Name = "Mem8"; }
 267   def X86Mem16AsmOperand  : AsmOperandClass { let Name = "Mem16"; }
 268   def X86Mem32AsmOperand  : AsmOperandClass { let Name = "Mem32"; }
 269   def X86Mem64AsmOperand  : AsmOperandClass { let Name = "Mem64"; }
 270   def X86Mem80AsmOperand  : AsmOperandClass { let Name = "Mem80"; }
 271   def X86Mem128AsmOperand : AsmOperandClass { let Name = "Mem128"; }
 272   def X86Mem256AsmOperand : AsmOperandClass { let Name = "Mem256"; }
 273   def X86Mem512AsmOperand : AsmOperandClass { let Name = "Mem512"; }
 274   // Gather mem operands
 275   def X86MemVX32Operand : AsmOperandClass { let Name = "MemVX32"; }
 276   def X86MemVY32Operand : AsmOperandClass { let Name = "MemVY32"; }
 277   def X86MemVZ32Operand : AsmOperandClass { let Name = "MemVZ32"; }
 278   def X86MemVX64Operand : AsmOperandClass { let Name = "MemVX64"; }
 279   def X86MemVY64Operand : AsmOperandClass { let Name = "MemVY64"; }
 280   def X86MemVZ64Operand : AsmOperandClass { let Name = "MemVZ64"; }
 281 }
 282
 283 def X86AbsMemAsmOperand : AsmOperandClass {
 284   let Name = "AbsMem";
 285   let SuperClasses = [X86MemAsmOperand];
 286 }
 287
 288 class X86MemOperand<string printMethod,
 289           AsmOperandClass parserMatchClass = X86MemAsmOperand> : Operand<iPTR> {
 290   let PrintMethod = printMethod;
 291   let MIOperandInfo = (ops ptr_rc, i8imm, ptr_rc_nosp, i32imm, i8imm);
 292   let ParserMatchClass = parserMatchClass;
 293   let OperandType = "OPERAND_MEMORY";
 294 }
 295
 296 // Gather mem operands
 297 class X86VMemOperand<RegisterClass RC, string printMethod,
 298                      AsmOperandClass parserMatchClass>
 299     : X86MemOperand<printMethod, parserMatchClass> {
 300   let MIOperandInfo = (ops ptr_rc, i8imm, RC, i32imm, i8imm);
 301 }
 302
 303 def opaque32mem : X86MemOperand<"printopaquemem">;
 304 def opaque48mem : X86MemOperand<"printopaquemem">;
 305 def opaque80mem : X86MemOperand<"printopaquemem">;
 306 def opaque512mem : X86MemOperand<"printopaquemem">;
 307
 308 def i8mem   : X86MemOperand<"printi8mem",   X86Mem8AsmOperand>;
 309 def i16mem  : X86MemOperand<"printi16mem",  X86Mem16AsmOperand>;
 310 def i32mem  : X86MemOperand<"printi32mem",  X86Mem32AsmOperand>;
 311 def i64mem  : X86MemOperand<"printi64mem",  X86Mem64AsmOperand>;
 312 def i128mem : X86MemOperand<"printi128mem", X86Mem128AsmOperand>;
 313 def i256mem : X86MemOperand<"printi256mem", X86Mem256AsmOperand>;
 314 def i512mem : X86MemOperand<"printi512mem", X86Mem512AsmOperand>;
 315 def f32mem  : X86MemOperand<"printf32mem",  X86Mem32AsmOperand>;
 316 def f64mem  : X86MemOperand<"printf64mem",  X86Mem64AsmOperand>;
 317 def f80mem  : X86MemOperand<"printf80mem",  X86Mem80AsmOperand>;
 318 def f128mem : X86MemOperand<"printf128mem", X86Mem128AsmOperand>;
 319 def f256mem : X86MemOperand<"printf256mem", X86Mem256AsmOperand>;
 320 def f512mem : X86MemOperand<"printf512mem", X86Mem512AsmOperand>;
 321
 322 def v512mem : X86VMemOperand<VR512, "printf512mem", X86Mem512AsmOperand>;
 323
 324 // Gather mem operands
 325 def vx32mem  : X86VMemOperand<VR128,  "printi32mem", X86MemVX32Operand>;
 326 def vy32mem  : X86VMemOperand<VR256,  "printi32mem", X86MemVY32Operand>;
 327 def vx64mem  : X86VMemOperand<VR128,  "printi64mem", X86MemVX64Operand>;
 328 def vy64mem  : X86VMemOperand<VR256,  "printi64mem", X86MemVY64Operand>;
 329 def vy64xmem : X86VMemOperand<VR256X, "printi64mem", X86MemVY64Operand>;
 330 def vz32mem  : X86VMemOperand<VR512,  "printi32mem", X86MemVZ32Operand>;
 331 def vz64mem  : X86VMemOperand<VR512,  "printi64mem", X86MemVZ64Operand>;
 332
 333 // A version of i8mem for use on x86-64 that uses GR64_NOREX instead of
 334 // plain GR64, so that it doesn't potentially require a REX prefix.
 335 def i8mem_NOREX : Operand<i64> {
 336   let PrintMethod = "printi8mem";
 337   let MIOperandInfo = (ops GR64_NOREX, i8imm, GR64_NOREX_NOSP, i32imm, i8imm);
 338   let ParserMatchClass = X86Mem8AsmOperand;
 339   let OperandType = "OPERAND_MEMORY";
 340 }
 341
 342 // GPRs available for tailcall.
 343 // It represents GR32_TC, GR64_TC or GR64_TCW64.
 344 def ptr_rc_tailcall : PointerLikeRegClass<2>;
 345
 346 // Special i32mem for addresses of load folding tail calls. These are not
 347 // allowed to use callee-saved registers since they must be scheduled
 348 // after callee-saved register are popped.
 349 def i32mem_TC : Operand<i32> {
 350   let PrintMethod = "printi32mem";
 351   let MIOperandInfo = (ops ptr_rc_tailcall, i8imm, ptr_rc_tailcall,
 352                        i32imm, i8imm);
 353   let ParserMatchClass = X86Mem32AsmOperand;
 354   let OperandType = "OPERAND_MEMORY";
 355 }
 356
 357 // Special i64mem for addresses of load folding tail calls. These are not
 358 // allowed to use callee-saved registers since they must be scheduled
 359 // after callee-saved register are popped.
 360 def i64mem_TC : Operand<i64> {
 361   let PrintMethod = "printi64mem";
 362   let MIOperandInfo = (ops ptr_rc_tailcall, i8imm,
 363                        ptr_rc_tailcall, i32imm, i8imm);
 364   let ParserMatchClass = X86Mem64AsmOperand;
 365   let OperandType = "OPERAND_MEMORY";
 366 }
 367
 368 let OperandType = "OPERAND_PCREL",
 369     ParserMatchClass = X86AbsMemAsmOperand,
 370     PrintMethod = "printPCRelImm" in {
 371 def i32imm_pcrel : Operand<i32>;
 372 def i16imm_pcrel : Operand<i16>;
 373
 374 // Branch targets have OtherVT type and print as pc-relative values.
 375 def brtarget : Operand<OtherVT>;
 376 def brtarget8 : Operand<OtherVT>;
 377
 378 }
 379
 380 // Special parsers to detect mode to disambiguate.
 381 def X86AbsMem16AsmOperand : AsmOperandClass {
 382   let Name = "AbsMem16";
 383   let RenderMethod = "addAbsMemOperands";
 384   let SuperClasses = [X86AbsMemAsmOperand];
 385 }
 386
 387 def X86AbsMem32AsmOperand : AsmOperandClass {
 388   let Name = "AbsMem32";
 389   let RenderMethod = "addAbsMemOperands";
 390   let SuperClasses = [X86AbsMemAsmOperand];
 391 }
 392
 393 // Branch targets have OtherVT type and print as pc-relative values.
 394 let OperandType = "OPERAND_PCREL",
 395     PrintMethod = "printPCRelImm" in {
 396 let ParserMatchClass = X86AbsMem16AsmOperand in
 397   def brtarget16 : Operand<OtherVT>;
 398 let ParserMatchClass = X86AbsMem32AsmOperand in
 399   def brtarget32 : Operand<OtherVT>;
 400 }
 401
 402 let RenderMethod = "addSrcIdxOperands" in {
 403   def X86SrcIdx8Operand : AsmOperandClass {
 404     let Name = "SrcIdx8";
 405     let SuperClasses = [X86Mem8AsmOperand];
 406   }
 407   def X86SrcIdx16Operand : AsmOperandClass {
 408     let Name = "SrcIdx16";
 409     let SuperClasses = [X86Mem16AsmOperand];
 410   }
 411   def X86SrcIdx32Operand : AsmOperandClass {
 412     let Name = "SrcIdx32";
 413     let SuperClasses = [X86Mem32AsmOperand];
 414   }
 415   def X86SrcIdx64Operand : AsmOperandClass {
 416     let Name = "SrcIdx64";
 417     let SuperClasses = [X86Mem64AsmOperand];
 418   }
 419 } // RenderMethod = "addSrcIdxOperands"
 420
 421 let RenderMethod = "addDstIdxOperands" in {
 422  def X86DstIdx8Operand : AsmOperandClass {
 423    let Name = "DstIdx8";
 424    let SuperClasses = [X86Mem8AsmOperand];
 425  }
 426  def X86DstIdx16Operand : AsmOperandClass {
 427    let Name = "DstIdx16";
 428    let SuperClasses = [X86Mem16AsmOperand];
 429  }
 430  def X86DstIdx32Operand : AsmOperandClass {
 431    let Name = "DstIdx32";
 432    let SuperClasses = [X86Mem32AsmOperand];
 433  }
 434  def X86DstIdx64Operand : AsmOperandClass {
 435    let Name = "DstIdx64";
 436    let SuperClasses = [X86Mem64AsmOperand];
 437  }
 438 } // RenderMethod = "addDstIdxOperands"
 439
 440 let RenderMethod = "addMemOffsOperands" in {
 441   def X86MemOffs16_8AsmOperand : AsmOperandClass {
 442     let Name = "MemOffs16_8";
 443     let SuperClasses = [X86Mem8AsmOperand];
 444   }
 445   def X86MemOffs16_16AsmOperand : AsmOperandClass {
 446     let Name = "MemOffs16_16";
 447     let SuperClasses = [X86Mem16AsmOperand];
 448   }
 449   def X86MemOffs16_32AsmOperand : AsmOperandClass {
 450     let Name = "MemOffs16_32";
 451     let SuperClasses = [X86Mem32AsmOperand];
 452   }
 453   def X86MemOffs32_8AsmOperand : AsmOperandClass {
 454     let Name = "MemOffs32_8";
 455     let SuperClasses = [X86Mem8AsmOperand];
 456   }
 457   def X86MemOffs32_16AsmOperand : AsmOperandClass {
 458     let Name = "MemOffs32_16";
 459     let SuperClasses = [X86Mem16AsmOperand];
 460   }
 461   def X86MemOffs32_32AsmOperand : AsmOperandClass {
 462     let Name = "MemOffs32_32";
 463     let SuperClasses = [X86Mem32AsmOperand];
 464   }
 465   def X86MemOffs32_64AsmOperand : AsmOperandClass {
 466     let Name = "MemOffs32_64";
 467     let SuperClasses = [X86Mem64AsmOperand];
 468   }
 469   def X86MemOffs64_8AsmOperand : AsmOperandClass {
 470     let Name = "MemOffs64_8";
 471     let SuperClasses = [X86Mem8AsmOperand];
 472   }
 473   def X86MemOffs64_16AsmOperand : AsmOperandClass {
 474     let Name = "MemOffs64_16";
 475     let SuperClasses = [X86Mem16AsmOperand];
 476   }
 477   def X86MemOffs64_32AsmOperand : AsmOperandClass {
 478     let Name = "MemOffs64_32";
 479     let SuperClasses = [X86Mem32AsmOperand];
 480   }
 481   def X86MemOffs64_64AsmOperand : AsmOperandClass {
 482     let Name = "MemOffs64_64";
 483     let SuperClasses = [X86Mem64AsmOperand];
 484   }
 485 } // RenderMethod = "addMemOffsOperands"
 486
 487 class X86SrcIdxOperand<string printMethod, AsmOperandClass parserMatchClass>
 488     : X86MemOperand<printMethod, parserMatchClass> {
 489   let MIOperandInfo = (ops ptr_rc, i8imm);
 490 }
 491
 492 class X86DstIdxOperand<string printMethod, AsmOperandClass parserMatchClass>
 493     : X86MemOperand<printMethod, parserMatchClass> {
 494   let MIOperandInfo = (ops ptr_rc);
 495 }
 496
 497 def srcidx8  : X86SrcIdxOperand<"printSrcIdx8",  X86SrcIdx8Operand>;
 498 def srcidx16 : X86SrcIdxOperand<"printSrcIdx16", X86SrcIdx16Operand>;
 499 def srcidx32 : X86SrcIdxOperand<"printSrcIdx32", X86SrcIdx32Operand>;
 500 def srcidx64 : X86SrcIdxOperand<"printSrcIdx64", X86SrcIdx64Operand>;
 501 def dstidx8  : X86DstIdxOperand<"printDstIdx8",  X86DstIdx8Operand>;
 502 def dstidx16 : X86DstIdxOperand<"printDstIdx16", X86DstIdx16Operand>;
 503 def dstidx32 : X86DstIdxOperand<"printDstIdx32", X86DstIdx32Operand>;
 504 def dstidx64 : X86DstIdxOperand<"printDstIdx64", X86DstIdx64Operand>;
 505
 506 class X86MemOffsOperand<Operand immOperand, string printMethod,
 507                         AsmOperandClass parserMatchClass>
 508     : X86MemOperand<printMethod, parserMatchClass> {
 509   let MIOperandInfo = (ops immOperand, i8imm);
 510 }
 511
 512 def offset16_8  : X86MemOffsOperand<i16imm, "printMemOffs8",
 513                                     X86MemOffs16_8AsmOperand>;
 514 def offset16_16 : X86MemOffsOperand<i16imm, "printMemOffs16",
 515                                     X86MemOffs16_16AsmOperand>;
 516 def offset16_32 : X86MemOffsOperand<i16imm, "printMemOffs32",
 517                                     X86MemOffs16_32AsmOperand>;
 518 def offset32_8  : X86MemOffsOperand<i32imm, "printMemOffs8",
 519                                     X86MemOffs32_8AsmOperand>;
 520 def offset32_16 : X86MemOffsOperand<i32imm, "printMemOffs16",
 521                                     X86MemOffs32_16AsmOperand>;
 522 def offset32_32 : X86MemOffsOperand<i32imm, "printMemOffs32",
 523                                     X86MemOffs32_32AsmOperand>;
 524 def offset32_64 : X86MemOffsOperand<i32imm, "printMemOffs64",
 525                                     X86MemOffs32_64AsmOperand>;
 526 def offset64_8  : X86MemOffsOperand<i64imm, "printMemOffs8",
 527                                     X86MemOffs64_8AsmOperand>;
 528 def offset64_16 : X86MemOffsOperand<i64imm, "printMemOffs16",
 529                                     X86MemOffs64_16AsmOperand>;
 530 def offset64_32 : X86MemOffsOperand<i64imm, "printMemOffs32",
 531                                     X86MemOffs64_32AsmOperand>;
 532 def offset64_64 : X86MemOffsOperand<i64imm, "printMemOffs64",
 533                                     X86MemOffs64_64AsmOperand>;
 534
 535 def SSECC : Operand<i8> {
 536   let PrintMethod = "printSSECC";
 537   let OperandType = "OPERAND_IMMEDIATE";
 538 }
 539
 540 def i8immZExt3 : ImmLeaf<i8, [{
 541   return Imm >= 0 && Imm < 8;
 542 }]>;
 543
 544 def AVXCC : Operand<i8> {
 545   let PrintMethod = "printAVXCC";
 546   let OperandType = "OPERAND_IMMEDIATE";
 547 }
 548
 549 def i8immZExt5 : ImmLeaf<i8, [{
 550   return Imm >= 0 && Imm < 32;
 551 }]>;
 552 // AVX-512 uses a 32-bit immediate in their intrinsics
 553 def i32immZExt5 : ImmLeaf<i32, [{
 554   return Imm >= 0 && Imm < 32;
 555 }]>;
 556
 557 class ImmSExtAsmOperandClass : AsmOperandClass {
 558   let SuperClasses = [ImmAsmOperand];
 559   let RenderMethod = "addImmOperands";
 560 }
 561
 562 def X86GR32orGR64AsmOperand : AsmOperandClass {
 563   let Name = "GR32orGR64";
 564 }
 565
 566 def GR32orGR64 : RegisterOperand<GR32> {
 567   let ParserMatchClass = X86GR32orGR64AsmOperand;
 568 }
 569
 570 def AVX512RC : Operand<i32> {
 571   let PrintMethod = "printRoundingControl";
 572   let OperandType = "OPERAND_IMMEDIATE";
 573 }
 574
 575 // Sign-extended immediate classes. We don't need to define the full lattice
 576 // here because there is no instruction with an ambiguity between ImmSExti64i32
 577 // and ImmSExti32i8.
 578 //
 579 // The strange ranges come from the fact that the assembler always works with
 580 // 64-bit immediates, but for a 16-bit target value we want to accept both "-1"
 581 // (which will be a -1ULL), and "0xFF" (-1 in 16-bits).
 582
 583 // [0, 0x7FFFFFFF]                                            |
 584 //   [0xFFFFFFFF80000000, 0xFFFFFFFFFFFFFFFF]
 585 def ImmSExti64i32AsmOperand : ImmSExtAsmOperandClass {
 586   let Name = "ImmSExti64i32";
 587 }
 588
 589 // [0, 0x0000007F] | [0x000000000000FF80, 0x000000000000FFFF] |
 590 //   [0xFFFFFFFFFFFFFF80, 0xFFFFFFFFFFFFFFFF]
 591 def ImmSExti16i8AsmOperand : ImmSExtAsmOperandClass {
 592   let Name = "ImmSExti16i8";
 593   let SuperClasses = [ImmSExti64i32AsmOperand];
 594 }
 595
 596 // [0, 0x0000007F] | [0x00000000FFFFFF80, 0x00000000FFFFFFFF] |
 597 //   [0xFFFFFFFFFFFFFF80, 0xFFFFFFFFFFFFFFFF]
 598 def ImmSExti32i8AsmOperand : ImmSExtAsmOperandClass {
 599   let Name = "ImmSExti32i8";
 600 }
 601
 602 // [0, 0x0000007F]                                            |
 603 //   [0xFFFFFFFFFFFFFF80, 0xFFFFFFFFFFFFFFFF]
 604 def ImmSExti64i8AsmOperand : ImmSExtAsmOperandClass {
 605   let Name = "ImmSExti64i8";
 606   let SuperClasses = [ImmSExti16i8AsmOperand, ImmSExti32i8AsmOperand,
 607                       ImmSExti64i32AsmOperand];
 608 }
 609
 610 // A couple of more descriptive operand definitions.
 611 // 16-bits but only 8 bits are significant.
 612 def i16i8imm  : Operand<i16> {
 613   let ParserMatchClass = ImmSExti16i8AsmOperand;
 614   let OperandType = "OPERAND_IMMEDIATE";
 615 }
 616 // 32-bits but only 8 bits are significant.
 617 def i32i8imm  : Operand<i32> {
 618   let ParserMatchClass = ImmSExti32i8AsmOperand;
 619   let OperandType = "OPERAND_IMMEDIATE";
 620 }
 621
 622 // 64-bits but only 32 bits are significant.
 623 def i64i32imm  : Operand<i64> {
 624   let ParserMatchClass = ImmSExti64i32AsmOperand;
 625   let OperandType = "OPERAND_IMMEDIATE";
 626 }
 627
 628 // 64-bits but only 32 bits are significant, and those bits are treated as being
 629 // pc relative.
 630 def i64i32imm_pcrel : Operand<i64> {
 631   let PrintMethod = "printPCRelImm";
 632   let ParserMatchClass = X86AbsMemAsmOperand;
 633   let OperandType = "OPERAND_PCREL";
 634 }
 635
 636 // 64-bits but only 8 bits are significant.
 637 def i64i8imm   : Operand<i64> {
 638   let ParserMatchClass = ImmSExti64i8AsmOperand;
 639   let OperandType = "OPERAND_IMMEDIATE";
 640 }
 641
 642 def lea64_32mem : Operand<i32> {
 643   let PrintMethod = "printi32mem";
 644   let MIOperandInfo = (ops GR64, i8imm, GR64_NOSP, i32imm, i8imm);
 645   let ParserMatchClass = X86MemAsmOperand;
 646 }
 647
 648 // Memory operands that use 64-bit pointers in both ILP32 and LP64.
 649 def lea64mem : Operand<i64> {
 650   let PrintMethod = "printi64mem";
 651   let MIOperandInfo = (ops GR64, i8imm, GR64_NOSP, i32imm, i8imm);
 652   let ParserMatchClass = X86MemAsmOperand;
 653 }
 654
 655
 656 //===----------------------------------------------------------------------===//
 657 // X86 Complex Pattern Definitions.
 658 //
 659
 660 // Define X86 specific addressing mode.
 661 def addr      : ComplexPattern<iPTR, 5, "SelectAddr", [], [SDNPWantParent]>;
 662 def lea32addr : ComplexPattern<i32, 5, "SelectLEAAddr",
 663                                [add, sub, mul, X86mul_imm, shl, or, frameindex],
 664                                []>;
 665 // In 64-bit mode 32-bit LEAs can use RIP-relative addressing.
 666 def lea64_32addr : ComplexPattern<i32, 5, "SelectLEA64_32Addr",
 667                                   [add, sub, mul, X86mul_imm, shl, or,
 668                                    frameindex, X86WrapperRIP],
 669                                   []>;
 670
 671 def tls32addr : ComplexPattern<i32, 5, "SelectTLSADDRAddr",
 672                                [tglobaltlsaddr], []>;
 673
 674 def tls32baseaddr : ComplexPattern<i32, 5, "SelectTLSADDRAddr",
 675                                [tglobaltlsaddr], []>;
 676
 677 def lea64addr : ComplexPattern<i64, 5, "SelectLEAAddr",
 678                         [add, sub, mul, X86mul_imm, shl, or, frameindex,
 679                          X86WrapperRIP], []>;
 680
 681 def tls64addr : ComplexPattern<i64, 5, "SelectTLSADDRAddr",
 682                                [tglobaltlsaddr], []>;
 683
 684 def tls64baseaddr : ComplexPattern<i64, 5, "SelectTLSADDRAddr",
 685                                [tglobaltlsaddr], []>;
 686
 687 //===----------------------------------------------------------------------===//
 688 // X86 Instruction Predicate Definitions.
 689 def HasCMov      : Predicate<"Subtarget->hasCMov()">;
 690 def NoCMov       : Predicate<"!Subtarget->hasCMov()">;
 691
 692 def HasMMX       : Predicate<"Subtarget->hasMMX()">;
 693 def Has3DNow     : Predicate<"Subtarget->has3DNow()">;
 694 def Has3DNowA    : Predicate<"Subtarget->has3DNowA()">;
 695 def HasSSE1      : Predicate<"Subtarget->hasSSE1()">;
 696 def UseSSE1      : Predicate<"Subtarget->hasSSE1() && !Subtarget->hasAVX()">;
 697 def HasSSE2      : Predicate<"Subtarget->hasSSE2()">;
 698 def UseSSE2      : Predicate<"Subtarget->hasSSE2() && !Subtarget->hasAVX()">;
 699 def HasSSE3      : Predicate<"Subtarget->hasSSE3()">;
 700 def UseSSE3      : Predicate<"Subtarget->hasSSE3() && !Subtarget->hasAVX()">;
 701 def HasSSSE3     : Predicate<"Subtarget->hasSSSE3()">;
 702 def UseSSSE3     : Predicate<"Subtarget->hasSSSE3() && !Subtarget->hasAVX()">;
 703 def HasSSE41     : Predicate<"Subtarget->hasSSE41()">;
 704 def NoSSE41      : Predicate<"!Subtarget->hasSSE41()">;
 705 def UseSSE41     : Predicate<"Subtarget->hasSSE41() && !Subtarget->hasAVX()">;
 706 def HasSSE42     : Predicate<"Subtarget->hasSSE42()">;
 707 def UseSSE42     : Predicate<"Subtarget->hasSSE42() && !Subtarget->hasAVX()">;
 708 def HasSSE4A     : Predicate<"Subtarget->hasSSE4A()">;
 709 def HasAVX       : Predicate<"Subtarget->hasAVX()">;
 710 def HasAVX2      : Predicate<"Subtarget->hasAVX2()">;
 711 def HasAVX1Only  : Predicate<"Subtarget->hasAVX() && !Subtarget->hasAVX2()">;
 712 def HasAVX512    : Predicate<"Subtarget->hasAVX512()">,
 713                      AssemblerPredicate<"FeatureAVX512", "AVX-512 ISA">;
 714 def UseAVX       : Predicate<"Subtarget->hasAVX() && !Subtarget->hasAVX512()">;
 715 def UseAVX2      : Predicate<"Subtarget->hasAVX2() && !Subtarget->hasAVX512()">;
 716 def NoAVX512     : Predicate<"!Subtarget->hasAVX512()">;
 717 def HasCDI       : Predicate<"Subtarget->hasCDI()">;
 718 def HasPFI       : Predicate<"Subtarget->hasPFI()">;
 719 def HasERI       : Predicate<"Subtarget->hasERI()">;
 720 def HasDQI       : Predicate<"Subtarget->hasDQI()">;
 721 def NoDQI        : Predicate<"!Subtarget->hasDQI()">;
 722 def HasBWI       : Predicate<"Subtarget->hasBWI()">;
 723 def HasVLX       : Predicate<"Subtarget->hasVLX()">,
 724                      AssemblerPredicate<"FeatureVLX", "AVX-512 VLX ISA">;
 725 def NoVLX        : Predicate<"!Subtarget->hasVLX()">;
 726
 727 def HasPOPCNT    : Predicate<"Subtarget->hasPOPCNT()">;
 728 def HasAES       : Predicate<"Subtarget->hasAES()">;
 729 def HasPCLMUL    : Predicate<"Subtarget->hasPCLMUL()">;
 730 def HasFMA       : Predicate<"Subtarget->hasFMA()">;
 731 def UseFMAOnAVX  : Predicate<"Subtarget->hasFMA() && !Subtarget->hasAVX512()">;
 732 def HasFMA4      : Predicate<"Subtarget->hasFMA4()">;
 733 def HasXOP       : Predicate<"Subtarget->hasXOP()">;
 734 def HasTBM       : Predicate<"Subtarget->hasTBM()">;
 735 def HasMOVBE     : Predicate<"Subtarget->hasMOVBE()">;
 736 def HasRDRAND    : Predicate<"Subtarget->hasRDRAND()">;
 737 def HasF16C      : Predicate<"Subtarget->hasF16C()">;
 738 def HasFSGSBase  : Predicate<"Subtarget->hasFSGSBase()">;
 739 def HasLZCNT     : Predicate<"Subtarget->hasLZCNT()">;
 740 def HasBMI       : Predicate<"Subtarget->hasBMI()">;
 741 def HasBMI2      : Predicate<"Subtarget->hasBMI2()">;
 742 def HasRTM       : Predicate<"Subtarget->hasRTM()">;
 743 def HasHLE       : Predicate<"Subtarget->hasHLE()">;
 744 def HasTSX       : Predicate<"Subtarget->hasRTM() || Subtarget->hasHLE()">;
 745 def HasADX       : Predicate<"Subtarget->hasADX()">;
 746 def HasSHA       : Predicate<"Subtarget->hasSHA()">;
 747 def HasSGX       : Predicate<"Subtarget->hasSGX()">;
 748 def HasPRFCHW    : Predicate<"Subtarget->hasPRFCHW()">;
 749 def HasRDSEED    : Predicate<"Subtarget->hasRDSEED()">;
 750 def HasSMAP      : Predicate<"Subtarget->hasSMAP()">;
 751 def HasPrefetchW : Predicate<"Subtarget->hasPRFCHW()">;
 752 def FPStackf32   : Predicate<"!Subtarget->hasSSE1()">;
 753 def FPStackf64   : Predicate<"!Subtarget->hasSSE2()">;
 754 def HasCmpxchg16b: Predicate<"Subtarget->hasCmpxchg16b()">;
 755 def Not64BitMode : Predicate<"!Subtarget->is64Bit()">,
 756                              AssemblerPredicate<"!Mode64Bit", "Not 64-bit mode">;
 757 def In64BitMode  : Predicate<"Subtarget->is64Bit()">,
 758                              AssemblerPredicate<"Mode64Bit", "64-bit mode">;
 759 def IsLP64  : Predicate<"Subtarget->isTarget64BitLP64()">;
 760 def NotLP64 : Predicate<"!Subtarget->isTarget64BitLP64()">;
 761 def In16BitMode  : Predicate<"Subtarget->is16Bit()">,
 762                              AssemblerPredicate<"Mode16Bit", "16-bit mode">;
 763 def Not16BitMode : Predicate<"!Subtarget->is16Bit()">,
 764                              AssemblerPredicate<"!Mode16Bit", "Not 16-bit mode">;
 765 def In32BitMode  : Predicate<"Subtarget->is32Bit()">,
 766                              AssemblerPredicate<"Mode32Bit", "32-bit mode">;
 767 def IsWin64      : Predicate<"Subtarget->isTargetWin64()">;
 768 def IsNaCl       : Predicate<"Subtarget->isTargetNaCl()">;
 769 def NotNaCl      : Predicate<"!Subtarget->isTargetNaCl()">;
 770 def SmallCode    : Predicate<"TM.getCodeModel() == CodeModel::Small">;
 771 def KernelCode   : Predicate<"TM.getCodeModel() == CodeModel::Kernel">;
 772 def FarData      : Predicate<"TM.getCodeModel() != CodeModel::Small &&"
 773                              "TM.getCodeModel() != CodeModel::Kernel">;
 774 def NearData     : Predicate<"TM.getCodeModel() == CodeModel::Small ||"
 775                              "TM.getCodeModel() == CodeModel::Kernel">;
 776 def IsStatic     : Predicate<"TM.getRelocationModel() == Reloc::Static">;
 777 def IsNotPIC     : Predicate<"TM.getRelocationModel() != Reloc::PIC_">;
 778 def OptForSize   : Predicate<"OptForSize">;
 779 def OptForSpeed  : Predicate<"!OptForSize">;
 780 def FastBTMem    : Predicate<"!Subtarget->isBTMemSlow()">;
 781 def CallImmAddr  : Predicate<"Subtarget->IsLegalToCallImmediateAddr(TM)">;
 782 def FavorMemIndirectCall  : Predicate<"!Subtarget->callRegIndirect()">;
 783 def NotSlowIncDec : Predicate<"!Subtarget->slowIncDec()">;
 784 def HasFastMem32 : Predicate<"!Subtarget->isUnalignedMem32Slow()">;
 785
 786 //===----------------------------------------------------------------------===//
 787 // X86 Instruction Format Definitions.
 788 //
 789
 790 include "X86InstrFormats.td"
 791
 792 //===----------------------------------------------------------------------===//
 793 // Pattern fragments.
 794 //
 795
 796 // X86 specific condition code. These correspond to CondCode in
 797 // X86InstrInfo.h. They must be kept in synch.
 798 def X86_COND_A   : PatLeaf<(i8 0)>;  // alt. COND_NBE
 799 def X86_COND_AE  : PatLeaf<(i8 1)>;  // alt. COND_NC
 800 def X86_COND_B   : PatLeaf<(i8 2)>;  // alt. COND_C
 801 def X86_COND_BE  : PatLeaf<(i8 3)>;  // alt. COND_NA
 802 def X86_COND_E   : PatLeaf<(i8 4)>;  // alt. COND_Z
 803 def X86_COND_G   : PatLeaf<(i8 5)>;  // alt. COND_NLE
 804 def X86_COND_GE  : PatLeaf<(i8 6)>;  // alt. COND_NL
 805 def X86_COND_L   : PatLeaf<(i8 7)>;  // alt. COND_NGE
 806 def X86_COND_LE  : PatLeaf<(i8 8)>;  // alt. COND_NG
 807 def X86_COND_NE  : PatLeaf<(i8 9)>;  // alt. COND_NZ
 808 def X86_COND_NO  : PatLeaf<(i8 10)>;
 809 def X86_COND_NP  : PatLeaf<(i8 11)>; // alt. COND_PO
 810 def X86_COND_NS  : PatLeaf<(i8 12)>;
 811 def X86_COND_O   : PatLeaf<(i8 13)>;
 812 def X86_COND_P   : PatLeaf<(i8 14)>; // alt. COND_PE
 813 def X86_COND_S   : PatLeaf<(i8 15)>;
 814
 815 // Predicate used to help when pattern matching LZCNT/TZCNT.
 816 def X86_COND_E_OR_NE : ImmLeaf<i8, [{
 817   return (Imm == X86::COND_E) || (Imm == X86::COND_NE);
 818 }]>;
 819
 820 let FastIselShouldIgnore = 1 in { // FastIsel should ignore all simm8 instrs.
 821   def i16immSExt8  : ImmLeaf<i16, [{ return Imm == (int8_t)Imm; }]>;
 822   def i32immSExt8  : ImmLeaf<i32, [{ return Imm == (int8_t)Imm; }]>;
 823   def i64immSExt8  : ImmLeaf<i64, [{ return Imm == (int8_t)Imm; }]>;
 824 }
 825
 826 def i64immSExt32 : ImmLeaf<i64, [{ return Imm == (int32_t)Imm; }]>;
 827
 828
 829 // i64immZExt32 predicate - True if the 64-bit immediate fits in a 32-bit
 830 // unsigned field.
 831 def i64immZExt32 : ImmLeaf<i64, [{ return (uint64_t)Imm == (uint32_t)Imm; }]>;
 832
 833 def i64immZExt32SExt8 : ImmLeaf<i64, [{
 834   return (uint64_t)Imm == (uint32_t)Imm && (int32_t)Imm == (int8_t)Imm;
 835 }]>;
 836
 837 // Helper fragments for loads.
 838 // It's always safe to treat a anyext i16 load as a i32 load if the i16 is
 839 // known to be 32-bit aligned or better. Ditto for i8 to i16.
 840 def loadi16 : PatFrag<(ops node:$ptr), (i16 (unindexedload node:$ptr)), [{
 841   LoadSDNode *LD = cast<LoadSDNode>(N);
 842   ISD::LoadExtType ExtType = LD->getExtensionType();
 843   if (ExtType == ISD::NON_EXTLOAD)
 844     return true;
 845   if (ExtType == ISD::EXTLOAD)
 846     return LD->getAlignment() >= 2 && !LD->isVolatile();
 847   return false;
 848 }]>;
 849
 850 def loadi16_anyext : PatFrag<(ops node:$ptr), (i32 (unindexedload node:$ptr)),[{
 851   LoadSDNode *LD = cast<LoadSDNode>(N);
 852   ISD::LoadExtType ExtType = LD->getExtensionType();
 853   if (ExtType == ISD::EXTLOAD)
 854     return LD->getAlignment() >= 2 && !LD->isVolatile();
 855   return false;
 856 }]>;
 857
 858 def loadi32 : PatFrag<(ops node:$ptr), (i32 (unindexedload node:$ptr)), [{
 859   LoadSDNode *LD = cast<LoadSDNode>(N);
 860   ISD::LoadExtType ExtType = LD->getExtensionType();
 861   if (ExtType == ISD::NON_EXTLOAD)
 862     return true;
 863   if (ExtType == ISD::EXTLOAD)
 864     return LD->getAlignment() >= 4 && !LD->isVolatile();
 865   return false;
 866 }]>;
 867
 868 def loadi8  : PatFrag<(ops node:$ptr), (i8  (load node:$ptr))>;
 869 def loadi64 : PatFrag<(ops node:$ptr), (i64 (load node:$ptr))>;
 870 def loadf32 : PatFrag<(ops node:$ptr), (f32 (load node:$ptr))>;
 871 def loadf64 : PatFrag<(ops node:$ptr), (f64 (load node:$ptr))>;
 872 def loadf80 : PatFrag<(ops node:$ptr), (f80 (load node:$ptr))>;
 873
 874 def sextloadi16i8  : PatFrag<(ops node:$ptr), (i16 (sextloadi8 node:$ptr))>;
 875 def sextloadi32i8  : PatFrag<(ops node:$ptr), (i32 (sextloadi8 node:$ptr))>;
 876 def sextloadi32i16 : PatFrag<(ops node:$ptr), (i32 (sextloadi16 node:$ptr))>;
 877 def sextloadi64i8  : PatFrag<(ops node:$ptr), (i64 (sextloadi8 node:$ptr))>;
 878 def sextloadi64i16 : PatFrag<(ops node:$ptr), (i64 (sextloadi16 node:$ptr))>;
 879 def sextloadi64i32 : PatFrag<(ops node:$ptr), (i64 (sextloadi32 node:$ptr))>;
 880
 881 def zextloadi8i1   : PatFrag<(ops node:$ptr), (i8  (zextloadi1 node:$ptr))>;
 882 def zextloadi16i1  : PatFrag<(ops node:$ptr), (i16 (zextloadi1 node:$ptr))>;
 883 def zextloadi32i1  : PatFrag<(ops node:$ptr), (i32 (zextloadi1 node:$ptr))>;
 884 def zextloadi16i8  : PatFrag<(ops node:$ptr), (i16 (zextloadi8 node:$ptr))>;
 885 def zextloadi32i8  : PatFrag<(ops node:$ptr), (i32 (zextloadi8 node:$ptr))>;
 886 def zextloadi32i16 : PatFrag<(ops node:$ptr), (i32 (zextloadi16 node:$ptr))>;
 887 def zextloadi64i1  : PatFrag<(ops node:$ptr), (i64 (zextloadi1 node:$ptr))>;
 888 def zextloadi64i8  : PatFrag<(ops node:$ptr), (i64 (zextloadi8 node:$ptr))>;
 889 def zextloadi64i16 : PatFrag<(ops node:$ptr), (i64 (zextloadi16 node:$ptr))>;
 890 def zextloadi64i32 : PatFrag<(ops node:$ptr), (i64 (zextloadi32 node:$ptr))>;
 891
 892 def extloadi8i1    : PatFrag<(ops node:$ptr), (i8  (extloadi1 node:$ptr))>;
 893 def extloadi16i1   : PatFrag<(ops node:$ptr), (i16 (extloadi1 node:$ptr))>;
 894 def extloadi32i1   : PatFrag<(ops node:$ptr), (i32 (extloadi1 node:$ptr))>;
 895 def extloadi16i8   : PatFrag<(ops node:$ptr), (i16 (extloadi8 node:$ptr))>;
 896 def extloadi32i8   : PatFrag<(ops node:$ptr), (i32 (extloadi8 node:$ptr))>;
 897 def extloadi32i16  : PatFrag<(ops node:$ptr), (i32 (extloadi16 node:$ptr))>;
 898 def extloadi64i1   : PatFrag<(ops node:$ptr), (i64 (extloadi1 node:$ptr))>;
 899 def extloadi64i8   : PatFrag<(ops node:$ptr), (i64 (extloadi8 node:$ptr))>;
 900 def extloadi64i16  : PatFrag<(ops node:$ptr), (i64 (extloadi16 node:$ptr))>;
 901 def extloadi64i32  : PatFrag<(ops node:$ptr), (i64 (extloadi32 node:$ptr))>;
 902
 903
 904 // An 'and' node with a single use.
 905 def and_su : PatFrag<(ops node:$lhs, node:$rhs), (and node:$lhs, node:$rhs), [{
 906   return N->hasOneUse();
 907 }]>;
 908 // An 'srl' node with a single use.
 909 def srl_su : PatFrag<(ops node:$lhs, node:$rhs), (srl node:$lhs, node:$rhs), [{
 910   return N->hasOneUse();
 911 }]>;
 912 // An 'trunc' node with a single use.
 913 def trunc_su : PatFrag<(ops node:$src), (trunc node:$src), [{
 914   return N->hasOneUse();
 915 }]>;
 916
 917 //===----------------------------------------------------------------------===//
 918 // Instruction list.
 919 //
 920
 921 // Nop
 922 let hasSideEffects = 0, SchedRW = [WriteZero] in {
 923   def NOOP : I<0x90, RawFrm, (outs), (ins), "nop", [], IIC_NOP>;
 924   def NOOPW : I<0x1f, MRMXm, (outs), (ins i16mem:$zero),
 925                 "nop{w}\t$zero", [], IIC_NOP>, TB, OpSize16;
 926   def NOOPL : I<0x1f, MRMXm, (outs), (ins i32mem:$zero),
 927                 "nop{l}\t$zero", [], IIC_NOP>, TB, OpSize32;
 928 }
 929
 930
 931 // Constructing a stack frame.
 932 def ENTER : Ii16<0xC8, RawFrmImm8, (outs), (ins i16imm:$len, i8imm:$lvl),
 933                  "enter\t$len, $lvl", [], IIC_ENTER>, Sched<[WriteMicrocoded]>;
 934
 935 let SchedRW = [WriteALU] in {
 936 let Defs = [EBP, ESP], Uses = [EBP, ESP], mayLoad = 1, hasSideEffects=0 in
 937 def LEAVE    : I<0xC9, RawFrm,
 938                  (outs), (ins), "leave", [], IIC_LEAVE>,
 939                  Requires<[Not64BitMode]>;
 940
 941 let Defs = [RBP,RSP], Uses = [RBP,RSP], mayLoad = 1, hasSideEffects = 0 in
 942 def LEAVE64  : I<0xC9, RawFrm,
 943                  (outs), (ins), "leave", [], IIC_LEAVE>,
 944                  Requires<[In64BitMode]>;
 945 } // SchedRW
 946
 947 //===----------------------------------------------------------------------===//
 948 //  Miscellaneous Instructions.
 949 //
 950
 951 let Defs = [ESP], Uses = [ESP], hasSideEffects=0 in {
 952 let mayLoad = 1, SchedRW = [WriteLoad] in {
 953 def POP16r  : I<0x58, AddRegFrm, (outs GR16:$reg), (ins), "pop{w}\t$reg", [],
 954                 IIC_POP_REG16>, OpSize16;
 955 def POP32r  : I<0x58, AddRegFrm, (outs GR32:$reg), (ins), "pop{l}\t$reg", [],
 956                 IIC_POP_REG>, OpSize32, Requires<[Not64BitMode]>;
 957 def POP16rmr: I<0x8F, MRM0r, (outs GR16:$reg), (ins), "pop{w}\t$reg", [],
 958                 IIC_POP_REG>, OpSize16;
 959 def POP16rmm: I<0x8F, MRM0m, (outs), (ins i16mem:$dst), "pop{w}\t$dst", [],
 960                 IIC_POP_MEM>, OpSize16;
 961 def POP32rmr: I<0x8F, MRM0r, (outs GR32:$reg), (ins), "pop{l}\t$reg", [],
 962                 IIC_POP_REG>, OpSize32, Requires<[Not64BitMode]>;
 963 def POP32rmm: I<0x8F, MRM0m, (outs), (ins i32mem:$dst), "pop{l}\t$dst", [],
 964                 IIC_POP_MEM>, OpSize32, Requires<[Not64BitMode]>;
 965 } // mayLoad, SchedRW
 966
 967 let mayStore = 1, SchedRW = [WriteStore] in {
 968 def PUSH16r  : I<0x50, AddRegFrm, (outs), (ins GR16:$reg), "push{w}\t$reg",[],
 969                  IIC_PUSH_REG>, OpSize16;
 970 def PUSH32r  : I<0x50, AddRegFrm, (outs), (ins GR32:$reg), "push{l}\t$reg",[],
 971                  IIC_PUSH_REG>, OpSize32, Requires<[Not64BitMode]>;
 972 def PUSH16rmr: I<0xFF, MRM6r, (outs), (ins GR16:$reg), "push{w}\t$reg",[],
 973                  IIC_PUSH_REG>, OpSize16;
 974 def PUSH16rmm: I<0xFF, MRM6m, (outs), (ins i16mem:$src), "push{w}\t$src",[],
 975                  IIC_PUSH_MEM>, OpSize16;
 976 def PUSH32rmr: I<0xFF, MRM6r, (outs), (ins GR32:$reg), "push{l}\t$reg",[],
 977                  IIC_PUSH_REG>, OpSize32, Requires<[Not64BitMode]>;
 978 def PUSH32rmm: I<0xFF, MRM6m, (outs), (ins i32mem:$src), "push{l}\t$src",[],
 979                  IIC_PUSH_MEM>, OpSize32, Requires<[Not64BitMode]>;
 980
 981 def PUSH16i8 : Ii8<0x6a, RawFrm, (outs), (ins i16i8imm:$imm),
 982                    "push{w}\t$imm", [], IIC_PUSH_IMM>, OpSize16,
 983                    Requires<[Not64BitMode]>;
 984 def PUSH32i8 : Ii8<0x6a, RawFrm, (outs), (ins i32i8imm:$imm),
 985                    "push{l}\t$imm", [], IIC_PUSH_IMM>, OpSize32,
 986                    Requires<[Not64BitMode]>;
 987 def PUSHi16  : Ii16<0x68, RawFrm, (outs), (ins i16imm:$imm),
 988                    "push{w}\t$imm", [], IIC_PUSH_IMM>, OpSize16,
 989                    Requires<[Not64BitMode]>;
 990 def PUSHi32  : Ii32<0x68, RawFrm, (outs), (ins i32imm:$imm),
 991                    "push{l}\t$imm", [], IIC_PUSH_IMM>, OpSize32,
 992                    Requires<[Not64BitMode]>;
 993 } // mayStore, SchedRW
 994 }
 995
 996 let Defs = [ESP, EFLAGS], Uses = [ESP], mayLoad = 1, hasSideEffects=0,
 997     SchedRW = [WriteLoad] in {
 998 def POPF16   : I<0x9D, RawFrm, (outs), (ins), "popf{w}", [], IIC_POP_F>,
 999                 OpSize16;
1000 def POPF32   : I<0x9D, RawFrm, (outs), (ins), "popf{l|d}", [], IIC_POP_FD>,
1001                 OpSize32, Requires<[Not64BitMode]>;
1002 }
1003
1004 let Defs = [ESP], Uses = [ESP, EFLAGS], mayStore = 1, hasSideEffects=0,
1005     SchedRW = [WriteStore] in {
1006 def PUSHF16  : I<0x9C, RawFrm, (outs), (ins), "pushf{w}", [], IIC_PUSH_F>,
1007                  OpSize16;
1008 def PUSHF32  : I<0x9C, RawFrm, (outs), (ins), "pushf{l|d}", [], IIC_PUSH_F>,
1009                OpSize32, Requires<[Not64BitMode]>;
1010 }
1011
1012 let Defs = [RSP], Uses = [RSP], hasSideEffects=0 in {
1013 let mayLoad = 1, SchedRW = [WriteLoad] in {
1014 def POP64r   : I<0x58, AddRegFrm, (outs GR64:$reg), (ins), "pop{q}\t$reg", [],
1015                  IIC_POP_REG>, OpSize32, Requires<[In64BitMode]>;
1016 def POP64rmr: I<0x8F, MRM0r, (outs GR64:$reg), (ins), "pop{q}\t$reg", [],
1017                 IIC_POP_REG>, OpSize32, Requires<[In64BitMode]>;
1018 def POP64rmm: I<0x8F, MRM0m, (outs), (ins i64mem:$dst), "pop{q}\t$dst", [],
1019                 IIC_POP_MEM>, OpSize32, Requires<[In64BitMode]>;
1020 } // mayLoad, SchedRW
1021 let mayStore = 1, SchedRW = [WriteStore] in {
1022 def PUSH64r  : I<0x50, AddRegFrm, (outs), (ins GR64:$reg), "push{q}\t$reg", [],
1023                  IIC_PUSH_REG>, OpSize32, Requires<[In64BitMode]>;
1024 def PUSH64rmr: I<0xFF, MRM6r, (outs), (ins GR64:$reg), "push{q}\t$reg", [],
1025                  IIC_PUSH_REG>, OpSize32, Requires<[In64BitMode]>;
1026 def PUSH64rmm: I<0xFF, MRM6m, (outs), (ins i64mem:$src), "push{q}\t$src", [],
1027                  IIC_PUSH_MEM>, OpSize32, Requires<[In64BitMode]>;
1028 } // mayStore, SchedRW
1029 }
1030
1031 let Defs = [RSP], Uses = [RSP], hasSideEffects = 0, mayStore = 1,
1032     SchedRW = [WriteStore] in {
1033 def PUSH64i8   : Ii8<0x6a, RawFrm, (outs), (ins i64i8imm:$imm),
1034                     "push{q}\t$imm", [], IIC_PUSH_IMM>, Requires<[In64BitMode]>;
1035 def PUSH64i16  : Ii16<0x68, RawFrm, (outs), (ins i16imm:$imm),
1036                     "push{w}\t$imm", [], IIC_PUSH_IMM>, OpSize16,
1037                     Requires<[In64BitMode]>;
1038 def PUSH64i32  : Ii32S<0x68, RawFrm, (outs), (ins i64i32imm:$imm),
1039                     "push{q}\t$imm", [], IIC_PUSH_IMM>, OpSize32,
1040                     Requires<[In64BitMode]>;
1041 }
1042
1043 let Defs = [RSP, EFLAGS], Uses = [RSP], mayLoad = 1, hasSideEffects=0 in
1044 def POPF64   : I<0x9D, RawFrm, (outs), (ins), "popfq", [], IIC_POP_FD>,
1045                OpSize32, Requires<[In64BitMode]>, Sched<[WriteLoad]>;
1046 let Defs = [RSP], Uses = [RSP, EFLAGS], mayStore = 1, hasSideEffects=0 in
1047 def PUSHF64    : I<0x9C, RawFrm, (outs), (ins), "pushfq", [], IIC_PUSH_F>,
1048                  OpSize32, Requires<[In64BitMode]>, Sched<[WriteStore]>;
1049
1050 let Defs = [EDI, ESI, EBP, EBX, EDX, ECX, EAX, ESP], Uses = [ESP],
1051     mayLoad = 1, hasSideEffects = 0, SchedRW = [WriteLoad] in {
1052 def POPA32   : I<0x61, RawFrm, (outs), (ins), "popal", [], IIC_POP_A>,
1053                OpSize32, Requires<[Not64BitMode]>;
1054 def POPA16   : I<0x61, RawFrm, (outs), (ins), "popaw", [], IIC_POP_A>,
1055                OpSize16, Requires<[Not64BitMode]>;
1056 }
1057 let Defs = [ESP], Uses = [EDI, ESI, EBP, EBX, EDX, ECX, EAX, ESP],
1058     mayStore = 1, hasSideEffects = 0, SchedRW = [WriteStore] in {
1059 def PUSHA32  : I<0x60, RawFrm, (outs), (ins), "pushal", [], IIC_PUSH_A>,
1060                OpSize32, Requires<[Not64BitMode]>;
1061 def PUSHA16  : I<0x60, RawFrm, (outs), (ins), "pushaw", [], IIC_PUSH_A>,
1062                OpSize16, Requires<[Not64BitMode]>;
1063 }
1064
1065 let Constraints = "$src = $dst", SchedRW = [WriteALU] in {
1066 // GR32 = bswap GR32
1067 def BSWAP32r : I<0xC8, AddRegFrm,
1068                  (outs GR32:$dst), (ins GR32:$src),
1069                  "bswap{l}\t$dst",
1070                  [(set GR32:$dst, (bswap GR32:$src))], IIC_BSWAP>, OpSize32, TB;
1071
1072 def BSWAP64r : RI<0xC8, AddRegFrm, (outs GR64:$dst), (ins GR64:$src),
1073                   "bswap{q}\t$dst",
1074                   [(set GR64:$dst, (bswap GR64:$src))], IIC_BSWAP>, TB;
1075 } // Constraints = "$src = $dst", SchedRW
1076
1077 // Bit scan instructions.
1078 let Defs = [EFLAGS] in {
1079 def BSF16rr  : I<0xBC, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
1080                  "bsf{w}\t{$src, $dst|$dst, $src}",
1081                  [(set GR16:$dst, EFLAGS, (X86bsf GR16:$src))],
1082                   IIC_BIT_SCAN_REG>, PS, OpSize16, Sched<[WriteShift]>;
1083 def BSF16rm  : I<0xBC, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
1084                  "bsf{w}\t{$src, $dst|$dst, $src}",
1085                  [(set GR16:$dst, EFLAGS, (X86bsf (loadi16 addr:$src)))],
1086                   IIC_BIT_SCAN_MEM>, PS, OpSize16, Sched<[WriteShiftLd]>;
1087 def BSF32rr  : I<0xBC, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
1088                  "bsf{l}\t{$src, $dst|$dst, $src}",
1089                  [(set GR32:$dst, EFLAGS, (X86bsf GR32:$src))],
1090                  IIC_BIT_SCAN_REG>, PS, OpSize32, Sched<[WriteShift]>;
1091 def BSF32rm  : I<0xBC, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
1092                  "bsf{l}\t{$src, $dst|$dst, $src}",
1093                  [(set GR32:$dst, EFLAGS, (X86bsf (loadi32 addr:$src)))],
1094                  IIC_BIT_SCAN_MEM>, PS, OpSize32, Sched<[WriteShiftLd]>;
1095 def BSF64rr  : RI<0xBC, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
1096                   "bsf{q}\t{$src, $dst|$dst, $src}",
1097                   [(set GR64:$dst, EFLAGS, (X86bsf GR64:$src))],
1098                   IIC_BIT_SCAN_REG>, PS, Sched<[WriteShift]>;
1099 def BSF64rm  : RI<0xBC, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
1100                   "bsf{q}\t{$src, $dst|$dst, $src}",
1101                   [(set GR64:$dst, EFLAGS, (X86bsf (loadi64 addr:$src)))],
1102                   IIC_BIT_SCAN_MEM>, PS, Sched<[WriteShiftLd]>;
1103
1104 def BSR16rr  : I<0xBD, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
1105                  "bsr{w}\t{$src, $dst|$dst, $src}",
1106                  [(set GR16:$dst, EFLAGS, (X86bsr GR16:$src))],
1107                  IIC_BIT_SCAN_REG>, PS, OpSize16, Sched<[WriteShift]>;
1108 def BSR16rm  : I<0xBD, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
1109                  "bsr{w}\t{$src, $dst|$dst, $src}",
1110                  [(set GR16:$dst, EFLAGS, (X86bsr (loadi16 addr:$src)))],
1111                  IIC_BIT_SCAN_MEM>, PS, OpSize16, Sched<[WriteShiftLd]>;
1112 def BSR32rr  : I<0xBD, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
1113                  "bsr{l}\t{$src, $dst|$dst, $src}",
1114                  [(set GR32:$dst, EFLAGS, (X86bsr GR32:$src))],
1115                  IIC_BIT_SCAN_REG>, PS, OpSize32, Sched<[WriteShift]>;
1116 def BSR32rm  : I<0xBD, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
1117                  "bsr{l}\t{$src, $dst|$dst, $src}",
1118                  [(set GR32:$dst, EFLAGS, (X86bsr (loadi32 addr:$src)))],
1119                  IIC_BIT_SCAN_MEM>, PS, OpSize32, Sched<[WriteShiftLd]>;
1120 def BSR64rr  : RI<0xBD, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
1121                   "bsr{q}\t{$src, $dst|$dst, $src}",
1122                   [(set GR64:$dst, EFLAGS, (X86bsr GR64:$src))],
1123                   IIC_BIT_SCAN_REG>, PS, Sched<[WriteShift]>;
1124 def BSR64rm  : RI<0xBD, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
1125                   "bsr{q}\t{$src, $dst|$dst, $src}",
1126                   [(set GR64:$dst, EFLAGS, (X86bsr (loadi64 addr:$src)))],
1127                   IIC_BIT_SCAN_MEM>, PS, Sched<[WriteShiftLd]>;
1128 } // Defs = [EFLAGS]
1129
1130 let SchedRW = [WriteMicrocoded] in {
1131 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1132 let Defs = [EDI,ESI], Uses = [EDI,ESI,EFLAGS] in {
1133 def MOVSB : I<0xA4, RawFrmDstSrc, (outs dstidx8:$dst), (ins srcidx8:$src),
1134               "movsb\t{$src, $dst|$dst, $src}", [], IIC_MOVS>;
1135 def MOVSW : I<0xA5, RawFrmDstSrc, (outs dstidx16:$dst), (ins srcidx16:$src),
1136               "movsw\t{$src, $dst|$dst, $src}", [], IIC_MOVS>, OpSize16;
1137 def MOVSL : I<0xA5, RawFrmDstSrc, (outs dstidx32:$dst), (ins srcidx32:$src),
1138               "movs{l|d}\t{$src, $dst|$dst, $src}", [], IIC_MOVS>, OpSize32;
1139 def MOVSQ : RI<0xA5, RawFrmDstSrc, (outs dstidx64:$dst), (ins srcidx64:$src),
1140                "movsq\t{$src, $dst|$dst, $src}", [], IIC_MOVS>;
1141 }
1142
1143 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1144 let Defs = [EDI], Uses = [AL,EDI,EFLAGS] in
1145 def STOSB : I<0xAA, RawFrmDst, (outs dstidx8:$dst), (ins),
1146               "stosb\t{%al, $dst|$dst, al}", [], IIC_STOS>;
1147 let Defs = [EDI], Uses = [AX,EDI,EFLAGS] in
1148 def STOSW : I<0xAB, RawFrmDst, (outs dstidx16:$dst), (ins),
1149               "stosw\t{%ax, $dst|$dst, ax}", [], IIC_STOS>, OpSize16;
1150 let Defs = [EDI], Uses = [EAX,EDI,EFLAGS] in
1151 def STOSL : I<0xAB, RawFrmDst, (outs dstidx32:$dst), (ins),
1152               "stos{l|d}\t{%eax, $dst|$dst, eax}", [], IIC_STOS>, OpSize32;
1153 let Defs = [RCX,RDI], Uses = [RAX,RCX,RDI,EFLAGS] in
1154 def STOSQ : RI<0xAB, RawFrmDst, (outs dstidx64:$dst), (ins),
1155                "stosq\t{%rax, $dst|$dst, rax}", [], IIC_STOS>;
1156
1157 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1158 let Defs = [EDI,EFLAGS], Uses = [AL,EDI,EFLAGS] in
1159 def SCASB : I<0xAE, RawFrmDst, (outs), (ins dstidx8:$dst),
1160               "scasb\t{$dst, %al|al, $dst}", [], IIC_SCAS>;
1161 let Defs = [EDI,EFLAGS], Uses = [AX,EDI,EFLAGS] in
1162 def SCASW : I<0xAF, RawFrmDst, (outs), (ins dstidx16:$dst),
1163               "scasw\t{$dst, %ax|ax, $dst}", [], IIC_SCAS>, OpSize16;
1164 let Defs = [EDI,EFLAGS], Uses = [EAX,EDI,EFLAGS] in
1165 def SCASL : I<0xAF, RawFrmDst, (outs), (ins dstidx32:$dst),
1166               "scas{l|d}\t{$dst, %eax|eax, $dst}", [], IIC_SCAS>, OpSize32;
1167 let Defs = [EDI,EFLAGS], Uses = [RAX,EDI,EFLAGS] in
1168 def SCASQ : RI<0xAF, RawFrmDst, (outs), (ins dstidx64:$dst),
1169                "scasq\t{$dst, %rax|rax, $dst}", [], IIC_SCAS>;
1170
1171 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1172 let Defs = [EDI,ESI,EFLAGS], Uses = [EDI,ESI,EFLAGS] in {
1173 def CMPSB : I<0xA6, RawFrmDstSrc, (outs), (ins dstidx8:$dst, srcidx8:$src),
1174               "cmpsb\t{$dst, $src|$src, $dst}", [], IIC_CMPS>;
1175 def CMPSW : I<0xA7, RawFrmDstSrc, (outs), (ins dstidx16:$dst, srcidx16:$src),
1176               "cmpsw\t{$dst, $src|$src, $dst}", [], IIC_CMPS>, OpSize16;
1177 def CMPSL : I<0xA7, RawFrmDstSrc, (outs), (ins dstidx32:$dst, srcidx32:$src),
1178               "cmps{l|d}\t{$dst, $src|$src, $dst}", [], IIC_CMPS>, OpSize32;
1179 def CMPSQ : RI<0xA7, RawFrmDstSrc, (outs), (ins dstidx64:$dst, srcidx64:$src),
1180                "cmpsq\t{$dst, $src|$src, $dst}", [], IIC_CMPS>;
1181 }
1182 } // SchedRW
1183
1184 //===----------------------------------------------------------------------===//
1185 //  Move Instructions.
1186 //
1187 let SchedRW = [WriteMove] in {
1188 let hasSideEffects = 0 in {
1189 def MOV8rr  : I<0x88, MRMDestReg, (outs GR8 :$dst), (ins GR8 :$src),
1190                 "mov{b}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
1191 def MOV16rr : I<0x89, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
1192                 "mov{w}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize16;
1193 def MOV32rr : I<0x89, MRMDestReg, (outs GR32:$dst), (ins GR32:$src),
1194                 "mov{l}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize32;
1195 def MOV64rr : RI<0x89, MRMDestReg, (outs GR64:$dst), (ins GR64:$src),
1196                  "mov{q}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
1197 }
1198
1199 let isReMaterializable = 1, isAsCheapAsAMove = 1 in {
1200 def MOV8ri  : Ii8 <0xB0, AddRegFrm, (outs GR8 :$dst), (ins i8imm :$src),
1201                    "mov{b}\t{$src, $dst|$dst, $src}",
1202                    [(set GR8:$dst, imm:$src)], IIC_MOV>;
1203 def MOV16ri : Ii16<0xB8, AddRegFrm, (outs GR16:$dst), (ins i16imm:$src),
1204                    "mov{w}\t{$src, $dst|$dst, $src}",
1205                    [(set GR16:$dst, imm:$src)], IIC_MOV>, OpSize16;
1206 def MOV32ri : Ii32<0xB8, AddRegFrm, (outs GR32:$dst), (ins i32imm:$src),
1207                    "mov{l}\t{$src, $dst|$dst, $src}",
1208                    [(set GR32:$dst, imm:$src)], IIC_MOV>, OpSize32;
1209 def MOV64ri32 : RIi32S<0xC7, MRM0r, (outs GR64:$dst), (ins i64i32imm:$src),
1210                        "mov{q}\t{$src, $dst|$dst, $src}",
1211                        [(set GR64:$dst, i64immSExt32:$src)], IIC_MOV>;
1212 }
1213 let isReMaterializable = 1 in {
1214 def MOV64ri : RIi64<0xB8, AddRegFrm, (outs GR64:$dst), (ins i64imm:$src),
1215                     "movabs{q}\t{$src, $dst|$dst, $src}",
1216                     [(set GR64:$dst, imm:$src)], IIC_MOV>;
1217 }
1218
1219 // Longer forms that use a ModR/M byte. Needed for disassembler
1220 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0 in {
1221 def MOV8ri_alt  : Ii8 <0xC6, MRM0r, (outs GR8 :$dst), (ins i8imm :$src),
1222                    "mov{b}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
1223 def MOV16ri_alt : Ii16<0xC7, MRM0r, (outs GR16:$dst), (ins i16imm:$src),
1224                    "mov{w}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize16;
1225 def MOV32ri_alt : Ii32<0xC7, MRM0r, (outs GR32:$dst), (ins i32imm:$src),
1226                    "mov{l}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize32;
1227 }
1228 } // SchedRW
1229
1230 let SchedRW = [WriteStore] in {
1231 def MOV8mi  : Ii8 <0xC6, MRM0m, (outs), (ins i8mem :$dst, i8imm :$src),
1232                    "mov{b}\t{$src, $dst|$dst, $src}",
1233                    [(store (i8 imm:$src), addr:$dst)], IIC_MOV_MEM>;
1234 def MOV16mi : Ii16<0xC7, MRM0m, (outs), (ins i16mem:$dst, i16imm:$src),
1235                    "mov{w}\t{$src, $dst|$dst, $src}",
1236                    [(store (i16 imm:$src), addr:$dst)], IIC_MOV_MEM>, OpSize16;
1237 def MOV32mi : Ii32<0xC7, MRM0m, (outs), (ins i32mem:$dst, i32imm:$src),
1238                    "mov{l}\t{$src, $dst|$dst, $src}",
1239                    [(store (i32 imm:$src), addr:$dst)], IIC_MOV_MEM>, OpSize32;
1240 def MOV64mi32 : RIi32S<0xC7, MRM0m, (outs), (ins i64mem:$dst, i64i32imm:$src),
1241                        "mov{q}\t{$src, $dst|$dst, $src}",
1242                        [(store i64immSExt32:$src, addr:$dst)], IIC_MOV_MEM>;
1243 } // SchedRW
1244
1245 let hasSideEffects = 0 in {
1246
1247 /// Memory offset versions of moves. The immediate is an address mode sized
1248 /// offset from the segment base.
1249 let SchedRW = [WriteALU] in {
1250 let mayLoad = 1 in {
1251 let Defs = [AL] in
1252 def MOV8ao32 : Ii32<0xA0, RawFrmMemOffs, (outs), (ins offset32_8:$src),
1253                     "mov{b}\t{$src, %al|al, $src}", [], IIC_MOV_MEM>,
1254                     AdSize32;
1255 let Defs = [AX] in
1256 def MOV16ao32 : Ii32<0xA1, RawFrmMemOffs, (outs), (ins offset32_16:$src),
1257                      "mov{w}\t{$src, %ax|ax, $src}", [], IIC_MOV_MEM>,
1258                      OpSize16, AdSize32;
1259 let Defs = [EAX] in
1260 def MOV32ao32 : Ii32<0xA1, RawFrmMemOffs, (outs), (ins offset32_32:$src),
1261                      "mov{l}\t{$src, %eax|eax, $src}", [], IIC_MOV_MEM>,
1262                      OpSize32, AdSize32;
1263 let Defs = [RAX] in
1264 def MOV64ao32 : RIi32<0xA1, RawFrmMemOffs, (outs), (ins offset32_64:$src),
1265                       "mov{q}\t{$src, %rax|rax, $src}", [], IIC_MOV_MEM>,
1266                       AdSize32;
1267
1268 let Defs = [AL] in
1269 def MOV8ao16 : Ii16<0xA0, RawFrmMemOffs, (outs), (ins offset16_8:$src),
1270                     "mov{b}\t{$src, %al|al, $src}", [], IIC_MOV_MEM>, AdSize16;
1271 let Defs = [AX] in
1272 def MOV16ao16 : Ii16<0xA1, RawFrmMemOffs, (outs), (ins offset16_16:$src),
1273                      "mov{w}\t{$src, %ax|ax, $src}", [], IIC_MOV_MEM>,
1274                      OpSize16, AdSize16;
1275 let Defs = [EAX] in
1276 def MOV32ao16 : Ii16<0xA1, RawFrmMemOffs, (outs), (ins offset16_32:$src),
1277                      "mov{l}\t{$src, %eax|eax, $src}", [], IIC_MOV_MEM>,
1278                      AdSize16, OpSize32;
1279 }
1280 let mayStore = 1 in {
1281 let Uses = [AL] in
1282 def MOV8o32a : Ii32<0xA2, RawFrmMemOffs, (outs offset32_8:$dst), (ins),
1283                     "mov{b}\t{%al, $dst|$dst, al}", [], IIC_MOV_MEM>, AdSize32;
1284 let Uses = [AX] in
1285 def MOV16o32a : Ii32<0xA3, RawFrmMemOffs, (outs offset32_16:$dst), (ins),
1286                      "mov{w}\t{%ax, $dst|$dst, ax}", [], IIC_MOV_MEM>,
1287                      OpSize16, AdSize32;
1288 let Uses = [EAX] in
1289 def MOV32o32a : Ii32<0xA3, RawFrmMemOffs, (outs offset32_32:$dst), (ins),
1290                      "mov{l}\t{%eax, $dst|$dst, eax}", [], IIC_MOV_MEM>,
1291                      OpSize32, AdSize32;
1292 let Uses = [RAX] in
1293 def MOV64o32a : RIi32<0xA3, RawFrmMemOffs, (outs offset32_64:$dst), (ins),
1294                       "mov{q}\t{%rax, $dst|$dst, rax}", [], IIC_MOV_MEM>,
1295                       AdSize32;
1296
1297 let Uses = [AL] in
1298 def MOV8o16a : Ii16<0xA2, RawFrmMemOffs, (outs offset16_8:$dst), (ins),
1299                     "mov{b}\t{%al, $dst|$dst, al}", [], IIC_MOV_MEM>, AdSize16;
1300 let Uses = [AX] in
1301 def MOV16o16a : Ii16<0xA3, RawFrmMemOffs, (outs offset16_16:$dst), (ins),
1302                      "mov{w}\t{%ax, $dst|$dst, ax}", [], IIC_MOV_MEM>,
1303                      OpSize16, AdSize16;
1304 let Uses = [EAX] in
1305 def MOV32o16a : Ii16<0xA3, RawFrmMemOffs, (outs offset16_32:$dst), (ins),
1306                      "mov{l}\t{%eax, $dst|$dst, eax}", [], IIC_MOV_MEM>,
1307                      OpSize32, AdSize16;
1308 }
1309 }
1310
1311 // These forms all have full 64-bit absolute addresses in their instructions
1312 // and use the movabs mnemonic to indicate this specific form.
1313 let mayLoad = 1 in {
1314 let Defs = [AL] in
1315 def MOV8ao64 : RIi64_NOREX<0xA0, RawFrmMemOffs, (outs), (ins offset64_8:$src),
1316                      "movabs{b}\t{$src, %al|al, $src}", []>, AdSize64;
1317 let Defs = [AX] in
1318 def MOV16ao64 : RIi64_NOREX<0xA1, RawFrmMemOffs, (outs), (ins offset64_16:$src),
1319                      "movabs{w}\t{$src, %ax|ax, $src}", []>, OpSize16, AdSize64;
1320 let Defs = [EAX] in
1321 def MOV32ao64 : RIi64_NOREX<0xA1, RawFrmMemOffs, (outs), (ins offset64_32:$src),
1322                      "movabs{l}\t{$src, %eax|eax, $src}", []>, OpSize32,
1323                      AdSize64;
1324 let Defs = [RAX] in
1325 def MOV64ao64 : RIi64<0xA1, RawFrmMemOffs, (outs), (ins offset64_64:$src),
1326                      "movabs{q}\t{$src, %rax|rax, $src}", []>, AdSize64;
1327 }
1328
1329 let mayStore = 1 in {
1330 let Uses = [AL] in
1331 def MOV8o64a : RIi64_NOREX<0xA2, RawFrmMemOffs, (outs offset64_8:$dst), (ins),
1332                      "movabs{b}\t{%al, $dst|$dst, al}", []>, AdSize64;
1333 let Uses = [AX] in
1334 def MOV16o64a : RIi64_NOREX<0xA3, RawFrmMemOffs, (outs offset64_16:$dst), (ins),
1335                      "movabs{w}\t{%ax, $dst|$dst, ax}", []>, OpSize16, AdSize64;
1336 let Uses = [EAX] in
1337 def MOV32o64a : RIi64_NOREX<0xA3, RawFrmMemOffs, (outs offset64_32:$dst), (ins),
1338                      "movabs{l}\t{%eax, $dst|$dst, eax}", []>, OpSize32,
1339                      AdSize64;
1340 let Uses = [RAX] in
1341 def MOV64o64a : RIi64<0xA3, RawFrmMemOffs, (outs offset64_64:$dst), (ins),
1342                      "movabs{q}\t{%rax, $dst|$dst, rax}", []>, AdSize64;
1343 }
1344 } // hasSideEffects = 0
1345
1346 let isCodeGenOnly = 1, ForceDisassemble = 1, hasSideEffects = 0,
1347     SchedRW = [WriteMove] in {
1348 def MOV8rr_REV : I<0x8A, MRMSrcReg, (outs GR8:$dst), (ins GR8:$src),
1349                    "mov{b}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
1350 def MOV16rr_REV : I<0x8B, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
1351                     "mov{w}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize16;
1352 def MOV32rr_REV : I<0x8B, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
1353                     "mov{l}\t{$src, $dst|$dst, $src}", [], IIC_MOV>, OpSize32;
1354 def MOV64rr_REV : RI<0x8B, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
1355                      "mov{q}\t{$src, $dst|$dst, $src}", [], IIC_MOV>;
1356 }
1357
1358 let canFoldAsLoad = 1, isReMaterializable = 1, SchedRW = [WriteLoad] in {
1359 def MOV8rm  : I<0x8A, MRMSrcMem, (outs GR8 :$dst), (ins i8mem :$src),
1360                 "mov{b}\t{$src, $dst|$dst, $src}",
1361                 [(set GR8:$dst, (loadi8 addr:$src))], IIC_MOV_MEM>;
1362 def MOV16rm : I<0x8B, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
1363                 "mov{w}\t{$src, $dst|$dst, $src}",
1364                 [(set GR16:$dst, (loadi16 addr:$src))], IIC_MOV_MEM>, OpSize16;
1365 def MOV32rm : I<0x8B, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
1366                 "mov{l}\t{$src, $dst|$dst, $src}",
1367                 [(set GR32:$dst, (loadi32 addr:$src))], IIC_MOV_MEM>, OpSize32;
1368 def MOV64rm : RI<0x8B, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
1369                  "mov{q}\t{$src, $dst|$dst, $src}",
1370                  [(set GR64:$dst, (load addr:$src))], IIC_MOV_MEM>;
1371 }
1372
1373 let SchedRW = [WriteStore] in {
1374 def MOV8mr  : I<0x88, MRMDestMem, (outs), (ins i8mem :$dst, GR8 :$src),
1375                 "mov{b}\t{$src, $dst|$dst, $src}",
1376                 [(store GR8:$src, addr:$dst)], IIC_MOV_MEM>;
1377 def MOV16mr : I<0x89, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
1378                 "mov{w}\t{$src, $dst|$dst, $src}",
1379                 [(store GR16:$src, addr:$dst)], IIC_MOV_MEM>, OpSize16;
1380 def MOV32mr : I<0x89, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
1381                 "mov{l}\t{$src, $dst|$dst, $src}",
1382                 [(store GR32:$src, addr:$dst)], IIC_MOV_MEM>, OpSize32;
1383 def MOV64mr : RI<0x89, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
1384                  "mov{q}\t{$src, $dst|$dst, $src}",
1385                  [(store GR64:$src, addr:$dst)], IIC_MOV_MEM>;
1386 } // SchedRW
1387
1388 // Versions of MOV8rr, MOV8mr, and MOV8rm that use i8mem_NOREX and GR8_NOREX so
1389 // that they can be used for copying and storing h registers, which can't be
1390 // encoded when a REX prefix is present.
1391 let isCodeGenOnly = 1 in {
1392 let hasSideEffects = 0 in
1393 def MOV8rr_NOREX : I<0x88, MRMDestReg,
1394                      (outs GR8_NOREX:$dst), (ins GR8_NOREX:$src),
1395                      "mov{b}\t{$src, $dst|$dst, $src}  # NOREX", [], IIC_MOV>,
1396                    Sched<[WriteMove]>;
1397 let mayStore = 1, hasSideEffects = 0 in
1398 def MOV8mr_NOREX : I<0x88, MRMDestMem,
1399                      (outs), (ins i8mem_NOREX:$dst, GR8_NOREX:$src),
1400                      "mov{b}\t{$src, $dst|$dst, $src}  # NOREX", [],
1401                      IIC_MOV_MEM>, Sched<[WriteStore]>;
1402 let mayLoad = 1, hasSideEffects = 0,
1403     canFoldAsLoad = 1, isReMaterializable = 1 in
1404 def MOV8rm_NOREX : I<0x8A, MRMSrcMem,
1405                      (outs GR8_NOREX:$dst), (ins i8mem_NOREX:$src),
1406                      "mov{b}\t{$src, $dst|$dst, $src}  # NOREX", [],
1407                      IIC_MOV_MEM>, Sched<[WriteLoad]>;
1408 }
1409
1410
1411 // Condition code ops, incl. set if equal/not equal/...
1412 let SchedRW = [WriteALU] in {
1413 let Defs = [EFLAGS], Uses = [AH] in
1414 def SAHF     : I<0x9E, RawFrm, (outs),  (ins), "sahf",
1415                  [(set EFLAGS, (X86sahf AH))], IIC_AHF>;
1416 let Defs = [AH], Uses = [EFLAGS], hasSideEffects = 0 in
1417 def LAHF     : I<0x9F, RawFrm, (outs),  (ins), "lahf", [],
1418                 IIC_AHF>;  // AH = flags
1419 } // SchedRW
1420
1421 //===----------------------------------------------------------------------===//
1422 // Bit tests instructions: BT, BTS, BTR, BTC.
1423
1424 let Defs = [EFLAGS] in {
1425 let SchedRW = [WriteALU] in {
1426 def BT16rr : I<0xA3, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
1427                "bt{w}\t{$src2, $src1|$src1, $src2}",
1428                [(set EFLAGS, (X86bt GR16:$src1, GR16:$src2))], IIC_BT_RR>,
1429                OpSize16, TB;
1430 def BT32rr : I<0xA3, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
1431                "bt{l}\t{$src2, $src1|$src1, $src2}",
1432                [(set EFLAGS, (X86bt GR32:$src1, GR32:$src2))], IIC_BT_RR>,
1433                OpSize32, TB;
1434 def BT64rr : RI<0xA3, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
1435                "bt{q}\t{$src2, $src1|$src1, $src2}",
1436                [(set EFLAGS, (X86bt GR64:$src1, GR64:$src2))], IIC_BT_RR>, TB;
1437 } // SchedRW
1438
1439 // Unlike with the register+register form, the memory+register form of the
1440 // bt instruction does not ignore the high bits of the index. From ISel's
1441 // perspective, this is pretty bizarre. Make these instructions disassembly
1442 // only for now.
1443
1444 let mayLoad = 1, hasSideEffects = 0, SchedRW = [WriteALULd] in {
1445   def BT16mr : I<0xA3, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
1446                  "bt{w}\t{$src2, $src1|$src1, $src2}",
1447   //               [(X86bt (loadi16 addr:$src1), GR16:$src2),
1448   //                (implicit EFLAGS)]
1449                  [], IIC_BT_MR
1450                  >, OpSize16, TB, Requires<[FastBTMem]>;
1451   def BT32mr : I<0xA3, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
1452                  "bt{l}\t{$src2, $src1|$src1, $src2}",
1453   //               [(X86bt (loadi32 addr:$src1), GR32:$src2),
1454   //                (implicit EFLAGS)]
1455                  [], IIC_BT_MR
1456                  >, OpSize32, TB, Requires<[FastBTMem]>;
1457   def BT64mr : RI<0xA3, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
1458                  "bt{q}\t{$src2, $src1|$src1, $src2}",
1459   //               [(X86bt (loadi64 addr:$src1), GR64:$src2),
1460   //                (implicit EFLAGS)]
1461                   [], IIC_BT_MR
1462                   >, TB;
1463 }
1464
1465 let SchedRW = [WriteALU] in {
1466 def BT16ri8 : Ii8<0xBA, MRM4r, (outs), (ins GR16:$src1, i16i8imm:$src2),
1467                 "bt{w}\t{$src2, $src1|$src1, $src2}",
1468                 [(set EFLAGS, (X86bt GR16:$src1, i16immSExt8:$src2))],
1469                 IIC_BT_RI>, OpSize16, TB;
1470 def BT32ri8 : Ii8<0xBA, MRM4r, (outs), (ins GR32:$src1, i32i8imm:$src2),
1471                 "bt{l}\t{$src2, $src1|$src1, $src2}",
1472                 [(set EFLAGS, (X86bt GR32:$src1, i32immSExt8:$src2))],
1473                 IIC_BT_RI>, OpSize32, TB;
1474 def BT64ri8 : RIi8<0xBA, MRM4r, (outs), (ins GR64:$src1, i64i8imm:$src2),
1475                 "bt{q}\t{$src2, $src1|$src1, $src2}",
1476                 [(set EFLAGS, (X86bt GR64:$src1, i64immSExt8:$src2))],
1477                 IIC_BT_RI>, TB;
1478 } // SchedRW
1479
1480 // Note that these instructions don't need FastBTMem because that
1481 // only applies when the other operand is in a register. When it's
1482 // an immediate, bt is still fast.
1483 let SchedRW = [WriteALU] in {
1484 def BT16mi8 : Ii8<0xBA, MRM4m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
1485                 "bt{w}\t{$src2, $src1|$src1, $src2}",
1486                 [(set EFLAGS, (X86bt (loadi16 addr:$src1), i16immSExt8:$src2))
1487                  ], IIC_BT_MI>, OpSize16, TB;
1488 def BT32mi8 : Ii8<0xBA, MRM4m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
1489                 "bt{l}\t{$src2, $src1|$src1, $src2}",
1490                 [(set EFLAGS, (X86bt (loadi32 addr:$src1), i32immSExt8:$src2))
1491                  ], IIC_BT_MI>, OpSize32, TB;
1492 def BT64mi8 : RIi8<0xBA, MRM4m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
1493                 "bt{q}\t{$src2, $src1|$src1, $src2}",
1494                 [(set EFLAGS, (X86bt (loadi64 addr:$src1),
1495                                      i64immSExt8:$src2))], IIC_BT_MI>, TB;
1496 } // SchedRW
1497
1498 let hasSideEffects = 0 in {
1499 let SchedRW = [WriteALU] in {
1500 def BTC16rr : I<0xBB, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
1501                 "btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
1502                 OpSize16, TB;
1503 def BTC32rr : I<0xBB, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
1504                 "btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
1505                 OpSize32, TB;
1506 def BTC64rr : RI<0xBB, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
1507                  "btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>, TB;
1508 } // SchedRW
1509
1510 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1511 def BTC16mr : I<0xBB, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
1512                 "btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
1513                 OpSize16, TB;
1514 def BTC32mr : I<0xBB, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
1515                 "btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
1516                 OpSize32, TB;
1517 def BTC64mr : RI<0xBB, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
1518                  "btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>, TB;
1519 }
1520
1521 let SchedRW = [WriteALU] in {
1522 def BTC16ri8 : Ii8<0xBA, MRM7r, (outs), (ins GR16:$src1, i16i8imm:$src2),
1523                     "btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
1524                     OpSize16, TB;
1525 def BTC32ri8 : Ii8<0xBA, MRM7r, (outs), (ins GR32:$src1, i32i8imm:$src2),
1526                     "btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
1527                     OpSize32, TB;
1528 def BTC64ri8 : RIi8<0xBA, MRM7r, (outs), (ins GR64:$src1, i64i8imm:$src2),
1529                     "btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>, TB;
1530 } // SchedRW
1531
1532 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1533 def BTC16mi8 : Ii8<0xBA, MRM7m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
1534                     "btc{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
1535                     OpSize16, TB;
1536 def BTC32mi8 : Ii8<0xBA, MRM7m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
1537                     "btc{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
1538                     OpSize32, TB;
1539 def BTC64mi8 : RIi8<0xBA, MRM7m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
1540                     "btc{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>, TB;
1541 }
1542
1543 let SchedRW = [WriteALU] in {
1544 def BTR16rr : I<0xB3, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
1545                 "btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
1546                 OpSize16, TB;
1547 def BTR32rr : I<0xB3, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
1548                 "btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
1549                 OpSize32, TB;
1550 def BTR64rr : RI<0xB3, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
1551                  "btr{q}\t{$src2, $src1|$src1, $src2}", []>, TB;
1552 } // SchedRW
1553
1554 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1555 def BTR16mr : I<0xB3, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
1556                 "btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
1557                 OpSize16, TB;
1558 def BTR32mr : I<0xB3, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
1559                 "btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
1560                 OpSize32, TB;
1561 def BTR64mr : RI<0xB3, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
1562                  "btr{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>, TB;
1563 }
1564
1565 let SchedRW = [WriteALU] in {
1566 def BTR16ri8 : Ii8<0xBA, MRM6r, (outs), (ins GR16:$src1, i16i8imm:$src2),
1567                     "btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
1568                     OpSize16, TB;
1569 def BTR32ri8 : Ii8<0xBA, MRM6r, (outs), (ins GR32:$src1, i32i8imm:$src2),
1570                     "btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
1571                     OpSize32, TB;
1572 def BTR64ri8 : RIi8<0xBA, MRM6r, (outs), (ins GR64:$src1, i64i8imm:$src2),
1573                     "btr{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>, TB;
1574 } // SchedRW
1575
1576 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1577 def BTR16mi8 : Ii8<0xBA, MRM6m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
1578                     "btr{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
1579                     OpSize16, TB;
1580 def BTR32mi8 : Ii8<0xBA, MRM6m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
1581                     "btr{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
1582                     OpSize32, TB;
1583 def BTR64mi8 : RIi8<0xBA, MRM6m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
1584                     "btr{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>, TB;
1585 }
1586
1587 let SchedRW = [WriteALU] in {
1588 def BTS16rr : I<0xAB, MRMDestReg, (outs), (ins GR16:$src1, GR16:$src2),
1589                 "bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
1590                 OpSize16, TB;
1591 def BTS32rr : I<0xAB, MRMDestReg, (outs), (ins GR32:$src1, GR32:$src2),
1592                 "bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>,
1593               OpSize32, TB;
1594 def BTS64rr : RI<0xAB, MRMDestReg, (outs), (ins GR64:$src1, GR64:$src2),
1595                "bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RR>, TB;
1596 } // SchedRW
1597
1598 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1599 def BTS16mr : I<0xAB, MRMDestMem, (outs), (ins i16mem:$src1, GR16:$src2),
1600               "bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
1601               OpSize16, TB;
1602 def BTS32mr : I<0xAB, MRMDestMem, (outs), (ins i32mem:$src1, GR32:$src2),
1603               "bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>,
1604               OpSize32, TB;
1605 def BTS64mr : RI<0xAB, MRMDestMem, (outs), (ins i64mem:$src1, GR64:$src2),
1606                  "bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MR>, TB;
1607 }
1608
1609 let SchedRW = [WriteALU] in {
1610 def BTS16ri8 : Ii8<0xBA, MRM5r, (outs), (ins GR16:$src1, i16i8imm:$src2),
1611                     "bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
1612                     OpSize16, TB;
1613 def BTS32ri8 : Ii8<0xBA, MRM5r, (outs), (ins GR32:$src1, i32i8imm:$src2),
1614                     "bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>,
1615                     OpSize32, TB;
1616 def BTS64ri8 : RIi8<0xBA, MRM5r, (outs), (ins GR64:$src1, i64i8imm:$src2),
1617                     "bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_RI>, TB;
1618 } // SchedRW
1619
1620 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1621 def BTS16mi8 : Ii8<0xBA, MRM5m, (outs), (ins i16mem:$src1, i16i8imm:$src2),
1622                     "bts{w}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
1623                     OpSize16, TB;
1624 def BTS32mi8 : Ii8<0xBA, MRM5m, (outs), (ins i32mem:$src1, i32i8imm:$src2),
1625                     "bts{l}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>,
1626                     OpSize32, TB;
1627 def BTS64mi8 : RIi8<0xBA, MRM5m, (outs), (ins i64mem:$src1, i64i8imm:$src2),
1628                     "bts{q}\t{$src2, $src1|$src1, $src2}", [], IIC_BTX_MI>, TB;
1629 }
1630 } // hasSideEffects = 0
1631 } // Defs = [EFLAGS]
1632
1633
1634 //===----------------------------------------------------------------------===//
1635 // Atomic support
1636 //
1637
1638 // Atomic swap. These are just normal xchg instructions. But since a memory
1639 // operand is referenced, the atomicity is ensured.
1640 multiclass ATOMIC_SWAP<bits<8> opc8, bits<8> opc, string mnemonic, string frag,
1641                        InstrItinClass itin> {
1642   let Constraints = "$val = $dst", SchedRW = [WriteALULd, WriteRMW] in {
1643     def NAME#8rm  : I<opc8, MRMSrcMem, (outs GR8:$dst),
1644                       (ins GR8:$val, i8mem:$ptr),
1645                       !strconcat(mnemonic, "{b}\t{$val, $ptr|$ptr, $val}"),
1646                       [(set
1647                          GR8:$dst,
1648                          (!cast<PatFrag>(frag # "_8") addr:$ptr, GR8:$val))],
1649                       itin>;
1650     def NAME#16rm : I<opc, MRMSrcMem, (outs GR16:$dst),
1651                       (ins GR16:$val, i16mem:$ptr),
1652                       !strconcat(mnemonic, "{w}\t{$val, $ptr|$ptr, $val}"),
1653                       [(set
1654                          GR16:$dst,
1655                          (!cast<PatFrag>(frag # "_16") addr:$ptr, GR16:$val))],
1656                       itin>, OpSize16;
1657     def NAME#32rm : I<opc, MRMSrcMem, (outs GR32:$dst),
1658                       (ins GR32:$val, i32mem:$ptr),
1659                       !strconcat(mnemonic, "{l}\t{$val, $ptr|$ptr, $val}"),
1660                       [(set
1661                          GR32:$dst,
1662                          (!cast<PatFrag>(frag # "_32") addr:$ptr, GR32:$val))],
1663                       itin>, OpSize32;
1664     def NAME#64rm : RI<opc, MRMSrcMem, (outs GR64:$dst),
1665                        (ins GR64:$val, i64mem:$ptr),
1666                        !strconcat(mnemonic, "{q}\t{$val, $ptr|$ptr, $val}"),
1667                        [(set
1668                          GR64:$dst,
1669                          (!cast<PatFrag>(frag # "_64") addr:$ptr, GR64:$val))],
1670                        itin>;
1671   }
1672 }
1673
1674 defm XCHG    : ATOMIC_SWAP<0x86, 0x87, "xchg", "atomic_swap", IIC_XCHG_MEM>;
1675
1676 // Swap between registers.
1677 let SchedRW = [WriteALU] in {
1678 let Constraints = "$val = $dst" in {
1679 def XCHG8rr : I<0x86, MRMSrcReg, (outs GR8:$dst), (ins GR8:$val, GR8:$src),
1680                 "xchg{b}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>;
1681 def XCHG16rr : I<0x87, MRMSrcReg, (outs GR16:$dst), (ins GR16:$val, GR16:$src),
1682                  "xchg{w}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>,
1683                  OpSize16;
1684 def XCHG32rr : I<0x87, MRMSrcReg, (outs GR32:$dst), (ins GR32:$val, GR32:$src),
1685                  "xchg{l}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>,
1686                  OpSize32;
1687 def XCHG64rr : RI<0x87, MRMSrcReg, (outs GR64:$dst), (ins GR64:$val,GR64:$src),
1688                   "xchg{q}\t{$val, $src|$src, $val}", [], IIC_XCHG_REG>;
1689 }
1690
1691 // Swap between EAX and other registers.
1692 let Uses = [AX], Defs = [AX] in
1693 def XCHG16ar : I<0x90, AddRegFrm, (outs), (ins GR16:$src),
1694                   "xchg{w}\t{$src, %ax|ax, $src}", [], IIC_XCHG_REG>, OpSize16;
1695 let Uses = [EAX], Defs = [EAX] in
1696 def XCHG32ar : I<0x90, AddRegFrm, (outs), (ins GR32:$src),
1697                   "xchg{l}\t{$src, %eax|eax, $src}", [], IIC_XCHG_REG>,
1698                   OpSize32, Requires<[Not64BitMode]>;
1699 let Uses = [EAX], Defs = [EAX] in
1700 // Uses GR32_NOAX in 64-bit mode to prevent encoding using the 0x90 NOP encoding.
1701 // xchg %eax, %eax needs to clear upper 32-bits of RAX so is not a NOP.
1702 def XCHG32ar64 : I<0x90, AddRegFrm, (outs), (ins GR32_NOAX:$src),
1703                    "xchg{l}\t{$src, %eax|eax, $src}", [], IIC_XCHG_REG>,
1704                    OpSize32, Requires<[In64BitMode]>;
1705 let Uses = [RAX], Defs = [RAX] in
1706 def XCHG64ar : RI<0x90, AddRegFrm, (outs), (ins GR64:$src),
1707                   "xchg{q}\t{$src, %rax|rax, $src}", [], IIC_XCHG_REG>;
1708 } // SchedRW
1709
1710 let SchedRW = [WriteALU] in {
1711 def XADD8rr : I<0xC0, MRMDestReg, (outs GR8:$dst), (ins GR8:$src),
1712                 "xadd{b}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB;
1713 def XADD16rr : I<0xC1, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
1714                  "xadd{w}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB,
1715                  OpSize16;
1716 def XADD32rr  : I<0xC1, MRMDestReg, (outs GR32:$dst), (ins GR32:$src),
1717                  "xadd{l}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB,
1718                  OpSize32;
1719 def XADD64rr  : RI<0xC1, MRMDestReg, (outs GR64:$dst), (ins GR64:$src),
1720                    "xadd{q}\t{$src, $dst|$dst, $src}", [], IIC_XADD_REG>, TB;
1721 } // SchedRW
1722
1723 let mayLoad = 1, mayStore = 1, SchedRW = [WriteALULd, WriteRMW] in {
1724 def XADD8rm   : I<0xC0, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
1725                  "xadd{b}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB;
1726 def XADD16rm  : I<0xC1, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
1727                  "xadd{w}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB,
1728                  OpSize16;
1729 def XADD32rm  : I<0xC1, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
1730                  "xadd{l}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB,
1731                  OpSize32;
1732 def XADD64rm  : RI<0xC1, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
1733                    "xadd{q}\t{$src, $dst|$dst, $src}", [], IIC_XADD_MEM>, TB;
1734
1735 }
1736
1737 let SchedRW = [WriteALU] in {
1738 def CMPXCHG8rr : I<0xB0, MRMDestReg, (outs GR8:$dst), (ins GR8:$src),
1739                    "cmpxchg{b}\t{$src, $dst|$dst, $src}", [],
1740                    IIC_CMPXCHG_REG8>, TB;
1741 def CMPXCHG16rr : I<0xB1, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
1742                     "cmpxchg{w}\t{$src, $dst|$dst, $src}", [],
1743                     IIC_CMPXCHG_REG>, TB, OpSize16;
1744 def CMPXCHG32rr  : I<0xB1, MRMDestReg, (outs GR32:$dst), (ins GR32:$src),
1745                      "cmpxchg{l}\t{$src, $dst|$dst, $src}", [],
1746                      IIC_CMPXCHG_REG>, TB, OpSize32;
1747 def CMPXCHG64rr  : RI<0xB1, MRMDestReg, (outs GR64:$dst), (ins GR64:$src),
1748                       "cmpxchg{q}\t{$src, $dst|$dst, $src}", [],
1749                       IIC_CMPXCHG_REG>, TB;
1750 } // SchedRW
1751
1752 let SchedRW = [WriteALULd, WriteRMW] in {
1753 let mayLoad = 1, mayStore = 1 in {
1754 def CMPXCHG8rm   : I<0xB0, MRMDestMem, (outs), (ins i8mem:$dst, GR8:$src),
1755                      "cmpxchg{b}\t{$src, $dst|$dst, $src}", [],
1756                      IIC_CMPXCHG_MEM8>, TB;
1757 def CMPXCHG16rm  : I<0xB1, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
1758                      "cmpxchg{w}\t{$src, $dst|$dst, $src}", [],
1759                      IIC_CMPXCHG_MEM>, TB, OpSize16;
1760 def CMPXCHG32rm  : I<0xB1, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
1761                      "cmpxchg{l}\t{$src, $dst|$dst, $src}", [],
1762                      IIC_CMPXCHG_MEM>, TB, OpSize32;
1763 def CMPXCHG64rm  : RI<0xB1, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
1764                       "cmpxchg{q}\t{$src, $dst|$dst, $src}", [],
1765                       IIC_CMPXCHG_MEM>, TB;
1766 }
1767
1768 let Defs = [EAX, EDX, EFLAGS], Uses = [EAX, EBX, ECX, EDX] in
1769 def CMPXCHG8B : I<0xC7, MRM1m, (outs), (ins i64mem:$dst),
1770                   "cmpxchg8b\t$dst", [], IIC_CMPXCHG_8B>, TB;
1771
1772 let Defs = [RAX, RDX, EFLAGS], Uses = [RAX, RBX, RCX, RDX] in
1773 def CMPXCHG16B : RI<0xC7, MRM1m, (outs), (ins i128mem:$dst),
1774                     "cmpxchg16b\t$dst", [], IIC_CMPXCHG_16B>,
1775                     TB, Requires<[HasCmpxchg16b]>;
1776 } // SchedRW
1777
1778
1779 // Lock instruction prefix
1780 def LOCK_PREFIX : I<0xF0, RawFrm, (outs),  (ins), "lock", []>;
1781
1782 // Rex64 instruction prefix
1783 def REX64_PREFIX : I<0x48, RawFrm, (outs),  (ins), "rex64", []>,
1784                      Requires<[In64BitMode]>;
1785
1786 // Data16 instruction prefix
1787 def DATA16_PREFIX : I<0x66, RawFrm, (outs),  (ins), "data16", []>;
1788
1789 // Repeat string operation instruction prefixes
1790 // These uses the DF flag in the EFLAGS register to inc or dec ECX
1791 let Defs = [ECX], Uses = [ECX,EFLAGS] in {
1792 // Repeat (used with INS, OUTS, MOVS, LODS and STOS)
1793 def REP_PREFIX : I<0xF3, RawFrm, (outs),  (ins), "rep", []>;
1794 // Repeat while not equal (used with CMPS and SCAS)
1795 def REPNE_PREFIX : I<0xF2, RawFrm, (outs),  (ins), "repne", []>;
1796 }
1797
1798
1799 // String manipulation instructions
1800 let SchedRW = [WriteMicrocoded] in {
1801 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1802 let Defs = [AL,ESI], Uses = [ESI,EFLAGS] in
1803 def LODSB : I<0xAC, RawFrmSrc, (outs), (ins srcidx8:$src),
1804               "lodsb\t{$src, %al|al, $src}", [], IIC_LODS>;
1805 let Defs = [AX,ESI], Uses = [ESI,EFLAGS] in
1806 def LODSW : I<0xAD, RawFrmSrc, (outs), (ins srcidx16:$src),
1807               "lodsw\t{$src, %ax|ax, $src}", [], IIC_LODS>, OpSize16;
1808 let Defs = [EAX,ESI], Uses = [ESI,EFLAGS] in
1809 def LODSL : I<0xAD, RawFrmSrc, (outs), (ins srcidx32:$src),
1810               "lods{l|d}\t{$src, %eax|eax, $src}", [], IIC_LODS>, OpSize32;
1811 let Defs = [RAX,ESI], Uses = [ESI,EFLAGS] in
1812 def LODSQ : RI<0xAD, RawFrmSrc, (outs), (ins srcidx64:$src),
1813                "lodsq\t{$src, %rax|rax, $src}", [], IIC_LODS>;
1814 }
1815
1816 let SchedRW = [WriteSystem] in {
1817 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1818 let Defs = [ESI], Uses = [DX,ESI,EFLAGS] in {
1819 def OUTSB : I<0x6E, RawFrmSrc, (outs), (ins srcidx8:$src),
1820              "outsb\t{$src, %dx|dx, $src}", [], IIC_OUTS>;
1821 def OUTSW : I<0x6F, RawFrmSrc, (outs), (ins srcidx16:$src),
1822               "outsw\t{$src, %dx|dx, $src}", [], IIC_OUTS>, OpSize16;
1823 def OUTSL : I<0x6F, RawFrmSrc, (outs), (ins srcidx32:$src),
1824               "outs{l|d}\t{$src, %dx|dx, $src}", [], IIC_OUTS>, OpSize32;
1825 }
1826
1827 // These uses the DF flag in the EFLAGS register to inc or dec EDI and ESI
1828 let Defs = [EDI], Uses = [DX,EDI,EFLAGS] in {
1829 def INSB : I<0x6C, RawFrmDst, (outs dstidx8:$dst), (ins),
1830              "insb\t{%dx, $dst|$dst, dx}", [], IIC_INS>;
1831 def INSW : I<0x6D, RawFrmDst, (outs dstidx16:$dst), (ins),
1832              "insw\t{%dx, $dst|$dst, dx}", [], IIC_INS>,  OpSize16;
1833 def INSL : I<0x6D, RawFrmDst, (outs dstidx32:$dst), (ins),
1834              "ins{l|d}\t{%dx, $dst|$dst, dx}", [], IIC_INS>, OpSize32;
1835 }
1836 }
1837
1838 // Flag instructions
1839 let SchedRW = [WriteALU] in {
1840 def CLC : I<0xF8, RawFrm, (outs), (ins), "clc", [], IIC_CLC>;
1841 def STC : I<0xF9, RawFrm, (outs), (ins), "stc", [], IIC_STC>;
1842 def CLI : I<0xFA, RawFrm, (outs), (ins), "cli", [], IIC_CLI>;
1843 def STI : I<0xFB, RawFrm, (outs), (ins), "sti", [], IIC_STI>;
1844 def CLD : I<0xFC, RawFrm, (outs), (ins), "cld", [], IIC_CLD>;
1845 def STD : I<0xFD, RawFrm, (outs), (ins), "std", [], IIC_STD>;
1846 def CMC : I<0xF5, RawFrm, (outs), (ins), "cmc", [], IIC_CMC>;
1847
1848 def CLTS : I<0x06, RawFrm, (outs), (ins), "clts", [], IIC_CLTS>, TB;
1849 }
1850
1851 // Table lookup instructions
1852 def XLAT : I<0xD7, RawFrm, (outs), (ins), "xlatb", [], IIC_XLAT>,
1853            Sched<[WriteLoad]>;
1854
1855 let SchedRW = [WriteMicrocoded] in {
1856 // ASCII Adjust After Addition
1857 // sets AL, AH and CF and AF of EFLAGS and uses AL and AF of EFLAGS
1858 def AAA : I<0x37, RawFrm, (outs), (ins), "aaa", [], IIC_AAA>,
1859             Requires<[Not64BitMode]>;
1860
1861 // ASCII Adjust AX Before Division
1862 // sets AL, AH and EFLAGS and uses AL and AH
1863 def AAD8i8 : Ii8<0xD5, RawFrm, (outs), (ins i8imm:$src),
1864                  "aad\t$src", [], IIC_AAD>, Requires<[Not64BitMode]>;
1865
1866 // ASCII Adjust AX After Multiply
1867 // sets AL, AH and EFLAGS and uses AL
1868 def AAM8i8 : Ii8<0xD4, RawFrm, (outs), (ins i8imm:$src),
1869                  "aam\t$src", [], IIC_AAM>, Requires<[Not64BitMode]>;
1870
1871 // ASCII Adjust AL After Subtraction - sets
1872 // sets AL, AH and CF and AF of EFLAGS and uses AL and AF of EFLAGS
1873 def AAS : I<0x3F, RawFrm, (outs), (ins), "aas", [], IIC_AAS>,
1874             Requires<[Not64BitMode]>;
1875
1876 // Decimal Adjust AL after Addition
1877 // sets AL, CF and AF of EFLAGS and uses AL, CF and AF of EFLAGS
1878 def DAA : I<0x27, RawFrm, (outs), (ins), "daa", [], IIC_DAA>,
1879             Requires<[Not64BitMode]>;
1880
1881 // Decimal Adjust AL after Subtraction
1882 // sets AL, CF and AF of EFLAGS and uses AL, CF and AF of EFLAGS
1883 def DAS : I<0x2F, RawFrm, (outs), (ins), "das", [], IIC_DAS>,
1884             Requires<[Not64BitMode]>;
1885 } // SchedRW
1886
1887 let SchedRW = [WriteSystem] in {
1888 // Check Array Index Against Bounds
1889 def BOUNDS16rm : I<0x62, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
1890                    "bound\t{$src, $dst|$dst, $src}", [], IIC_BOUND>, OpSize16,
1891                    Requires<[Not64BitMode]>;
1892 def BOUNDS32rm : I<0x62, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
1893                    "bound\t{$src, $dst|$dst, $src}", [], IIC_BOUND>, OpSize32,
1894                    Requires<[Not64BitMode]>;
1895
1896 // Adjust RPL Field of Segment Selector
1897 def ARPL16rr : I<0x63, MRMDestReg, (outs GR16:$dst), (ins GR16:$src),
1898                  "arpl\t{$src, $dst|$dst, $src}", [], IIC_ARPL_REG>,
1899                  Requires<[Not64BitMode]>;
1900 def ARPL16mr : I<0x63, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
1901                  "arpl\t{$src, $dst|$dst, $src}", [], IIC_ARPL_MEM>,
1902                  Requires<[Not64BitMode]>;
1903 } // SchedRW
1904
1905 //===----------------------------------------------------------------------===//
1906 // MOVBE Instructions
1907 //
1908 let Predicates = [HasMOVBE] in {
1909   let SchedRW = [WriteALULd] in {
1910   def MOVBE16rm : I<0xF0, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
1911                     "movbe{w}\t{$src, $dst|$dst, $src}",
1912                     [(set GR16:$dst, (bswap (loadi16 addr:$src)))], IIC_MOVBE>,
1913                     OpSize16, T8PS;
1914   def MOVBE32rm : I<0xF0, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
1915                     "movbe{l}\t{$src, $dst|$dst, $src}",
1916                     [(set GR32:$dst, (bswap (loadi32 addr:$src)))], IIC_MOVBE>,
1917                     OpSize32, T8PS;
1918   def MOVBE64rm : RI<0xF0, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
1919                      "movbe{q}\t{$src, $dst|$dst, $src}",
1920                      [(set GR64:$dst, (bswap (loadi64 addr:$src)))], IIC_MOVBE>,
1921                      T8PS;
1922   }
1923   let SchedRW = [WriteStore] in {
1924   def MOVBE16mr : I<0xF1, MRMDestMem, (outs), (ins i16mem:$dst, GR16:$src),
1925                     "movbe{w}\t{$src, $dst|$dst, $src}",
1926                     [(store (bswap GR16:$src), addr:$dst)], IIC_MOVBE>,
1927                     OpSize16, T8PS;
1928   def MOVBE32mr : I<0xF1, MRMDestMem, (outs), (ins i32mem:$dst, GR32:$src),
1929                     "movbe{l}\t{$src, $dst|$dst, $src}",
1930                     [(store (bswap GR32:$src), addr:$dst)], IIC_MOVBE>,
1931                     OpSize32, T8PS;
1932   def MOVBE64mr : RI<0xF1, MRMDestMem, (outs), (ins i64mem:$dst, GR64:$src),
1933                      "movbe{q}\t{$src, $dst|$dst, $src}",
1934                      [(store (bswap GR64:$src), addr:$dst)], IIC_MOVBE>,
1935                      T8PS;
1936   }
1937 }
1938
1939 //===----------------------------------------------------------------------===//
1940 // RDRAND Instruction
1941 //
1942 let Predicates = [HasRDRAND], Defs = [EFLAGS] in {
1943   def RDRAND16r : I<0xC7, MRM6r, (outs GR16:$dst), (ins),
1944                     "rdrand{w}\t$dst",
1945                     [(set GR16:$dst, EFLAGS, (X86rdrand))]>, OpSize16, TB;
1946   def RDRAND32r : I<0xC7, MRM6r, (outs GR32:$dst), (ins),
1947                     "rdrand{l}\t$dst",
1948                     [(set GR32:$dst, EFLAGS, (X86rdrand))]>, OpSize32, TB;
1949   def RDRAND64r : RI<0xC7, MRM6r, (outs GR64:$dst), (ins),
1950                      "rdrand{q}\t$dst",
1951                      [(set GR64:$dst, EFLAGS, (X86rdrand))]>, TB;
1952 }
1953
1954 //===----------------------------------------------------------------------===//
1955 // RDSEED Instruction
1956 //
1957 let Predicates = [HasRDSEED], Defs = [EFLAGS] in {
1958   def RDSEED16r : I<0xC7, MRM7r, (outs GR16:$dst), (ins),
1959                     "rdseed{w}\t$dst",
1960                     [(set GR16:$dst, EFLAGS, (X86rdseed))]>, OpSize16, TB;
1961   def RDSEED32r : I<0xC7, MRM7r, (outs GR32:$dst), (ins),
1962                     "rdseed{l}\t$dst",
1963                     [(set GR32:$dst, EFLAGS, (X86rdseed))]>, OpSize32, TB;
1964   def RDSEED64r : RI<0xC7, MRM7r, (outs GR64:$dst), (ins),
1965                      "rdseed{q}\t$dst",
1966                      [(set GR64:$dst, EFLAGS, (X86rdseed))]>, TB;
1967 }
1968
1969 //===----------------------------------------------------------------------===//
1970 // LZCNT Instruction
1971 //
1972 let Predicates = [HasLZCNT], Defs = [EFLAGS] in {
1973   def LZCNT16rr : I<0xBD, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
1974                     "lzcnt{w}\t{$src, $dst|$dst, $src}",
1975                     [(set GR16:$dst, (ctlz GR16:$src)), (implicit EFLAGS)]>, XS,
1976                     OpSize16;
1977   def LZCNT16rm : I<0xBD, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
1978                     "lzcnt{w}\t{$src, $dst|$dst, $src}",
1979                     [(set GR16:$dst, (ctlz (loadi16 addr:$src))),
1980                      (implicit EFLAGS)]>, XS, OpSize16;
1981
1982   def LZCNT32rr : I<0xBD, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
1983                     "lzcnt{l}\t{$src, $dst|$dst, $src}",
1984                     [(set GR32:$dst, (ctlz GR32:$src)), (implicit EFLAGS)]>, XS,
1985                     OpSize32;
1986   def LZCNT32rm : I<0xBD, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
1987                     "lzcnt{l}\t{$src, $dst|$dst, $src}",
1988                     [(set GR32:$dst, (ctlz (loadi32 addr:$src))),
1989                      (implicit EFLAGS)]>, XS, OpSize32;
1990
1991   def LZCNT64rr : RI<0xBD, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
1992                      "lzcnt{q}\t{$src, $dst|$dst, $src}",
1993                      [(set GR64:$dst, (ctlz GR64:$src)), (implicit EFLAGS)]>,
1994                      XS;
1995   def LZCNT64rm : RI<0xBD, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
1996                      "lzcnt{q}\t{$src, $dst|$dst, $src}",
1997                      [(set GR64:$dst, (ctlz (loadi64 addr:$src))),
1998                       (implicit EFLAGS)]>, XS;
1999 }
2000
2001 let Predicates = [HasLZCNT] in {
2002   def : Pat<(X86cmov (ctlz GR16:$src), (i16 16), (X86_COND_E_OR_NE),
2003               (X86cmp GR16:$src, (i16 0))),
2004             (LZCNT16rr GR16:$src)>;
2005   def : Pat<(X86cmov (ctlz GR32:$src), (i32 32), (X86_COND_E_OR_NE),
2006               (X86cmp GR32:$src, (i32 0))),
2007             (LZCNT32rr GR32:$src)>;
2008   def : Pat<(X86cmov (ctlz GR64:$src), (i64 64), (X86_COND_E_OR_NE),
2009               (X86cmp GR64:$src, (i64 0))),
2010             (LZCNT64rr GR64:$src)>;
2011   def : Pat<(X86cmov (i16 16), (ctlz GR16:$src), (X86_COND_E_OR_NE),
2012               (X86cmp GR16:$src, (i16 0))),
2013             (LZCNT16rr GR16:$src)>;
2014   def : Pat<(X86cmov (i32 32), (ctlz GR32:$src), (X86_COND_E_OR_NE),
2015               (X86cmp GR32:$src, (i32 0))),
2016             (LZCNT32rr GR32:$src)>;
2017   def : Pat<(X86cmov (i64 64), (ctlz GR64:$src), (X86_COND_E_OR_NE),
2018               (X86cmp GR64:$src, (i64 0))),
2019             (LZCNT64rr GR64:$src)>;
2020
2021   def : Pat<(X86cmov (ctlz (loadi16 addr:$src)), (i16 16), (X86_COND_E_OR_NE),
2022               (X86cmp (loadi16 addr:$src), (i16 0))),
2023             (LZCNT16rm addr:$src)>;
2024   def : Pat<(X86cmov (ctlz (loadi32 addr:$src)), (i32 32), (X86_COND_E_OR_NE),
2025               (X86cmp (loadi32 addr:$src), (i32 0))),
2026             (LZCNT32rm addr:$src)>;
2027   def : Pat<(X86cmov (ctlz (loadi64 addr:$src)), (i64 64), (X86_COND_E_OR_NE),
2028               (X86cmp (loadi64 addr:$src), (i64 0))),
2029             (LZCNT64rm addr:$src)>;
2030   def : Pat<(X86cmov (i16 16), (ctlz (loadi16 addr:$src)), (X86_COND_E_OR_NE),
2031               (X86cmp (loadi16 addr:$src), (i16 0))),
2032             (LZCNT16rm addr:$src)>;
2033   def : Pat<(X86cmov (i32 32), (ctlz (loadi32 addr:$src)), (X86_COND_E_OR_NE),
2034               (X86cmp (loadi32 addr:$src), (i32 0))),
2035             (LZCNT32rm addr:$src)>;
2036   def : Pat<(X86cmov (i64 64), (ctlz (loadi64 addr:$src)), (X86_COND_E_OR_NE),
2037               (X86cmp (loadi64 addr:$src), (i64 0))),
2038             (LZCNT64rm addr:$src)>;
2039 }
2040
2041 //===----------------------------------------------------------------------===//
2042 // BMI Instructions
2043 //
2044 let Predicates = [HasBMI], Defs = [EFLAGS] in {
2045   def TZCNT16rr : I<0xBC, MRMSrcReg, (outs GR16:$dst), (ins GR16:$src),
2046                     "tzcnt{w}\t{$src, $dst|$dst, $src}",
2047                     [(set GR16:$dst, (cttz GR16:$src)), (implicit EFLAGS)]>, XS,
2048                     OpSize16;
2049   def TZCNT16rm : I<0xBC, MRMSrcMem, (outs GR16:$dst), (ins i16mem:$src),
2050                     "tzcnt{w}\t{$src, $dst|$dst, $src}",
2051                     [(set GR16:$dst, (cttz (loadi16 addr:$src))),
2052                      (implicit EFLAGS)]>, XS, OpSize16;
2053
2054   def TZCNT32rr : I<0xBC, MRMSrcReg, (outs GR32:$dst), (ins GR32:$src),
2055                     "tzcnt{l}\t{$src, $dst|$dst, $src}",
2056                     [(set GR32:$dst, (cttz GR32:$src)), (implicit EFLAGS)]>, XS,
2057                     OpSize32;
2058   def TZCNT32rm : I<0xBC, MRMSrcMem, (outs GR32:$dst), (ins i32mem:$src),
2059                     "tzcnt{l}\t{$src, $dst|$dst, $src}",
2060                     [(set GR32:$dst, (cttz (loadi32 addr:$src))),
2061                      (implicit EFLAGS)]>, XS, OpSize32;
2062
2063   def TZCNT64rr : RI<0xBC, MRMSrcReg, (outs GR64:$dst), (ins GR64:$src),
2064                      "tzcnt{q}\t{$src, $dst|$dst, $src}",
2065                      [(set GR64:$dst, (cttz GR64:$src)), (implicit EFLAGS)]>,
2066                      XS;
2067   def TZCNT64rm : RI<0xBC, MRMSrcMem, (outs GR64:$dst), (ins i64mem:$src),
2068                      "tzcnt{q}\t{$src, $dst|$dst, $src}",
2069                      [(set GR64:$dst, (cttz (loadi64 addr:$src))),
2070                       (implicit EFLAGS)]>, XS;
2071 }
2072
2073 multiclass bmi_bls<string mnemonic, Format RegMRM, Format MemMRM,
2074                   RegisterClass RC, X86MemOperand x86memop> {
2075 let hasSideEffects = 0 in {
2076   def rr : I<0xF3, RegMRM, (outs RC:$dst), (ins RC:$src),
2077              !strconcat(mnemonic, "\t{$src, $dst|$dst, $src}"),
2078              []>, T8PS, VEX_4V;
2079   let mayLoad = 1 in
2080   def rm : I<0xF3, MemMRM, (outs RC:$dst), (ins x86memop:$src),
2081              !strconcat(mnemonic, "\t{$src, $dst|$dst, $src}"),
2082              []>, T8PS, VEX_4V;
2083 }
2084 }
2085
2086 let Predicates = [HasBMI], Defs = [EFLAGS] in {
2087   defm BLSR32 : bmi_bls<"blsr{l}", MRM1r, MRM1m, GR32, i32mem>;
2088   defm BLSR64 : bmi_bls<"blsr{q}", MRM1r, MRM1m, GR64, i64mem>, VEX_W;
2089   defm BLSMSK32 : bmi_bls<"blsmsk{l}", MRM2r, MRM2m, GR32, i32mem>;
2090   defm BLSMSK64 : bmi_bls<"blsmsk{q}", MRM2r, MRM2m, GR64, i64mem>, VEX_W;
2091   defm BLSI32 : bmi_bls<"blsi{l}", MRM3r, MRM3m, GR32, i32mem>;
2092   defm BLSI64 : bmi_bls<"blsi{q}", MRM3r, MRM3m, GR64, i64mem>, VEX_W;
2093 }
2094
2095 //===----------------------------------------------------------------------===//
2096 // Pattern fragments to auto generate BMI instructions.
2097 //===----------------------------------------------------------------------===//
2098
2099 let Predicates = [HasBMI] in {
2100   // FIXME: patterns for the load versions are not implemented
2101   def : Pat<(and GR32:$src, (add GR32:$src, -1)),
2102             (BLSR32rr GR32:$src)>;
2103   def : Pat<(and GR64:$src, (add GR64:$src, -1)),
2104             (BLSR64rr GR64:$src)>;
2105
2106   def : Pat<(xor GR32:$src, (add GR32:$src, -1)),
2107             (BLSMSK32rr GR32:$src)>;
2108   def : Pat<(xor GR64:$src, (add GR64:$src, -1)),
2109             (BLSMSK64rr GR64:$src)>;
2110
2111   def : Pat<(and GR32:$src, (ineg GR32:$src)),
2112             (BLSI32rr GR32:$src)>;
2113   def : Pat<(and GR64:$src, (ineg GR64:$src)),
2114             (BLSI64rr GR64:$src)>;
2115 }
2116
2117 let Predicates = [HasBMI] in {
2118   def : Pat<(X86cmov (cttz GR16:$src), (i16 16), (X86_COND_E_OR_NE),
2119               (X86cmp GR16:$src, (i16 0))),
2120             (TZCNT16rr GR16:$src)>;
2121   def : Pat<(X86cmov (cttz GR32:$src), (i32 32), (X86_COND_E_OR_NE),
2122               (X86cmp GR32:$src, (i32 0))),
2123             (TZCNT32rr GR32:$src)>;
2124   def : Pat<(X86cmov (cttz GR64:$src), (i64 64), (X86_COND_E_OR_NE),
2125               (X86cmp GR64:$src, (i64 0))),
2126             (TZCNT64rr GR64:$src)>;
2127   def : Pat<(X86cmov (i16 16), (cttz GR16:$src), (X86_COND_E_OR_NE),
2128               (X86cmp GR16:$src, (i16 0))),
2129             (TZCNT16rr GR16:$src)>;
2130   def : Pat<(X86cmov (i32 32), (cttz GR32:$src), (X86_COND_E_OR_NE),
2131               (X86cmp GR32:$src, (i32 0))),
2132             (TZCNT32rr GR32:$src)>;
2133   def : Pat<(X86cmov (i64 64), (cttz GR64:$src), (X86_COND_E_OR_NE),
2134               (X86cmp GR64:$src, (i64 0))),
2135             (TZCNT64rr GR64:$src)>;
2136
2137   def : Pat<(X86cmov (cttz (loadi16 addr:$src)), (i16 16), (X86_COND_E_OR_NE),
2138               (X86cmp (loadi16 addr:$src), (i16 0))),
2139             (TZCNT16rm addr:$src)>;
2140   def : Pat<(X86cmov (cttz (loadi32 addr:$src)), (i32 32), (X86_COND_E_OR_NE),
2141               (X86cmp (loadi32 addr:$src), (i32 0))),
2142             (TZCNT32rm addr:$src)>;
2143   def : Pat<(X86cmov (cttz (loadi64 addr:$src)), (i64 64), (X86_COND_E_OR_NE),
2144               (X86cmp (loadi64 addr:$src), (i64 0))),
2145             (TZCNT64rm addr:$src)>;
2146   def : Pat<(X86cmov (i16 16), (cttz (loadi16 addr:$src)), (X86_COND_E_OR_NE),
2147               (X86cmp (loadi16 addr:$src), (i16 0))),
2148             (TZCNT16rm addr:$src)>;
2149   def : Pat<(X86cmov (i32 32), (cttz (loadi32 addr:$src)), (X86_COND_E_OR_NE),
2150               (X86cmp (loadi32 addr:$src), (i32 0))),
2151             (TZCNT32rm addr:$src)>;
2152   def : Pat<(X86cmov (i64 64), (cttz (loadi64 addr:$src)), (X86_COND_E_OR_NE),
2153               (X86cmp (loadi64 addr:$src), (i64 0))),
2154             (TZCNT64rm addr:$src)>;
2155 }
2156
2157
2158 multiclass bmi_bextr_bzhi<bits<8> opc, string mnemonic, RegisterClass RC,
2159                           X86MemOperand x86memop, Intrinsic Int,
2160                           PatFrag ld_frag> {
2161   def rr : I<opc, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
2162              !strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
2163              [(set RC:$dst, (Int RC:$src1, RC:$src2)), (implicit EFLAGS)]>,
2164              T8PS, VEX_4VOp3;
2165   def rm : I<opc, MRMSrcMem, (outs RC:$dst), (ins x86memop:$src1, RC:$src2),
2166              !strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
2167              [(set RC:$dst, (Int (ld_frag addr:$src1), RC:$src2)),
2168               (implicit EFLAGS)]>, T8PS, VEX_4VOp3;
2169 }
2170
2171 let Predicates = [HasBMI], Defs = [EFLAGS] in {
2172   defm BEXTR32 : bmi_bextr_bzhi<0xF7, "bextr{l}", GR32, i32mem,
2173                                 int_x86_bmi_bextr_32, loadi32>;
2174   defm BEXTR64 : bmi_bextr_bzhi<0xF7, "bextr{q}", GR64, i64mem,
2175                                 int_x86_bmi_bextr_64, loadi64>, VEX_W;
2176 }
2177
2178 let Predicates = [HasBMI2], Defs = [EFLAGS] in {
2179   defm BZHI32 : bmi_bextr_bzhi<0xF5, "bzhi{l}", GR32, i32mem,
2180                                int_x86_bmi_bzhi_32, loadi32>;
2181   defm BZHI64 : bmi_bextr_bzhi<0xF5, "bzhi{q}", GR64, i64mem,
2182                                int_x86_bmi_bzhi_64, loadi64>, VEX_W;
2183 }
2184
2185
2186 def CountTrailingOnes : SDNodeXForm<imm, [{
2187   // Count the trailing ones in the immediate.
2188   return getI8Imm(CountTrailingOnes_64(N->getZExtValue()));
2189 }]>;
2190
2191 def BZHIMask : ImmLeaf<i64, [{
2192   return isMask_64(Imm) && (CountTrailingOnes_64(Imm) > 32);
2193 }]>;
2194
2195 let Predicates = [HasBMI2] in {
2196   def : Pat<(and GR64:$src, BZHIMask:$mask),
2197             (BZHI64rr GR64:$src,
2198               (INSERT_SUBREG (i64 (IMPLICIT_DEF)),
2199                              (MOV8ri (CountTrailingOnes imm:$mask)), sub_8bit))>;
2200
2201   def : Pat<(and GR32:$src, (add (shl 1, GR8:$lz), -1)),
2202             (BZHI32rr GR32:$src,
2203               (INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
2204
2205   def : Pat<(and (loadi32 addr:$src), (add (shl 1, GR8:$lz), -1)),
2206             (BZHI32rm addr:$src,
2207               (INSERT_SUBREG (i32 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
2208
2209   def : Pat<(and GR64:$src, (add (shl 1, GR8:$lz), -1)),
2210             (BZHI64rr GR64:$src,
2211               (INSERT_SUBREG (i64 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
2212
2213   def : Pat<(and (loadi64 addr:$src), (add (shl 1, GR8:$lz), -1)),
2214             (BZHI64rm addr:$src,
2215               (INSERT_SUBREG (i64 (IMPLICIT_DEF)), GR8:$lz, sub_8bit))>;
2216 } // HasBMI2
2217
2218 let Predicates = [HasBMI] in {
2219   def : Pat<(X86bextr GR32:$src1, GR32:$src2),
2220             (BEXTR32rr GR32:$src1, GR32:$src2)>;
2221   def : Pat<(X86bextr (loadi32 addr:$src1), GR32:$src2),
2222             (BEXTR32rm addr:$src1, GR32:$src2)>;
2223   def : Pat<(X86bextr GR64:$src1, GR64:$src2),
2224             (BEXTR64rr GR64:$src1, GR64:$src2)>;
2225   def : Pat<(X86bextr (loadi64 addr:$src1), GR64:$src2),
2226             (BEXTR64rm addr:$src1, GR64:$src2)>;
2227 } // HasBMI
2228
2229 multiclass bmi_pdep_pext<string mnemonic, RegisterClass RC,
2230                          X86MemOperand x86memop, Intrinsic Int,
2231                          PatFrag ld_frag> {
2232   def rr : I<0xF5, MRMSrcReg, (outs RC:$dst), (ins RC:$src1, RC:$src2),
2233              !strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
2234              [(set RC:$dst, (Int RC:$src1, RC:$src2))]>,
2235              VEX_4V;
2236   def rm : I<0xF5, MRMSrcMem, (outs RC:$dst), (ins RC:$src1, x86memop:$src2),
2237              !strconcat(mnemonic, "\t{$src2, $src1, $dst|$dst, $src1, $src2}"),
2238              [(set RC:$dst, (Int RC:$src1, (ld_frag addr:$src2)))]>, VEX_4V;
2239 }
2240
2241 let Predicates = [HasBMI2] in {
2242   defm PDEP32 : bmi_pdep_pext<"pdep{l}", GR32, i32mem,
2243                                int_x86_bmi_pdep_32, loadi32>, T8XD;
2244   defm PDEP64 : bmi_pdep_pext<"pdep{q}", GR64, i64mem,
2245                                int_x86_bmi_pdep_64, loadi64>, T8XD, VEX_W;
2246   defm PEXT32 : bmi_pdep_pext<"pext{l}", GR32, i32mem,
2247                                int_x86_bmi_pext_32, loadi32>, T8XS;
2248   defm PEXT64 : bmi_pdep_pext<"pext{q}", GR64, i64mem,
2249                                int_x86_bmi_pext_64, loadi64>, T8XS, VEX_W;
2250 }
2251
2252 //===----------------------------------------------------------------------===//
2253 // TBM Instructions
2254 //
2255 let Predicates = [HasTBM], Defs = [EFLAGS] in {
2256
2257 multiclass tbm_ternary_imm_intr<bits<8> opc, RegisterClass RC, string OpcodeStr,
2258                                 X86MemOperand x86memop, PatFrag ld_frag,
2259                                 Intrinsic Int, Operand immtype,
2260                                 SDPatternOperator immoperator> {
2261   def ri : Ii32<opc,  MRMSrcReg, (outs RC:$dst), (ins RC:$src1, immtype:$cntl),
2262                 !strconcat(OpcodeStr,
2263                            "\t{$cntl, $src1, $dst|$dst, $src1, $cntl}"),
2264                 [(set RC:$dst, (Int RC:$src1, immoperator:$cntl))]>,
2265            XOP, XOPA;
2266   def mi : Ii32<opc,  MRMSrcMem, (outs RC:$dst),
2267                 (ins x86memop:$src1, immtype:$cntl),
2268                 !strconcat(OpcodeStr,
2269                            "\t{$cntl, $src1, $dst|$dst, $src1, $cntl}"),
2270                 [(set RC:$dst, (Int (ld_frag addr:$src1), immoperator:$cntl))]>,
2271            XOP, XOPA;
2272 }
2273
2274 defm BEXTRI32 : tbm_ternary_imm_intr<0x10, GR32, "bextr", i32mem, loadi32,
2275                                      int_x86_tbm_bextri_u32, i32imm, imm>;
2276 let ImmT = Imm32S in
2277 defm BEXTRI64 : tbm_ternary_imm_intr<0x10, GR64, "bextr", i64mem, loadi64,
2278                                      int_x86_tbm_bextri_u64, i64i32imm,
2279                                      i64immSExt32>, VEX_W;
2280
2281 multiclass tbm_binary_rm<bits<8> opc, Format FormReg, Format FormMem,
2282                          RegisterClass RC, string OpcodeStr,
2283                          X86MemOperand x86memop, PatFrag ld_frag> {
2284 let hasSideEffects = 0 in {
2285   def rr : I<opc,  FormReg, (outs RC:$dst), (ins RC:$src),
2286              !strconcat(OpcodeStr,"\t{$src, $dst|$dst, $src}"),
2287              []>, XOP_4V, XOP9;
2288   let mayLoad = 1 in
2289   def rm : I<opc,  FormMem, (outs RC:$dst), (ins x86memop:$src),
2290              !strconcat(OpcodeStr,"\t{$src, $dst|$dst, $src}"),
2291              []>, XOP_4V, XOP9;
2292 }
2293 }
2294
2295 multiclass tbm_binary_intr<bits<8> opc, string OpcodeStr,
2296                            Format FormReg, Format FormMem> {
2297   defm NAME#32 : tbm_binary_rm<opc, FormReg, FormMem, GR32, OpcodeStr, i32mem,
2298                                loadi32>;
2299   defm NAME#64 : tbm_binary_rm<opc, FormReg, FormMem, GR64, OpcodeStr, i64mem,
2300                                loadi64>, VEX_W;
2301 }
2302
2303 defm BLCFILL : tbm_binary_intr<0x01, "blcfill", MRM1r, MRM1m>;
2304 defm BLCI    : tbm_binary_intr<0x02, "blci", MRM6r, MRM6m>;
2305 defm BLCIC   : tbm_binary_intr<0x01, "blcic", MRM5r, MRM5m>;
2306 defm BLCMSK  : tbm_binary_intr<0x02, "blcmsk", MRM1r, MRM1m>;
2307 defm BLCS    : tbm_binary_intr<0x01, "blcs", MRM3r, MRM3m>;
2308 defm BLSFILL : tbm_binary_intr<0x01, "blsfill", MRM2r, MRM2m>;
2309 defm BLSIC   : tbm_binary_intr<0x01, "blsic", MRM6r, MRM6m>;
2310 defm T1MSKC  : tbm_binary_intr<0x01, "t1mskc", MRM7r, MRM7m>;
2311 defm TZMSK   : tbm_binary_intr<0x01, "tzmsk", MRM4r, MRM4m>;
2312 } // HasTBM, EFLAGS
2313
2314 //===----------------------------------------------------------------------===//
2315 // Pattern fragments to auto generate TBM instructions.
2316 //===----------------------------------------------------------------------===//
2317
2318 let Predicates = [HasTBM] in {
2319   def : Pat<(X86bextr GR32:$src1, (i32 imm:$src2)),
2320             (BEXTRI32ri GR32:$src1, imm:$src2)>;
2321   def : Pat<(X86bextr (loadi32 addr:$src1), (i32 imm:$src2)),
2322             (BEXTRI32mi addr:$src1, imm:$src2)>;
2323   def : Pat<(X86bextr GR64:$src1, i64immSExt32:$src2),
2324             (BEXTRI64ri GR64:$src1, i64immSExt32:$src2)>;
2325   def : Pat<(X86bextr (loadi64 addr:$src1), i64immSExt32:$src2),
2326             (BEXTRI64mi addr:$src1, i64immSExt32:$src2)>;
2327
2328   // FIXME: patterns for the load versions are not implemented
2329   def : Pat<(and GR32:$src, (add GR32:$src, 1)),
2330             (BLCFILL32rr GR32:$src)>;
2331   def : Pat<(and GR64:$src, (add GR64:$src, 1)),
2332             (BLCFILL64rr GR64:$src)>;
2333
2334   def : Pat<(or GR32:$src, (not (add GR32:$src, 1))),
2335             (BLCI32rr GR32:$src)>;
2336   def : Pat<(or GR64:$src, (not (add GR64:$src, 1))),
2337             (BLCI64rr GR64:$src)>;
2338
2339   // Extra patterns because opt can optimize the above patterns to this.
2340   def : Pat<(or GR32:$src, (sub -2, GR32:$src)),
2341             (BLCI32rr GR32:$src)>;
2342   def : Pat<(or GR64:$src, (sub -2, GR64:$src)),
2343             (BLCI64rr GR64:$src)>;
2344
2345   def : Pat<(and (not GR32:$src), (add GR32:$src, 1)),
2346             (BLCIC32rr GR32:$src)>;
2347   def : Pat<(and (not GR64:$src), (add GR64:$src, 1)),
2348             (BLCIC64rr GR64:$src)>;
2349
2350   def : Pat<(xor GR32:$src, (add GR32:$src, 1)),
2351             (BLCMSK32rr GR32:$src)>;
2352   def : Pat<(xor GR64:$src, (add GR64:$src, 1)),
2353             (BLCMSK64rr GR64:$src)>;
2354
2355   def : Pat<(or GR32:$src, (add GR32:$src, 1)),
2356             (BLCS32rr GR32:$src)>;
2357   def : Pat<(or GR64:$src, (add GR64:$src, 1)),
2358             (BLCS64rr GR64:$src)>;
2359
2360   def : Pat<(or GR32:$src, (add GR32:$src, -1)),
2361             (BLSFILL32rr GR32:$src)>;
2362   def : Pat<(or GR64:$src, (add GR64:$src, -1)),
2363             (BLSFILL64rr GR64:$src)>;
2364
2365   def : Pat<(or (not GR32:$src), (add GR32:$src, -1)),
2366             (BLSIC32rr GR32:$src)>;
2367   def : Pat<(or (not GR64:$src), (add GR64:$src, -1)),
2368             (BLSIC64rr GR64:$src)>;
2369
2370   def : Pat<(or (not GR32:$src), (add GR32:$src, 1)),
2371             (T1MSKC32rr GR32:$src)>;
2372   def : Pat<(or (not GR64:$src), (add GR64:$src, 1)),
2373             (T1MSKC64rr GR64:$src)>;
2374
2375   def : Pat<(and (not GR32:$src), (add GR32:$src, -1)),
2376             (TZMSK32rr GR32:$src)>;
2377   def : Pat<(and (not GR64:$src), (add GR64:$src, -1)),
2378             (TZMSK64rr GR64:$src)>;
2379 } // HasTBM
2380
2381 //===----------------------------------------------------------------------===//
2382 // Subsystems.
2383 //===----------------------------------------------------------------------===//
2384
2385 include "X86InstrArithmetic.td"
2386 include "X86InstrCMovSetCC.td"
2387 include "X86InstrExtension.td"
2388 include "X86InstrControl.td"
2389 include "X86InstrShiftRotate.td"
2390
2391 // X87 Floating Point Stack.
2392 include "X86InstrFPStack.td"
2393
2394 // SIMD support (SSE, MMX and AVX)
2395 include "X86InstrFragmentsSIMD.td"
2396
2397 // FMA - Fused Multiply-Add support (requires FMA)
2398 include "X86InstrFMA.td"
2399
2400 // XOP
2401 include "X86InstrXOP.td"
2402
2403 // SSE, MMX and 3DNow! vector support.
2404 include "X86InstrSSE.td"
2405 include "X86InstrAVX512.td"
2406 include "X86InstrMMX.td"
2407 include "X86Instr3DNow.td"
2408
2409 include "X86InstrVMX.td"
2410 include "X86InstrSVM.td"
2411
2412 include "X86InstrTSX.td"
2413 include "X86InstrSGX.td"
2414
2415 // System instructions.
2416 include "X86InstrSystem.td"
2417
2418 // Compiler Pseudo Instructions and Pat Patterns
2419 include "X86InstrCompiler.td"
2420
2421 //===----------------------------------------------------------------------===//
2422 // Assembler Mnemonic Aliases
2423 //===----------------------------------------------------------------------===//
2424
2425 def : MnemonicAlias<"call", "callw", "att">, Requires<[In16BitMode]>;
2426 def : MnemonicAlias<"call", "calll", "att">, Requires<[In32BitMode]>;
2427 def : MnemonicAlias<"call", "callq", "att">, Requires<[In64BitMode]>;
2428
2429 def : MnemonicAlias<"cbw",  "cbtw", "att">;
2430 def : MnemonicAlias<"cwde", "cwtl", "att">;
2431 def : MnemonicAlias<"cwd",  "cwtd", "att">;
2432 def : MnemonicAlias<"cdq",  "cltd", "att">;
2433 def : MnemonicAlias<"cdqe", "cltq", "att">;
2434 def : MnemonicAlias<"cqo",  "cqto", "att">;
2435
2436 // In 64-bit mode lret maps to lretl; it is not ambiguous with lretq.
2437 def : MnemonicAlias<"lret", "lretw", "att">, Requires<[In16BitMode]>;
2438 def : MnemonicAlias<"lret", "lretl", "att">, Requires<[Not16BitMode]>;
2439
2440 def : MnemonicAlias<"leavel", "leave", "att">, Requires<[Not64BitMode]>;
2441 def : MnemonicAlias<"leaveq", "leave", "att">, Requires<[In64BitMode]>;
2442
2443 def : MnemonicAlias<"loopz",  "loope",  "att">;
2444 def : MnemonicAlias<"loopnz", "loopne", "att">;
2445
2446 def : MnemonicAlias<"pop",   "popw",  "att">, Requires<[In16BitMode]>;
2447 def : MnemonicAlias<"pop",   "popl",  "att">, Requires<[In32BitMode]>;
2448 def : MnemonicAlias<"pop",   "popq",  "att">, Requires<[In64BitMode]>;
2449 def : MnemonicAlias<"popf",  "popfw", "att">, Requires<[In16BitMode]>;
2450 def : MnemonicAlias<"popf",  "popfl", "att">, Requires<[In32BitMode]>;
2451 def : MnemonicAlias<"popf",  "popfq", "att">, Requires<[In64BitMode]>;
2452 def : MnemonicAlias<"popfd", "popfl", "att">;
2453
2454 // FIXME: This is wrong for "push reg".  "push %bx" should turn into pushw in
2455 // all modes.  However: "push (addr)" and "push $42" should default to
2456 // pushl/pushq depending on the current mode.  Similar for "pop %bx"
2457 def : MnemonicAlias<"push",   "pushw",  "att">, Requires<[In16BitMode]>;
2458 def : MnemonicAlias<"push",   "pushl",  "att">, Requires<[In32BitMode]>;
2459 def : MnemonicAlias<"push",   "pushq",  "att">, Requires<[In64BitMode]>;
2460 def : MnemonicAlias<"pushf",  "pushfw", "att">, Requires<[In16BitMode]>;
2461 def : MnemonicAlias<"pushf",  "pushfl", "att">, Requires<[In32BitMode]>;
2462 def : MnemonicAlias<"pushf",  "pushfq", "att">, Requires<[In64BitMode]>;
2463 def : MnemonicAlias<"pushfd", "pushfl", "att">;
2464
2465 def : MnemonicAlias<"popad",  "popal",  "intel">, Requires<[Not64BitMode]>;
2466 def : MnemonicAlias<"pushad", "pushal", "intel">, Requires<[Not64BitMode]>;
2467 def : MnemonicAlias<"popa",   "popaw",  "intel">, Requires<[In16BitMode]>;
2468 def : MnemonicAlias<"pusha",  "pushaw", "intel">, Requires<[In16BitMode]>;
2469 def : MnemonicAlias<"popa",   "popal",  "intel">, Requires<[In32BitMode]>;
2470 def : MnemonicAlias<"pusha",  "pushal", "intel">, Requires<[In32BitMode]>;
2471
2472 def : MnemonicAlias<"popa",   "popaw",  "att">, Requires<[In16BitMode]>;
2473 def : MnemonicAlias<"pusha",  "pushaw", "att">, Requires<[In16BitMode]>;
2474 def : MnemonicAlias<"popa",   "popal",  "att">, Requires<[In32BitMode]>;
2475 def : MnemonicAlias<"pusha",  "pushal", "att">, Requires<[In32BitMode]>;
2476
2477 def : MnemonicAlias<"repe",  "rep",   "att">;
2478 def : MnemonicAlias<"repz",  "rep",   "att">;
2479 def : MnemonicAlias<"repnz", "repne", "att">;
2480
2481 def : MnemonicAlias<"ret", "retw", "att">, Requires<[In16BitMode]>;
2482 def : MnemonicAlias<"ret", "retl", "att">, Requires<[In32BitMode]>;
2483 def : MnemonicAlias<"ret", "retq", "att">, Requires<[In64BitMode]>;
2484
2485 def : MnemonicAlias<"salb", "shlb", "att">;
2486 def : MnemonicAlias<"salw", "shlw", "att">;
2487 def : MnemonicAlias<"sall", "shll", "att">;
2488 def : MnemonicAlias<"salq", "shlq", "att">;
2489
2490 def : MnemonicAlias<"smovb", "movsb", "att">;
2491 def : MnemonicAlias<"smovw", "movsw", "att">;
2492 def : MnemonicAlias<"smovl", "movsl", "att">;
2493 def : MnemonicAlias<"smovq", "movsq", "att">;
2494
2495 def : MnemonicAlias<"ud2a",  "ud2",  "att">;
2496 def : MnemonicAlias<"verrw", "verr", "att">;
2497
2498 // System instruction aliases.
2499 def : MnemonicAlias<"iret",    "iretw",    "att">, Requires<[In16BitMode]>;
2500 def : MnemonicAlias<"iret",    "iretl",    "att">, Requires<[Not16BitMode]>;
2501 def : MnemonicAlias<"sysret",  "sysretl",  "att">;
2502 def : MnemonicAlias<"sysexit", "sysexitl", "att">;
2503
2504 def : MnemonicAlias<"lgdt", "lgdtw", "att">, Requires<[In16BitMode]>;
2505 def : MnemonicAlias<"lgdt", "lgdtl", "att">, Requires<[In32BitMode]>;
2506 def : MnemonicAlias<"lgdt", "lgdtq", "att">, Requires<[In64BitMode]>;
2507 def : MnemonicAlias<"lidt", "lidtw", "att">, Requires<[In16BitMode]>;
2508 def : MnemonicAlias<"lidt", "lidtl", "att">, Requires<[In32BitMode]>;
2509 def : MnemonicAlias<"lidt", "lidtq", "att">, Requires<[In64BitMode]>;
2510 def : MnemonicAlias<"sgdt", "sgdtw", "att">, Requires<[In16BitMode]>;
2511 def : MnemonicAlias<"sgdt", "sgdtl", "att">, Requires<[In32BitMode]>;
2512 def : MnemonicAlias<"sgdt", "sgdtq", "att">, Requires<[In64BitMode]>;
2513 def : MnemonicAlias<"sidt", "sidtw", "att">, Requires<[In16BitMode]>;
2514 def : MnemonicAlias<"sidt", "sidtl", "att">, Requires<[In32BitMode]>;
2515 def : MnemonicAlias<"sidt", "sidtq", "att">, Requires<[In64BitMode]>;
2516
2517
2518 // Floating point stack aliases.
2519 def : MnemonicAlias<"fcmovz",   "fcmove",   "att">;
2520 def : MnemonicAlias<"fcmova",   "fcmovnbe", "att">;
2521 def : MnemonicAlias<"fcmovnae", "fcmovb",   "att">;
2522 def : MnemonicAlias<"fcmovna",  "fcmovbe",  "att">;
2523 def : MnemonicAlias<"fcmovae",  "fcmovnb",  "att">;
2524 def : MnemonicAlias<"fcomip",   "fcompi",   "att">;
2525 def : MnemonicAlias<"fildq",    "fildll",   "att">;
2526 def : MnemonicAlias<"fistpq",   "fistpll",  "att">;
2527 def : MnemonicAlias<"fisttpq",  "fisttpll", "att">;
2528 def : MnemonicAlias<"fldcww",   "fldcw",    "att">;
2529 def : MnemonicAlias<"fnstcww",  "fnstcw",   "att">;
2530 def : MnemonicAlias<"fnstsww",  "fnstsw",   "att">;
2531 def : MnemonicAlias<"fucomip",  "fucompi",  "att">;
2532 def : MnemonicAlias<"fwait",    "wait">;
2533
2534
2535 class CondCodeAlias<string Prefix,string Suffix, string OldCond, string NewCond,
2536                     string VariantName>
2537   : MnemonicAlias<!strconcat(Prefix, OldCond, Suffix),
2538                   !strconcat(Prefix, NewCond, Suffix), VariantName>;
2539
2540 /// IntegerCondCodeMnemonicAlias - This multiclass defines a bunch of
2541 /// MnemonicAlias's that canonicalize the condition code in a mnemonic, for
2542 /// example "setz" -> "sete".
2543 multiclass IntegerCondCodeMnemonicAlias<string Prefix, string Suffix,
2544                                         string V = ""> {
2545   def C   : CondCodeAlias<Prefix, Suffix, "c",   "b",  V>; // setc   -> setb
2546   def Z   : CondCodeAlias<Prefix, Suffix, "z" ,  "e",  V>; // setz   -> sete
2547   def NA  : CondCodeAlias<Prefix, Suffix, "na",  "be", V>; // setna  -> setbe
2548   def NB  : CondCodeAlias<Prefix, Suffix, "nb",  "ae", V>; // setnb  -> setae
2549   def NC  : CondCodeAlias<Prefix, Suffix, "nc",  "ae", V>; // setnc  -> setae
2550   def NG  : CondCodeAlias<Prefix, Suffix, "ng",  "le", V>; // setng  -> setle
2551   def NL  : CondCodeAlias<Prefix, Suffix, "nl",  "ge", V>; // setnl  -> setge
2552   def NZ  : CondCodeAlias<Prefix, Suffix, "nz",  "ne", V>; // setnz  -> setne
2553   def PE  : CondCodeAlias<Prefix, Suffix, "pe",  "p",  V>; // setpe  -> setp
2554   def PO  : CondCodeAlias<Prefix, Suffix, "po",  "np", V>; // setpo  -> setnp
2555
2556   def NAE : CondCodeAlias<Prefix, Suffix, "nae", "b",  V>; // setnae -> setb
2557   def NBE : CondCodeAlias<Prefix, Suffix, "nbe", "a",  V>; // setnbe -> seta
2558   def NGE : CondCodeAlias<Prefix, Suffix, "nge", "l",  V>; // setnge -> setl
2559   def NLE : CondCodeAlias<Prefix, Suffix, "nle", "g",  V>; // setnle -> setg
2560 }
2561
2562 // Aliases for set<CC>
2563 defm : IntegerCondCodeMnemonicAlias<"set", "">;
2564 // Aliases for j<CC>
2565 defm : IntegerCondCodeMnemonicAlias<"j", "">;
2566 // Aliases for cmov<CC>{w,l,q}
2567 defm : IntegerCondCodeMnemonicAlias<"cmov", "w", "att">;
2568 defm : IntegerCondCodeMnemonicAlias<"cmov", "l", "att">;
2569 defm : IntegerCondCodeMnemonicAlias<"cmov", "q", "att">;
2570 // No size suffix for intel-style asm.
2571 defm : IntegerCondCodeMnemonicAlias<"cmov", "", "intel">;
2572
2573
2574 //===----------------------------------------------------------------------===//
2575 // Assembler Instruction Aliases
2576 //===----------------------------------------------------------------------===//
2577
2578 // aad/aam default to base 10 if no operand is specified.
2579 def : InstAlias<"aad", (AAD8i8 10)>;
2580 def : InstAlias<"aam", (AAM8i8 10)>;
2581
2582 // Disambiguate the mem/imm form of bt-without-a-suffix as btl.
2583 // Likewise for btc/btr/bts.
2584 def : InstAlias<"bt {$imm, $mem|$mem, $imm}",
2585                 (BT32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
2586 def : InstAlias<"btc {$imm, $mem|$mem, $imm}",
2587                 (BTC32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
2588 def : InstAlias<"btr {$imm, $mem|$mem, $imm}",
2589                 (BTR32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
2590 def : InstAlias<"bts {$imm, $mem|$mem, $imm}",
2591                 (BTS32mi8 i32mem:$mem, i32i8imm:$imm), 0>;
2592
2593 // clr aliases.
2594 def : InstAlias<"clrb $reg", (XOR8rr  GR8 :$reg, GR8 :$reg), 0>;
2595 def : InstAlias<"clrw $reg", (XOR16rr GR16:$reg, GR16:$reg), 0>;
2596 def : InstAlias<"clrl $reg", (XOR32rr GR32:$reg, GR32:$reg), 0>;
2597 def : InstAlias<"clrq $reg", (XOR64rr GR64:$reg, GR64:$reg), 0>;
2598
2599 // lods aliases. Accept the destination being omitted because it's implicit
2600 // in the mnemonic, or the mnemonic suffix being omitted because it's implicit
2601 // in the destination.
2602 def : InstAlias<"lodsb $src", (LODSB srcidx8:$src),  0>;
2603 def : InstAlias<"lodsw $src", (LODSW srcidx16:$src), 0>;
2604 def : InstAlias<"lods{l|d} $src", (LODSL srcidx32:$src), 0>;
2605 def : InstAlias<"lodsq $src", (LODSQ srcidx64:$src), 0>, Requires<[In64BitMode]>;
2606 def : InstAlias<"lods {$src, %al|al, $src}", (LODSB srcidx8:$src),  0>;
2607 def : InstAlias<"lods {$src, %ax|ax, $src}", (LODSW srcidx16:$src), 0>;
2608 def : InstAlias<"lods {$src, %eax|eax, $src}", (LODSL srcidx32:$src), 0>;
2609 def : InstAlias<"lods {$src, %rax|rax, $src}", (LODSQ srcidx64:$src), 0>, Requires<[In64BitMode]>;
2610
2611 // stos aliases. Accept the source being omitted because it's implicit in
2612 // the mnemonic, or the mnemonic suffix being omitted because it's implicit
2613 // in the source.
2614 def : InstAlias<"stosb $dst", (STOSB dstidx8:$dst),  0>;
2615 def : InstAlias<"stosw $dst", (STOSW dstidx16:$dst), 0>;
2616 def : InstAlias<"stos{l|d} $dst", (STOSL dstidx32:$dst), 0>;
2617 def : InstAlias<"stosq $dst", (STOSQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
2618 def : InstAlias<"stos {%al, $dst|$dst, al}", (STOSB dstidx8:$dst),  0>;
2619 def : InstAlias<"stos {%ax, $dst|$dst, ax}", (STOSW dstidx16:$dst), 0>;
2620 def : InstAlias<"stos {%eax, $dst|$dst, eax}", (STOSL dstidx32:$dst), 0>;
2621 def : InstAlias<"stos {%rax, $dst|$dst, rax}", (STOSQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
2622
2623 // scas aliases. Accept the destination being omitted because it's implicit
2624 // in the mnemonic, or the mnemonic suffix being omitted because it's implicit
2625 // in the destination.
2626 def : InstAlias<"scasb $dst", (SCASB dstidx8:$dst),  0>;
2627 def : InstAlias<"scasw $dst", (SCASW dstidx16:$dst), 0>;
2628 def : InstAlias<"scas{l|d} $dst", (SCASL dstidx32:$dst), 0>;
2629 def : InstAlias<"scasq $dst", (SCASQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
2630 def : InstAlias<"scas {$dst, %al|al, $dst}", (SCASB dstidx8:$dst),  0>;
2631 def : InstAlias<"scas {$dst, %ax|ax, $dst}", (SCASW dstidx16:$dst), 0>;
2632 def : InstAlias<"scas {$dst, %eax|eax, $dst}", (SCASL dstidx32:$dst), 0>;
2633 def : InstAlias<"scas {$dst, %rax|rax, $dst}", (SCASQ dstidx64:$dst), 0>, Requires<[In64BitMode]>;
2634
2635 // div and idiv aliases for explicit A register.
2636 def : InstAlias<"div{b}\t{$src, %al|al, $src}", (DIV8r  GR8 :$src)>;
2637 def : InstAlias<"div{w}\t{$src, %ax|ax, $src}", (DIV16r GR16:$src)>;
2638 def : InstAlias<"div{l}\t{$src, %eax|eax, $src}", (DIV32r GR32:$src)>;
2639 def : InstAlias<"div{q}\t{$src, %rax|rax, $src}", (DIV64r GR64:$src)>;
2640 def : InstAlias<"div{b}\t{$src, %al|al, $src}", (DIV8m  i8mem :$src)>;
2641 def : InstAlias<"div{w}\t{$src, %ax|ax, $src}", (DIV16m i16mem:$src)>;
2642 def : InstAlias<"div{l}\t{$src, %eax|eax, $src}", (DIV32m i32mem:$src)>;
2643 def : InstAlias<"div{q}\t{$src, %rax|rax, $src}", (DIV64m i64mem:$src)>;
2644 def : InstAlias<"idiv{b}\t{$src, %al|al, $src}", (IDIV8r  GR8 :$src)>;
2645 def : InstAlias<"idiv{w}\t{$src, %ax|ax, $src}", (IDIV16r GR16:$src)>;
2646 def : InstAlias<"idiv{l}\t{$src, %eax|eax, $src}", (IDIV32r GR32:$src)>;
2647 def : InstAlias<"idiv{q}\t{$src, %rax|rax, $src}", (IDIV64r GR64:$src)>;
2648 def : InstAlias<"idiv{b}\t{$src, %al|al, $src}", (IDIV8m  i8mem :$src)>;
2649 def : InstAlias<"idiv{w}\t{$src, %ax|ax, $src}", (IDIV16m i16mem:$src)>;
2650 def : InstAlias<"idiv{l}\t{$src, %eax|eax, $src}", (IDIV32m i32mem:$src)>;
2651 def : InstAlias<"idiv{q}\t{$src, %rax|rax, $src}", (IDIV64m i64mem:$src)>;
2652
2653
2654
2655 // Various unary fpstack operations default to operating on on ST1.
2656 // For example, "fxch" -> "fxch %st(1)"
2657 def : InstAlias<"faddp",        (ADD_FPrST0  ST1), 0>;
2658 def : InstAlias<"fsub{|r}p",    (SUBR_FPrST0 ST1), 0>;
2659 def : InstAlias<"fsub{r|}p",    (SUB_FPrST0  ST1), 0>;
2660 def : InstAlias<"fmulp",        (MUL_FPrST0  ST1), 0>;
2661 def : InstAlias<"fdiv{|r}p",    (DIVR_FPrST0 ST1), 0>;
2662 def : InstAlias<"fdiv{r|}p",    (DIV_FPrST0  ST1), 0>;
2663 def : InstAlias<"fxch",         (XCH_F       ST1), 0>;
2664 def : InstAlias<"fcom",         (COM_FST0r   ST1), 0>;
2665 def : InstAlias<"fcomp",        (COMP_FST0r  ST1), 0>;
2666 def : InstAlias<"fcomi",        (COM_FIr     ST1), 0>;
2667 def : InstAlias<"fcompi",       (COM_FIPr    ST1), 0>;
2668 def : InstAlias<"fucom",        (UCOM_Fr     ST1), 0>;
2669 def : InstAlias<"fucomp",       (UCOM_FPr    ST1), 0>;
2670 def : InstAlias<"fucomi",       (UCOM_FIr    ST1), 0>;
2671 def : InstAlias<"fucompi",      (UCOM_FIPr   ST1), 0>;
2672
2673 // Handle fmul/fadd/fsub/fdiv instructions with explicitly written st(0) op.
2674 // For example, "fadd %st(4), %st(0)" -> "fadd %st(4)".  We also disambiguate
2675 // instructions like "fadd %st(0), %st(0)" as "fadd %st(0)" for consistency with
2676 // gas.
2677 multiclass FpUnaryAlias<string Mnemonic, Instruction Inst, bit EmitAlias = 1> {
2678  def : InstAlias<!strconcat(Mnemonic, "\t{$op, %st(0)|st(0), $op}"),
2679                  (Inst RST:$op), EmitAlias>;
2680  def : InstAlias<!strconcat(Mnemonic, "\t{%st(0), %st(0)|st(0), st(0)}"),
2681                  (Inst ST0), EmitAlias>;
2682 }
2683
2684 defm : FpUnaryAlias<"fadd",   ADD_FST0r>;
2685 defm : FpUnaryAlias<"faddp",  ADD_FPrST0, 0>;
2686 defm : FpUnaryAlias<"fsub",   SUB_FST0r>;
2687 defm : FpUnaryAlias<"fsub{|r}p",  SUBR_FPrST0>;
2688 defm : FpUnaryAlias<"fsubr",  SUBR_FST0r>;
2689 defm : FpUnaryAlias<"fsub{r|}p", SUB_FPrST0>;
2690 defm : FpUnaryAlias<"fmul",   MUL_FST0r>;
2691 defm : FpUnaryAlias<"fmulp",  MUL_FPrST0>;
2692 defm : FpUnaryAlias<"fdiv",   DIV_FST0r>;
2693 defm : FpUnaryAlias<"fdiv{|r}p",  DIVR_FPrST0>;
2694 defm : FpUnaryAlias<"fdivr",  DIVR_FST0r>;
2695 defm : FpUnaryAlias<"fdiv{r|}p", DIV_FPrST0>;
2696 defm : FpUnaryAlias<"fcomi",   COM_FIr, 0>;
2697 defm : FpUnaryAlias<"fucomi",  UCOM_FIr, 0>;
2698 defm : FpUnaryAlias<"fcompi",   COM_FIPr>;
2699 defm : FpUnaryAlias<"fucompi",  UCOM_FIPr>;
2700
2701
2702 // Handle "f{mulp,addp} st(0), $op" the same as "f{mulp,addp} $op", since they
2703 // commute.  We also allow fdiv[r]p/fsubrp even though they don't commute,
2704 // solely because gas supports it.
2705 def : InstAlias<"faddp\t{%st(0), $op|$op, st(0)}", (ADD_FPrST0 RST:$op), 0>;
2706 def : InstAlias<"fmulp\t{%st(0), $op|$op, st(0)}", (MUL_FPrST0 RST:$op)>;
2707 def : InstAlias<"fsub{|r}p\t{%st(0), $op|$op, st(0)}", (SUBR_FPrST0 RST:$op)>;
2708 def : InstAlias<"fsub{r|}p\t{%st(0), $op|$op, st(0)}", (SUB_FPrST0 RST:$op)>;
2709 def : InstAlias<"fdiv{|r}p\t{%st(0), $op|$op, st(0)}", (DIVR_FPrST0 RST:$op)>;
2710 def : InstAlias<"fdiv{r|}p\t{%st(0), $op|$op, st(0)}", (DIV_FPrST0 RST:$op)>;
2711
2712 // We accept "fnstsw %eax" even though it only writes %ax.
2713 def : InstAlias<"fnstsw\t{%eax|eax}", (FNSTSW16r)>;
2714 def : InstAlias<"fnstsw\t{%al|al}" , (FNSTSW16r)>;
2715 def : InstAlias<"fnstsw"     , (FNSTSW16r)>;
2716
2717 // lcall and ljmp aliases.  This seems to be an odd mapping in 64-bit mode, but
2718 // this is compatible with what GAS does.
2719 def : InstAlias<"lcall $seg, $off", (FARCALL32i i32imm:$off, i16imm:$seg), 0>, Requires<[Not16BitMode]>;
2720 def : InstAlias<"ljmp $seg, $off",  (FARJMP32i  i32imm:$off, i16imm:$seg), 0>, Requires<[Not16BitMode]>;
2721 def : InstAlias<"lcall {*}$dst",    (FARCALL32m opaque48mem:$dst), 0>, Requires<[Not16BitMode]>;
2722 def : InstAlias<"ljmp {*}$dst",     (FARJMP32m  opaque48mem:$dst), 0>, Requires<[Not16BitMode]>;
2723 def : InstAlias<"lcall $seg, $off", (FARCALL16i i16imm:$off, i16imm:$seg), 0>, Requires<[In16BitMode]>;
2724 def : InstAlias<"ljmp $seg, $off",  (FARJMP16i  i16imm:$off, i16imm:$seg), 0>, Requires<[In16BitMode]>;
2725 def : InstAlias<"lcall {*}$dst",    (FARCALL16m opaque32mem:$dst), 0>, Requires<[In16BitMode]>;
2726 def : InstAlias<"ljmp {*}$dst",     (FARJMP16m  opaque32mem:$dst), 0>, Requires<[In16BitMode]>;
2727
2728 def : InstAlias<"call {*}$dst",     (CALL64m i64mem:$dst), 0>, Requires<[In64BitMode]>;
2729 def : InstAlias<"jmp {*}$dst",      (JMP64m  i64mem:$dst), 0>, Requires<[In64BitMode]>;
2730 def : InstAlias<"call {*}$dst",     (CALL32m i32mem:$dst), 0>, Requires<[In32BitMode]>;
2731 def : InstAlias<"jmp {*}$dst",      (JMP32m  i32mem:$dst), 0>, Requires<[In32BitMode]>;
2732 def : InstAlias<"call {*}$dst",     (CALL16m i16mem:$dst), 0>, Requires<[In16BitMode]>;
2733 def : InstAlias<"jmp {*}$dst",      (JMP16m  i16mem:$dst), 0>, Requires<[In16BitMode]>;
2734
2735
2736 // "imul <imm>, B" is an alias for "imul <imm>, B, B".
2737 def : InstAlias<"imulw {$imm, $r|$r, $imm}", (IMUL16rri  GR16:$r, GR16:$r, i16imm:$imm), 0>;
2738 def : InstAlias<"imulw {$imm, $r|$r, $imm}", (IMUL16rri8 GR16:$r, GR16:$r, i16i8imm:$imm), 0>;
2739 def : InstAlias<"imull {$imm, $r|$r, $imm}", (IMUL32rri  GR32:$r, GR32:$r, i32imm:$imm), 0>;
2740 def : InstAlias<"imull {$imm, $r|$r, $imm}", (IMUL32rri8 GR32:$r, GR32:$r, i32i8imm:$imm), 0>;
2741 def : InstAlias<"imulq {$imm, $r|$r, $imm}", (IMUL64rri32 GR64:$r, GR64:$r, i64i32imm:$imm), 0>;
2742 def : InstAlias<"imulq {$imm, $r|$r, $imm}", (IMUL64rri8 GR64:$r, GR64:$r, i64i8imm:$imm), 0>;
2743
2744 // inb %dx -> inb %al, %dx
2745 def : InstAlias<"inb\t{%dx|dx}", (IN8rr), 0>;
2746 def : InstAlias<"inw\t{%dx|dx}", (IN16rr), 0>;
2747 def : InstAlias<"inl\t{%dx|dx}", (IN32rr), 0>;
2748 def : InstAlias<"inb\t$port", (IN8ri i8imm:$port), 0>;
2749 def : InstAlias<"inw\t$port", (IN16ri i8imm:$port), 0>;
2750 def : InstAlias<"inl\t$port", (IN32ri i8imm:$port), 0>;
2751
2752
2753 // jmp and call aliases for lcall and ljmp.  jmp $42,$5 -> ljmp
2754 def : InstAlias<"call $seg, $off",  (FARCALL16i i16imm:$off, i16imm:$seg)>, Requires<[In16BitMode]>;
2755 def : InstAlias<"jmp $seg, $off",   (FARJMP16i  i16imm:$off, i16imm:$seg)>, Requires<[In16BitMode]>;
2756 def : InstAlias<"call $seg, $off",  (FARCALL32i i32imm:$off, i16imm:$seg)>, Requires<[Not16BitMode]>;
2757 def : InstAlias<"jmp $seg, $off",   (FARJMP32i  i32imm:$off, i16imm:$seg)>, Requires<[Not16BitMode]>;
2758 def : InstAlias<"callw $seg, $off", (FARCALL16i i16imm:$off, i16imm:$seg)>;
2759 def : InstAlias<"jmpw $seg, $off",  (FARJMP16i  i16imm:$off, i16imm:$seg)>;
2760 def : InstAlias<"calll $seg, $off", (FARCALL32i i32imm:$off, i16imm:$seg)>;
2761 def : InstAlias<"jmpl $seg, $off",  (FARJMP32i  i32imm:$off, i16imm:$seg)>;
2762
2763 // Force mov without a suffix with a segment and mem to prefer the 'l' form of
2764 // the move.  All segment/mem forms are equivalent, this has the shortest
2765 // encoding.
2766 def : InstAlias<"mov {$mem, $seg|$seg, $mem}", (MOV32sm SEGMENT_REG:$seg, i32mem:$mem), 0>;
2767 def : InstAlias<"mov {$seg, $mem|$mem, $seg}", (MOV32ms i32mem:$mem, SEGMENT_REG:$seg), 0>;
2768
2769 // Match 'movq <largeimm>, <reg>' as an alias for movabsq.
2770 def : InstAlias<"movq {$imm, $reg|$reg, $imm}", (MOV64ri GR64:$reg, i64imm:$imm), 0>;
2771
2772 // Match 'movq GR64, MMX' as an alias for movd.
2773 def : InstAlias<"movq {$src, $dst|$dst, $src}",
2774                 (MMX_MOVD64to64rr VR64:$dst, GR64:$src), 0>;
2775 def : InstAlias<"movq {$src, $dst|$dst, $src}",
2776                 (MMX_MOVD64from64rr GR64:$dst, VR64:$src), 0>;
2777
2778 // movsx aliases
2779 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX16rr8 GR16:$dst, GR8:$src), 0>;
2780 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX16rm8 GR16:$dst, i8mem:$src), 0>;
2781 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX32rr8 GR32:$dst, GR8:$src), 0>;
2782 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX32rr16 GR32:$dst, GR16:$src), 0>;
2783 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX64rr8 GR64:$dst, GR8:$src), 0>;
2784 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX64rr16 GR64:$dst, GR16:$src), 0>;
2785 def : InstAlias<"movsx {$src, $dst|$dst, $src}", (MOVSX64rr32 GR64:$dst, GR32:$src), 0>;
2786
2787 // movzx aliases
2788 def : InstAlias<"movzx {$src, $dst|$dst, $src}", (MOVZX16rr8 GR16:$dst, GR8:$src), 0>;
2789 def : InstAlias<"movzx {$src, $dst|$dst, $src}", (MOVZX16rm8 GR16:$dst, i8mem:$src), 0>;
2790 def : InstAlias<"movzx {$src, $dst|$dst, $src}", (MOVZX32rr8 GR32:$dst, GR8:$src), 0>;
2791 def : InstAlias<"movzx {$src, $dst|$dst, $src}", (MOVZX32rr16 GR32:$dst, GR16:$src), 0>;
2792 def : InstAlias<"movzx {$src, $dst|$dst, $src}", (MOVZX64rr8_Q GR64:$dst, GR8:$src), 0>;
2793 def : InstAlias<"movzx {$src, $dst|$dst, $src}", (MOVZX64rr16_Q GR64:$dst, GR16:$src), 0>;
2794 // Note: No GR32->GR64 movzx form.
2795
2796 // outb %dx -> outb %al, %dx
2797 def : InstAlias<"outb\t{%dx|dx}", (OUT8rr), 0>;
2798 def : InstAlias<"outw\t{%dx|dx}", (OUT16rr), 0>;
2799 def : InstAlias<"outl\t{%dx|dx}", (OUT32rr), 0>;
2800 def : InstAlias<"outb\t$port", (OUT8ir i8imm:$port), 0>;
2801 def : InstAlias<"outw\t$port", (OUT16ir i8imm:$port), 0>;
2802 def : InstAlias<"outl\t$port", (OUT32ir i8imm:$port), 0>;
2803
2804 // 'sldt <mem>' can be encoded with either sldtw or sldtq with the same
2805 // effect (both store to a 16-bit mem).  Force to sldtw to avoid ambiguity
2806 // errors, since its encoding is the most compact.
2807 def : InstAlias<"sldt $mem", (SLDT16m i16mem:$mem), 0>;
2808
2809 // shld/shrd op,op -> shld op, op, CL
2810 def : InstAlias<"shld{w}\t{$r2, $r1|$r1, $r2}", (SHLD16rrCL GR16:$r1, GR16:$r2), 0>;
2811 def : InstAlias<"shld{l}\t{$r2, $r1|$r1, $r2}", (SHLD32rrCL GR32:$r1, GR32:$r2), 0>;
2812 def : InstAlias<"shld{q}\t{$r2, $r1|$r1, $r2}", (SHLD64rrCL GR64:$r1, GR64:$r2), 0>;
2813 def : InstAlias<"shrd{w}\t{$r2, $r1|$r1, $r2}", (SHRD16rrCL GR16:$r1, GR16:$r2), 0>;
2814 def : InstAlias<"shrd{l}\t{$r2, $r1|$r1, $r2}", (SHRD32rrCL GR32:$r1, GR32:$r2), 0>;
2815 def : InstAlias<"shrd{q}\t{$r2, $r1|$r1, $r2}", (SHRD64rrCL GR64:$r1, GR64:$r2), 0>;
2816
2817 def : InstAlias<"shld{w}\t{$reg, $mem|$mem, $reg}", (SHLD16mrCL i16mem:$mem, GR16:$reg), 0>;
2818 def : InstAlias<"shld{l}\t{$reg, $mem|$mem, $reg}", (SHLD32mrCL i32mem:$mem, GR32:$reg), 0>;
2819 def : InstAlias<"shld{q}\t{$reg, $mem|$mem, $reg}", (SHLD64mrCL i64mem:$mem, GR64:$reg), 0>;
2820 def : InstAlias<"shrd{w}\t{$reg, $mem|$mem, $reg}", (SHRD16mrCL i16mem:$mem, GR16:$reg), 0>;
2821 def : InstAlias<"shrd{l}\t{$reg, $mem|$mem, $reg}", (SHRD32mrCL i32mem:$mem, GR32:$reg), 0>;
2822 def : InstAlias<"shrd{q}\t{$reg, $mem|$mem, $reg}", (SHRD64mrCL i64mem:$mem, GR64:$reg), 0>;
2823
2824 /*  FIXME: This is disabled because the asm matcher is currently incapable of
2825  *  matching a fixed immediate like $1.
2826 // "shl X, $1" is an alias for "shl X".
2827 multiclass ShiftRotateByOneAlias<string Mnemonic, string Opc> {
2828  def : InstAlias<!strconcat(Mnemonic, "b $op, $$1"),
2829                  (!cast<Instruction>(!strconcat(Opc, "8r1")) GR8:$op)>;
2830  def : InstAlias<!strconcat(Mnemonic, "w $op, $$1"),
2831                  (!cast<Instruction>(!strconcat(Opc, "16r1")) GR16:$op)>;
2832  def : InstAlias<!strconcat(Mnemonic, "l $op, $$1"),
2833                  (!cast<Instruction>(!strconcat(Opc, "32r1")) GR32:$op)>;
2834  def : InstAlias<!strconcat(Mnemonic, "q $op, $$1"),
2835                  (!cast<Instruction>(!strconcat(Opc, "64r1")) GR64:$op)>;
2836  def : InstAlias<!strconcat(Mnemonic, "b $op, $$1"),
2837                  (!cast<Instruction>(!strconcat(Opc, "8m1")) i8mem:$op)>;
2838  def : InstAlias<!strconcat(Mnemonic, "w $op, $$1"),
2839                  (!cast<Instruction>(!strconcat(Opc, "16m1")) i16mem:$op)>;
2840  def : InstAlias<!strconcat(Mnemonic, "l $op, $$1"),
2841                  (!cast<Instruction>(!strconcat(Opc, "32m1")) i32mem:$op)>;
2842  def : InstAlias<!strconcat(Mnemonic, "q $op, $$1"),
2843                  (!cast<Instruction>(!strconcat(Opc, "64m1")) i64mem:$op)>;
2844 }
2845
2846 defm : ShiftRotateByOneAlias<"rcl", "RCL">;
2847 defm : ShiftRotateByOneAlias<"rcr", "RCR">;
2848 defm : ShiftRotateByOneAlias<"rol", "ROL">;
2849 defm : ShiftRotateByOneAlias<"ror", "ROR">;
2850 FIXME */
2851
2852 // test: We accept "testX <reg>, <mem>" and "testX <mem>, <reg>" as synonyms.
2853 def : InstAlias<"test{b}\t{$val, $mem|$mem, $val}",
2854                 (TEST8rm  GR8 :$val, i8mem :$mem), 0>;
2855 def : InstAlias<"test{w}\t{$val, $mem|$mem, $val}",
2856                 (TEST16rm GR16:$val, i16mem:$mem), 0>;
2857 def : InstAlias<"test{l}\t{$val, $mem|$mem, $val}",
2858                 (TEST32rm GR32:$val, i32mem:$mem), 0>;
2859 def : InstAlias<"test{q}\t{$val, $mem|$mem, $val}",
2860                 (TEST64rm GR64:$val, i64mem:$mem), 0>;
2861
2862 // xchg: We accept "xchgX <reg>, <mem>" and "xchgX <mem>, <reg>" as synonyms.
2863 def : InstAlias<"xchg{b}\t{$mem, $val|$val, $mem}",
2864                 (XCHG8rm  GR8 :$val, i8mem :$mem), 0>;
2865 def : InstAlias<"xchg{w}\t{$mem, $val|$val, $mem}",
2866                 (XCHG16rm GR16:$val, i16mem:$mem), 0>;
2867 def : InstAlias<"xchg{l}\t{$mem, $val|$val, $mem}",
2868                 (XCHG32rm GR32:$val, i32mem:$mem), 0>;
2869 def : InstAlias<"xchg{q}\t{$mem, $val|$val, $mem}",
2870                 (XCHG64rm GR64:$val, i64mem:$mem), 0>;
2871
2872 // xchg: We accept "xchgX <reg>, %eax" and "xchgX %eax, <reg>" as synonyms.
2873 def : InstAlias<"xchg{w}\t{%ax, $src|$src, ax}", (XCHG16ar GR16:$src), 0>;
2874 def : InstAlias<"xchg{l}\t{%eax, $src|$src, eax}",
2875                 (XCHG32ar GR32:$src), 0>, Requires<[Not64BitMode]>;
2876 def : InstAlias<"xchg{l}\t{%eax, $src|$src, eax}",
2877                 (XCHG32ar64 GR32_NOAX:$src), 0>, Requires<[In64BitMode]>;
2878 def : InstAlias<"xchg{q}\t{%rax, $src|$src, rax}", (XCHG64ar GR64:$src), 0>;