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