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