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