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