lib/Target/X86/X86InstrInfo.td

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