lib/Target/X86/X86InstrInfo.td

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