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