lib/Target/X86/X86InstrInfo.td

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