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