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