lib/Target/X86/X86InstrInfo.td

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