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