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