lib/Target/X86/X86InstrFormats.td

   1 //===-- X86InstrFormats.td - X86 Instruction Formats -------*- 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 //===----------------------------------------------------------------------===//
  11 // X86 Instruction Format Definitions.
  12 //
  13
  14 // Format specifies the encoding used by the instruction.  This is part of the
  15 // ad-hoc solution used to emit machine instruction encodings by our machine
  16 // code emitter.
  17 class Format<bits<7> val> {
  18   bits<7> Value = val;
  19 }
  20
  21 def Pseudo     : Format<0>; def RawFrm     : Format<1>;
  22 def AddRegFrm  : Format<2>; def MRMDestReg : Format<3>;
  23 def MRMDestMem : Format<4>; def MRMSrcReg  : Format<5>;
  24 def MRMSrcMem  : Format<6>; def RawFrmMemOffs : Format<7>;
  25 def RawFrmSrc  : Format<8>; def RawFrmDst     : Format<9>;
  26 def RawFrmDstSrc: Format<10>;
  27 def RawFrmImm8 : Format<11>;
  28 def RawFrmImm16 : Format<12>;
  29 def MRMXr  : Format<14>; def MRMXm  : Format<15>;
  30 def MRM0r  : Format<16>; def MRM1r  : Format<17>; def MRM2r  : Format<18>;
  31 def MRM3r  : Format<19>; def MRM4r  : Format<20>; def MRM5r  : Format<21>;
  32 def MRM6r  : Format<22>; def MRM7r  : Format<23>;
  33 def MRM0m  : Format<24>; def MRM1m  : Format<25>; def MRM2m  : Format<26>;
  34 def MRM3m  : Format<27>; def MRM4m  : Format<28>; def MRM5m  : Format<29>;
  35 def MRM6m  : Format<30>; def MRM7m  : Format<31>;
  36 def MRM_C0 : Format<32>; def MRM_C1 : Format<33>; def MRM_C2 : Format<34>;
  37 def MRM_C3 : Format<35>; def MRM_C4 : Format<36>; def MRM_C8 : Format<37>;
  38 def MRM_C9 : Format<38>; def MRM_CA : Format<39>; def MRM_CB : Format<40>;
  39 def MRM_CF : Format<41>; def MRM_D0 : Format<42>; def MRM_D1 : Format<43>;
  40 def MRM_D4 : Format<44>; def MRM_D5 : Format<45>; def MRM_D6 : Format<46>;
  41 def MRM_D7 : Format<47>; def MRM_D8 : Format<48>; def MRM_D9 : Format<49>;
  42 def MRM_DA : Format<50>; def MRM_DB : Format<51>; def MRM_DC : Format<52>;
  43 def MRM_DD : Format<53>; def MRM_DE : Format<54>; def MRM_DF : Format<55>;
  44 def MRM_E0 : Format<56>; def MRM_E1 : Format<57>; def MRM_E2 : Format<58>;
  45 def MRM_E3 : Format<59>; def MRM_E4 : Format<60>; def MRM_E5 : Format<61>;
  46 def MRM_E8 : Format<62>; def MRM_E9 : Format<63>; def MRM_EA : Format<64>;
  47 def MRM_EB : Format<65>; def MRM_EC : Format<66>; def MRM_ED : Format<67>;
  48 def MRM_EE : Format<68>; def MRM_F0 : Format<69>; def MRM_F1 : Format<70>;
  49 def MRM_F2 : Format<71>; def MRM_F3 : Format<72>; def MRM_F4 : Format<73>;
  50 def MRM_F5 : Format<74>; def MRM_F6 : Format<75>; def MRM_F7 : Format<76>;
  51 def MRM_F8 : Format<77>; def MRM_F9 : Format<78>; def MRM_FA : Format<79>;
  52 def MRM_FB : Format<80>; def MRM_FC : Format<81>; def MRM_FD : Format<82>;
  53 def MRM_FE : Format<83>; def MRM_FF : Format<84>;
  54
  55 // ImmType - This specifies the immediate type used by an instruction. This is
  56 // part of the ad-hoc solution used to emit machine instruction encodings by our
  57 // machine code emitter.
  58 class ImmType<bits<4> val> {
  59   bits<4> Value = val;
  60 }
  61 def NoImm      : ImmType<0>;
  62 def Imm8       : ImmType<1>;
  63 def Imm8PCRel  : ImmType<2>;
  64 def Imm16      : ImmType<3>;
  65 def Imm16PCRel : ImmType<4>;
  66 def Imm32      : ImmType<5>;
  67 def Imm32PCRel : ImmType<6>;
  68 def Imm32S     : ImmType<7>;
  69 def Imm64      : ImmType<8>;
  70
  71 // FPFormat - This specifies what form this FP instruction has.  This is used by
  72 // the Floating-Point stackifier pass.
  73 class FPFormat<bits<3> val> {
  74   bits<3> Value = val;
  75 }
  76 def NotFP      : FPFormat<0>;
  77 def ZeroArgFP  : FPFormat<1>;
  78 def OneArgFP   : FPFormat<2>;
  79 def OneArgFPRW : FPFormat<3>;
  80 def TwoArgFP   : FPFormat<4>;
  81 def CompareFP  : FPFormat<5>;
  82 def CondMovFP  : FPFormat<6>;
  83 def SpecialFP  : FPFormat<7>;
  84
  85 // Class specifying the SSE execution domain, used by the SSEDomainFix pass.
  86 // Keep in sync with tables in X86InstrInfo.cpp.
  87 class Domain<bits<2> val> {
  88   bits<2> Value = val;
  89 }
  90 def GenericDomain   : Domain<0>;
  91 def SSEPackedSingle : Domain<1>;
  92 def SSEPackedDouble : Domain<2>;
  93 def SSEPackedInt    : Domain<3>;
  94
  95 // Class specifying the vector form of the decompressed
  96 // displacement of 8-bit.
  97 class CD8VForm<bits<3> val> {
  98   bits<3> Value = val;
  99 }
 100 def CD8VF  : CD8VForm<0>;  // v := VL
 101 def CD8VH  : CD8VForm<1>;  // v := VL/2
 102 def CD8VQ  : CD8VForm<2>;  // v := VL/4
 103 def CD8VO  : CD8VForm<3>;  // v := VL/8
 104 // The tuple (subvector) forms.
 105 def CD8VT1 : CD8VForm<4>;  // v := 1
 106 def CD8VT2 : CD8VForm<5>;  // v := 2
 107 def CD8VT4 : CD8VForm<6>;  // v := 4
 108 def CD8VT8 : CD8VForm<7>;  // v := 8
 109
 110 // Class specifying the prefix used an opcode extension.
 111 class Prefix<bits<3> val> {
 112   bits<3> Value = val;
 113 }
 114 def NoPrfx : Prefix<0>;
 115 def PS     : Prefix<1>;
 116 def PD     : Prefix<2>;
 117 def XS     : Prefix<3>;
 118 def XD     : Prefix<4>;
 119
 120 // Class specifying the opcode map.
 121 class Map<bits<3> val> {
 122   bits<3> Value = val;
 123 }
 124 def OB   : Map<0>;
 125 def TB   : Map<1>;
 126 def T8   : Map<2>;
 127 def TA   : Map<3>;
 128 def XOP8 : Map<4>;
 129 def XOP9 : Map<5>;
 130 def XOPA : Map<6>;
 131
 132 // Class specifying the encoding
 133 class Encoding<bits<2> val> {
 134   bits<2> Value = val;
 135 }
 136 def EncNormal : Encoding<0>;
 137 def EncVEX    : Encoding<1>;
 138 def EncXOP    : Encoding<2>;
 139 def EncEVEX   : Encoding<3>;
 140
 141 // Operand size for encodings that change based on mode.
 142 class OperandSize<bits<2> val> {
 143   bits<2> Value = val;
 144 }
 145 def OpSizeFixed : OperandSize<0>; // Never needs a 0x66 prefix.
 146 def OpSize16    : OperandSize<1>; // Needs 0x66 prefix in 32-bit mode.
 147 def OpSize32    : OperandSize<2>; // Needs 0x66 prefix in 16-bit mode.
 148
 149 // Prefix byte classes which are used to indicate to the ad-hoc machine code
 150 // emitter that various prefix bytes are required.
 151 class OpSize16 { OperandSize OpSize = OpSize16; }
 152 class OpSize32 { OperandSize OpSize = OpSize32; }
 153 class AdSize { bit hasAdSizePrefix = 1; }
 154 class REX_W  { bit hasREX_WPrefix = 1; }
 155 class LOCK   { bit hasLockPrefix = 1; }
 156 class REP    { bit hasREPPrefix = 1; }
 157 class TB     { Map OpMap = TB; }
 158 class T8     { Map OpMap = T8; }
 159 class TA     { Map OpMap = TA; }
 160 class XOP8   { Map OpMap = XOP8; Prefix OpPrefix = PS; }
 161 class XOP9   { Map OpMap = XOP9; Prefix OpPrefix = PS; }
 162 class XOPA   { Map OpMap = XOPA; Prefix OpPrefix = PS; }
 163 class OBXS   { Prefix OpPrefix = XS; }
 164 class PS   : TB { Prefix OpPrefix = PS; }
 165 class PD   : TB { Prefix OpPrefix = PD; }
 166 class XD   : TB { Prefix OpPrefix = XD; }
 167 class XS   : TB { Prefix OpPrefix = XS; }
 168 class T8PS : T8 { Prefix OpPrefix = PS; }
 169 class T8PD : T8 { Prefix OpPrefix = PD; }
 170 class T8XD : T8 { Prefix OpPrefix = XD; }
 171 class T8XS : T8 { Prefix OpPrefix = XS; }
 172 class TAPS : TA { Prefix OpPrefix = PS; }
 173 class TAPD : TA { Prefix OpPrefix = PD; }
 174 class TAXD : TA { Prefix OpPrefix = XD; }
 175 class VEX    { Encoding OpEnc = EncVEX; }
 176 class VEX_W  { bit hasVEX_WPrefix = 1; }
 177 class VEX_4V : VEX { bit hasVEX_4V = 1; }
 178 class VEX_4VOp3 : VEX { bit hasVEX_4VOp3 = 1; }
 179 class VEX_I8IMM { bit hasVEX_i8ImmReg = 1; }
 180 class VEX_L  { bit hasVEX_L = 1; }
 181 class VEX_LIG { bit ignoresVEX_L = 1; }
 182 class EVEX : VEX { Encoding OpEnc = EncEVEX; }
 183 class EVEX_4V : VEX_4V { Encoding OpEnc = EncEVEX; }
 184 class EVEX_K { bit hasEVEX_K = 1; }
 185 class EVEX_KZ : EVEX_K { bit hasEVEX_Z = 1; }
 186 class EVEX_B { bit hasEVEX_B = 1; }
 187 class EVEX_RC { bit hasEVEX_RC = 1; }
 188 class EVEX_V512 { bit hasEVEX_L2 = 1; bit hasVEX_L = 0; }
 189 class EVEX_V256 { bit hasEVEX_L2 = 0; bit hasVEX_L = 1; }
 190 class EVEX_V128 { bit hasEVEX_L2 = 0; bit hasVEX_L = 0; }
 191
 192 // Specify AVX512 8-bit compressed displacement encoding based on the vector
 193 // element size in bits (8, 16, 32, 64) and the CDisp8 form.
 194 class EVEX_CD8<int esize, CD8VForm form> {
 195   int CD8_EltSize = !srl(esize, 3);
 196   bits<3> CD8_Form = form.Value;
 197 }
 198
 199 class Has3DNow0F0FOpcode  { bit has3DNow0F0FOpcode = 1; }
 200 class MemOp4 { bit hasMemOp4Prefix = 1; }
 201 class XOP { Encoding OpEnc = EncXOP; }
 202 class XOP_4V : XOP { bit hasVEX_4V = 1; }
 203 class XOP_4VOp3 : XOP { bit hasVEX_4VOp3 = 1; }
 204
 205 class X86Inst<bits<8> opcod, Format f, ImmType i, dag outs, dag ins,
 206               string AsmStr,
 207               InstrItinClass itin,
 208               Domain d = GenericDomain>
 209   : Instruction {
 210   let Namespace = "X86";
 211
 212   bits<8> Opcode = opcod;
 213   Format Form = f;
 214   bits<7> FormBits = Form.Value;
 215   ImmType ImmT = i;
 216
 217   dag OutOperandList = outs;
 218   dag InOperandList = ins;
 219   string AsmString = AsmStr;
 220
 221   // If this is a pseudo instruction, mark it isCodeGenOnly.
 222   let isCodeGenOnly = !eq(!cast<string>(f), "Pseudo");
 223
 224   let Itinerary = itin;
 225
 226   //
 227   // Attributes specific to X86 instructions...
 228   //
 229   bit ForceDisassemble = 0; // Force instruction to disassemble even though it's
 230                             // isCodeGenonly. Needed to hide an ambiguous
 231                             // AsmString from the parser, but still disassemble.
 232
 233   OperandSize OpSize = OpSizeFixed; // Does this instruction's encoding change
 234                                     // based on operand size of the mode
 235   bits<2> OpSizeBits = OpSize.Value;
 236   bit hasAdSizePrefix = 0;  // Does this inst have a 0x67 prefix?
 237
 238   Prefix OpPrefix = NoPrfx; // Which prefix byte does this inst have?
 239   bits<3> OpPrefixBits = OpPrefix.Value;
 240   Map OpMap = OB;           // Which opcode map does this inst have?
 241   bits<3> OpMapBits = OpMap.Value;
 242   bit hasREX_WPrefix  = 0;  // Does this inst require the REX.W prefix?
 243   FPFormat FPForm = NotFP;  // What flavor of FP instruction is this?
 244   bit hasLockPrefix = 0;    // Does this inst have a 0xF0 prefix?
 245   Domain ExeDomain = d;
 246   bit hasREPPrefix = 0;     // Does this inst have a REP prefix?
 247   Encoding OpEnc = EncNormal; // Encoding used by this instruction
 248   bits<2> OpEncBits = OpEnc.Value;
 249   bit hasVEX_WPrefix = 0;   // Does this inst set the VEX_W field?
 250   bit hasVEX_4V = 0;        // Does this inst require the VEX.VVVV field?
 251   bit hasVEX_4VOp3 = 0;     // Does this inst require the VEX.VVVV field to
 252                             // encode the third operand?
 253   bit hasVEX_i8ImmReg = 0;  // Does this inst require the last source register
 254                             // to be encoded in a immediate field?
 255   bit hasVEX_L = 0;         // Does this inst use large (256-bit) registers?
 256   bit ignoresVEX_L = 0;     // Does this instruction ignore the L-bit
 257   bit hasEVEX_K = 0;        // Does this inst require masking?
 258   bit hasEVEX_Z = 0;        // Does this inst set the EVEX_Z field?
 259   bit hasEVEX_L2 = 0;       // Does this inst set the EVEX_L2 field?
 260   bit hasEVEX_B = 0;        // Does this inst set the EVEX_B field?
 261   bits<3> CD8_Form = 0;     // Compressed disp8 form - vector-width.
 262   // Declare it int rather than bits<4> so that all bits are defined when
 263   // assigning to bits<7>.
 264   int CD8_EltSize = 0;      // Compressed disp8 form - element-size in bytes.
 265   bit has3DNow0F0FOpcode =0;// Wacky 3dNow! encoding?
 266   bit hasMemOp4Prefix = 0;  // Same bit as VEX_W, but used for swapping operands
 267   bit hasEVEX_RC = 0;       // Explicitly specified rounding control in FP instruction.
 268
 269   bits<2> EVEX_LL;
 270   let EVEX_LL{0} = hasVEX_L;
 271   let EVEX_LL{1} = hasEVEX_L2;
 272   // Vector size in bytes.
 273   bits<7> VectSize = !shl(16, EVEX_LL);
 274
 275   // The scaling factor for AVX512's compressed displacement is either
 276   //   - the size of a  power-of-two number of elements or
 277   //   - the size of a single element for broadcasts or
 278   //   - the total vector size divided by a power-of-two number.
 279   // Possible values are: 0 (non-AVX512 inst), 1, 2, 4, 8, 16, 32 and 64.
 280   bits<7> CD8_Scale = !if (!eq (OpEnc.Value, EncEVEX.Value),
 281                            !if (CD8_Form{2},
 282                                 !shl(CD8_EltSize, CD8_Form{1-0}),
 283                                 !if (hasEVEX_B,
 284                                      CD8_EltSize,
 285                                      !srl(VectSize, CD8_Form{1-0}))), 0);
 286
 287   // TSFlags layout should be kept in sync with X86InstrInfo.h.
 288   let TSFlags{6-0}   = FormBits;
 289   let TSFlags{8-7}   = OpSizeBits;
 290   let TSFlags{9}     = hasAdSizePrefix;
 291   let TSFlags{12-10} = OpPrefixBits;
 292   let TSFlags{15-13} = OpMapBits;
 293   let TSFlags{16}    = hasREX_WPrefix;
 294   let TSFlags{20-17} = ImmT.Value;
 295   let TSFlags{23-21} = FPForm.Value;
 296   let TSFlags{24}    = hasLockPrefix;
 297   let TSFlags{25}    = hasREPPrefix;
 298   let TSFlags{27-26} = ExeDomain.Value;
 299   let TSFlags{29-28} = OpEncBits;
 300   let TSFlags{37-30} = Opcode;
 301   let TSFlags{38}    = hasVEX_WPrefix;
 302   let TSFlags{39}    = hasVEX_4V;
 303   let TSFlags{40}    = hasVEX_4VOp3;
 304   let TSFlags{41}    = hasVEX_i8ImmReg;
 305   let TSFlags{42}    = hasVEX_L;
 306   let TSFlags{43}    = ignoresVEX_L;
 307   let TSFlags{44}    = hasEVEX_K;
 308   let TSFlags{45}    = hasEVEX_Z;
 309   let TSFlags{46}    = hasEVEX_L2;
 310   let TSFlags{47}    = hasEVEX_B;
 311   // If we run out of TSFlags bits, it's possible to encode this in 3 bits.
 312   let TSFlags{54-48} = CD8_Scale;
 313   let TSFlags{55}    = has3DNow0F0FOpcode;
 314   let TSFlags{56}    = hasMemOp4Prefix;
 315   let TSFlags{57}    = hasEVEX_RC;
 316 }
 317
 318 class PseudoI<dag oops, dag iops, list<dag> pattern>
 319   : X86Inst<0, Pseudo, NoImm, oops, iops, "", NoItinerary> {
 320   let Pattern = pattern;
 321 }
 322
 323 class I<bits<8> o, Format f, dag outs, dag ins, string asm,
 324         list<dag> pattern, InstrItinClass itin = NoItinerary,
 325         Domain d = GenericDomain>
 326   : X86Inst<o, f, NoImm, outs, ins, asm, itin, d> {
 327   let Pattern = pattern;
 328   let CodeSize = 3;
 329 }
 330 class Ii8 <bits<8> o, Format f, dag outs, dag ins, string asm,
 331            list<dag> pattern, InstrItinClass itin = NoItinerary,
 332            Domain d = GenericDomain>
 333   : X86Inst<o, f, Imm8, outs, ins, asm, itin, d> {
 334   let Pattern = pattern;
 335   let CodeSize = 3;
 336 }
 337 class Ii8PCRel<bits<8> o, Format f, dag outs, dag ins, string asm,
 338                list<dag> pattern, InstrItinClass itin = NoItinerary>
 339   : X86Inst<o, f, Imm8PCRel, outs, ins, asm, itin> {
 340   let Pattern = pattern;
 341   let CodeSize = 3;
 342 }
 343 class Ii16<bits<8> o, Format f, dag outs, dag ins, string asm,
 344            list<dag> pattern, InstrItinClass itin = NoItinerary>
 345   : X86Inst<o, f, Imm16, outs, ins, asm, itin> {
 346   let Pattern = pattern;
 347   let CodeSize = 3;
 348 }
 349 class Ii32<bits<8> o, Format f, dag outs, dag ins, string asm,
 350            list<dag> pattern, InstrItinClass itin = NoItinerary>
 351   : X86Inst<o, f, Imm32, outs, ins, asm, itin> {
 352   let Pattern = pattern;
 353   let CodeSize = 3;
 354 }
 355 class Ii32S<bits<8> o, Format f, dag outs, dag ins, string asm,
 356             list<dag> pattern, InstrItinClass itin = NoItinerary>
 357   : X86Inst<o, f, Imm32S, outs, ins, asm, itin> {
 358   let Pattern = pattern;
 359   let CodeSize = 3;
 360 }
 361
 362 class Ii16PCRel<bits<8> o, Format f, dag outs, dag ins, string asm,
 363            list<dag> pattern, InstrItinClass itin = NoItinerary>
 364            : X86Inst<o, f, Imm16PCRel, outs, ins, asm, itin> {
 365   let Pattern = pattern;
 366   let CodeSize = 3;
 367 }
 368
 369 class Ii32PCRel<bits<8> o, Format f, dag outs, dag ins, string asm,
 370            list<dag> pattern, InstrItinClass itin = NoItinerary>
 371   : X86Inst<o, f, Imm32PCRel, outs, ins, asm, itin> {
 372   let Pattern = pattern;
 373   let CodeSize = 3;
 374 }
 375
 376 // FPStack Instruction Templates:
 377 // FPI - Floating Point Instruction template.
 378 class FPI<bits<8> o, Format F, dag outs, dag ins, string asm,
 379           InstrItinClass itin = NoItinerary>
 380   : I<o, F, outs, ins, asm, [], itin> {}
 381
 382 // FpI_ - Floating Point Pseudo Instruction template. Not Predicated.
 383 class FpI_<dag outs, dag ins, FPFormat fp, list<dag> pattern,
 384            InstrItinClass itin = NoItinerary>
 385   : X86Inst<0, Pseudo, NoImm, outs, ins, "", itin> {
 386   let FPForm = fp;
 387   let Pattern = pattern;
 388 }
 389
 390 // Templates for instructions that use a 16- or 32-bit segmented address as
 391 //  their only operand: lcall (FAR CALL) and ljmp (FAR JMP)
 392 //
 393 //   Iseg16 - 16-bit segment selector, 16-bit offset
 394 //   Iseg32 - 16-bit segment selector, 32-bit offset
 395
 396 class Iseg16 <bits<8> o, Format f, dag outs, dag ins, string asm,
 397               list<dag> pattern, InstrItinClass itin = NoItinerary>
 398       : X86Inst<o, f, Imm16, outs, ins, asm, itin> {
 399   let Pattern = pattern;
 400   let CodeSize = 3;
 401 }
 402
 403 class Iseg32 <bits<8> o, Format f, dag outs, dag ins, string asm,
 404               list<dag> pattern, InstrItinClass itin = NoItinerary>
 405       : X86Inst<o, f, Imm32, outs, ins, asm, itin> {
 406   let Pattern = pattern;
 407   let CodeSize = 3;
 408 }
 409
 410 // SI - SSE 1 & 2 scalar instructions
 411 class SI<bits<8> o, Format F, dag outs, dag ins, string asm,
 412          list<dag> pattern, InstrItinClass itin = NoItinerary>
 413       : I<o, F, outs, ins, asm, pattern, itin> {
 414   let Predicates = !if(!eq(OpEnc.Value, EncEVEX.Value), [HasAVX512],
 415                    !if(!eq(OpEnc.Value, EncVEX.Value), [UseAVX],
 416                    !if(!eq(OpPrefix.Value, XS.Value), [UseSSE1],
 417                    !if(!eq(OpPrefix.Value, XD.Value), [UseSSE2],
 418                    !if(!eq(OpPrefix.Value, PD.Value), [UseSSE2],
 419                    [UseSSE1])))));
 420
 421   // AVX instructions have a 'v' prefix in the mnemonic
 422   let AsmString = !if(!eq(OpEnc.Value, EncEVEX.Value), !strconcat("v", asm),
 423                   !if(!eq(OpEnc.Value, EncVEX.Value), !strconcat("v", asm),
 424                   asm));
 425 }
 426
 427 // SIi8 - SSE 1 & 2 scalar instructions
 428 class SIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 429            list<dag> pattern, InstrItinClass itin = NoItinerary>
 430       : Ii8<o, F, outs, ins, asm, pattern, itin> {
 431   let Predicates = !if(!eq(OpEnc.Value, EncEVEX.Value), [HasAVX512],
 432                    !if(!eq(OpEnc.Value, EncVEX.Value), [UseAVX],
 433                    !if(!eq(OpPrefix.Value, XS.Value), [UseSSE1],
 434                    [UseSSE2])));
 435
 436   // AVX instructions have a 'v' prefix in the mnemonic
 437   let AsmString = !if(!eq(OpEnc.Value, EncEVEX.Value), !strconcat("v", asm),
 438                   !if(!eq(OpEnc.Value, EncVEX.Value), !strconcat("v", asm),
 439                   asm));
 440 }
 441
 442 // PI - SSE 1 & 2 packed instructions
 443 class PI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern,
 444          InstrItinClass itin, Domain d>
 445       : I<o, F, outs, ins, asm, pattern, itin, d> {
 446   let Predicates = !if(!eq(OpEnc.Value, EncEVEX.Value), [HasAVX512],
 447                    !if(!eq(OpEnc.Value, EncVEX.Value), [HasAVX],
 448                    !if(!eq(OpPrefix.Value, PD.Value), [UseSSE2],
 449                    [UseSSE1])));
 450
 451   // AVX instructions have a 'v' prefix in the mnemonic
 452   let AsmString = !if(!eq(OpEnc.Value, EncEVEX.Value), !strconcat("v", asm),
 453                   !if(!eq(OpEnc.Value, EncVEX.Value), !strconcat("v", asm),
 454                   asm));
 455 }
 456
 457 // MMXPI - SSE 1 & 2 packed instructions with MMX operands
 458 class MMXPI<bits<8> o, Format F, dag outs, dag ins, string asm, list<dag> pattern,
 459             InstrItinClass itin, Domain d>
 460       : I<o, F, outs, ins, asm, pattern, itin, d> {
 461   let Predicates = !if(!eq(OpPrefix.Value, PD.Value), [HasSSE2],
 462                        [HasSSE1]);
 463 }
 464
 465 // PIi8 - SSE 1 & 2 packed instructions with immediate
 466 class PIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 467            list<dag> pattern, InstrItinClass itin, Domain d>
 468       : Ii8<o, F, outs, ins, asm, pattern, itin, d> {
 469   let Predicates = !if(!eq(OpEnc.Value, EncEVEX.Value), [HasAVX512],
 470                    !if(!eq(OpEnc.Value, EncVEX.Value), [HasAVX],
 471                    !if(!eq(OpPrefix.Value, PD.Value), [UseSSE2],
 472                    [UseSSE1])));
 473
 474   // AVX instructions have a 'v' prefix in the mnemonic
 475   let AsmString = !if(!eq(OpEnc.Value, EncEVEX.Value), !strconcat("v", asm),
 476                   !if(!eq(OpEnc.Value, EncVEX.Value), !strconcat("v", asm),
 477                   asm));
 478 }
 479
 480 // SSE1 Instruction Templates:
 481 //
 482 //   SSI   - SSE1 instructions with XS prefix.
 483 //   PSI   - SSE1 instructions with PS prefix.
 484 //   PSIi8 - SSE1 instructions with ImmT == Imm8 and PS prefix.
 485 //   VSSI  - SSE1 instructions with XS prefix in AVX form.
 486 //   VPSI  - SSE1 instructions with PS prefix in AVX form, packed single.
 487
 488 class SSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 489           list<dag> pattern, InstrItinClass itin = NoItinerary>
 490       : I<o, F, outs, ins, asm, pattern, itin>, XS, Requires<[UseSSE1]>;
 491 class SSIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 492             list<dag> pattern, InstrItinClass itin = NoItinerary>
 493       : Ii8<o, F, outs, ins, asm, pattern, itin>, XS, Requires<[UseSSE1]>;
 494 class PSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 495           list<dag> pattern, InstrItinClass itin = NoItinerary>
 496       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedSingle>, PS,
 497         Requires<[UseSSE1]>;
 498 class PSIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 499             list<dag> pattern, InstrItinClass itin = NoItinerary>
 500       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedSingle>, PS,
 501         Requires<[UseSSE1]>;
 502 class VSSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 503            list<dag> pattern, InstrItinClass itin = NoItinerary>
 504       : I<o, F, outs, ins, !strconcat("v", asm), pattern, itin>, XS,
 505         Requires<[HasAVX]>;
 506 class VPSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 507            list<dag> pattern, InstrItinClass itin = NoItinerary>
 508       : I<o, F, outs, ins, !strconcat("v", asm), pattern, itin, SSEPackedSingle>, PS,
 509         Requires<[HasAVX]>;
 510
 511 // SSE2 Instruction Templates:
 512 //
 513 //   SDI    - SSE2 instructions with XD prefix.
 514 //   SDIi8  - SSE2 instructions with ImmT == Imm8 and XD prefix.
 515 //   S2SI   - SSE2 instructions with XS prefix.
 516 //   SSDIi8 - SSE2 instructions with ImmT == Imm8 and XS prefix.
 517 //   PDI    - SSE2 instructions with PD prefix, packed double domain.
 518 //   PDIi8  - SSE2 instructions with ImmT == Imm8 and PD prefix.
 519 //   VSDI   - SSE2 scalar instructions with XD prefix in AVX form.
 520 //   VPDI   - SSE2 vector instructions with PD prefix in AVX form,
 521 //                 packed double domain.
 522 //   VS2I   - SSE2 scalar instructions with PD prefix in AVX form.
 523 //   S2I    - SSE2 scalar instructions with PD prefix.
 524 //   MMXSDIi8  - SSE2 instructions with ImmT == Imm8 and XD prefix as well as
 525 //               MMX operands.
 526 //   MMXSSDIi8 - SSE2 instructions with ImmT == Imm8 and XS prefix as well as
 527 //               MMX operands.
 528
 529 class SDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 530           list<dag> pattern, InstrItinClass itin = NoItinerary>
 531       : I<o, F, outs, ins, asm, pattern, itin>, XD, Requires<[UseSSE2]>;
 532 class SDIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 533             list<dag> pattern, InstrItinClass itin = NoItinerary>
 534       : Ii8<o, F, outs, ins, asm, pattern, itin>, XD, Requires<[UseSSE2]>;
 535 class S2SI<bits<8> o, Format F, dag outs, dag ins, string asm,
 536            list<dag> pattern, InstrItinClass itin = NoItinerary>
 537       : I<o, F, outs, ins, asm, pattern, itin>, XS, Requires<[UseSSE2]>;
 538 class S2SIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 539              list<dag> pattern, InstrItinClass itin = NoItinerary>
 540       : Ii8<o, F, outs, ins, asm, pattern>, XS, Requires<[UseSSE2]>;
 541 class PDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 542           list<dag> pattern, InstrItinClass itin = NoItinerary>
 543       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>, PD,
 544         Requires<[UseSSE2]>;
 545 class PDIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 546             list<dag> pattern, InstrItinClass itin = NoItinerary>
 547       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>, PD,
 548         Requires<[UseSSE2]>;
 549 class VSDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 550            list<dag> pattern, InstrItinClass itin = NoItinerary>
 551       : I<o, F, outs, ins, !strconcat("v", asm), pattern, itin>, XD,
 552         Requires<[UseAVX]>;
 553 class VS2SI<bits<8> o, Format F, dag outs, dag ins, string asm,
 554             list<dag> pattern, InstrItinClass itin = NoItinerary>
 555       : I<o, F, outs, ins, !strconcat("v", asm), pattern, itin>, XS,
 556         Requires<[HasAVX]>;
 557 class VPDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 558            list<dag> pattern, InstrItinClass itin = NoItinerary>
 559       : I<o, F, outs, ins, !strconcat("v", asm), pattern, itin, SSEPackedDouble>,
 560         PD, Requires<[HasAVX]>;
 561 class VS2I<bits<8> o, Format F, dag outs, dag ins, string asm,
 562            list<dag> pattern, InstrItinClass itin = NoItinerary>
 563       : I<o, F, outs, ins, !strconcat("v", asm), pattern, itin>, PD,
 564         Requires<[UseAVX]>;
 565 class S2I<bits<8> o, Format F, dag outs, dag ins, string asm,
 566            list<dag> pattern, InstrItinClass itin = NoItinerary>
 567       : I<o, F, outs, ins, asm, pattern, itin>, PD, Requires<[UseSSE2]>;
 568 class MMXSDIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 569                list<dag> pattern, InstrItinClass itin = NoItinerary>
 570       : Ii8<o, F, outs, ins, asm, pattern, itin>, XD, Requires<[HasSSE2]>;
 571 class MMXS2SIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 572                 list<dag> pattern, InstrItinClass itin = NoItinerary>
 573       : Ii8<o, F, outs, ins, asm, pattern>, XS, Requires<[HasSSE2]>;
 574
 575 // SSE3 Instruction Templates:
 576 //
 577 //   S3I   - SSE3 instructions with PD prefixes.
 578 //   S3SI  - SSE3 instructions with XS prefix.
 579 //   S3DI  - SSE3 instructions with XD prefix.
 580
 581 class S3SI<bits<8> o, Format F, dag outs, dag ins, string asm,
 582            list<dag> pattern, InstrItinClass itin = NoItinerary>
 583       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedSingle>, XS,
 584         Requires<[UseSSE3]>;
 585 class S3DI<bits<8> o, Format F, dag outs, dag ins, string asm,
 586            list<dag> pattern, InstrItinClass itin = NoItinerary>
 587       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>, XD,
 588         Requires<[UseSSE3]>;
 589 class S3I<bits<8> o, Format F, dag outs, dag ins, string asm,
 590           list<dag> pattern, InstrItinClass itin = NoItinerary>
 591       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>, PD,
 592         Requires<[UseSSE3]>;
 593
 594
 595 // SSSE3 Instruction Templates:
 596 //
 597 //   SS38I - SSSE3 instructions with T8 prefix.
 598 //   SS3AI - SSSE3 instructions with TA prefix.
 599 //   MMXSS38I - SSSE3 instructions with T8 prefix and MMX operands.
 600 //   MMXSS3AI - SSSE3 instructions with TA prefix and MMX operands.
 601 //
 602 // Note: SSSE3 instructions have 64-bit and 128-bit versions. The 64-bit version
 603 // uses the MMX registers. The 64-bit versions are grouped with the MMX
 604 // classes. They need to be enabled even if AVX is enabled.
 605
 606 class SS38I<bits<8> o, Format F, dag outs, dag ins, string asm,
 607             list<dag> pattern, InstrItinClass itin = NoItinerary>
 608       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 609         Requires<[UseSSSE3]>;
 610 class SS3AI<bits<8> o, Format F, dag outs, dag ins, string asm,
 611             list<dag> pattern, InstrItinClass itin = NoItinerary>
 612       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 613         Requires<[UseSSSE3]>;
 614 class MMXSS38I<bits<8> o, Format F, dag outs, dag ins, string asm,
 615                list<dag> pattern, InstrItinClass itin = NoItinerary>
 616       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PS,
 617         Requires<[HasSSSE3]>;
 618 class MMXSS3AI<bits<8> o, Format F, dag outs, dag ins, string asm,
 619                list<dag> pattern, InstrItinClass itin = NoItinerary>
 620       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPS,
 621         Requires<[HasSSSE3]>;
 622
 623 // SSE4.1 Instruction Templates:
 624 //
 625 //   SS48I - SSE 4.1 instructions with T8 prefix.
 626 //   SS41AIi8 - SSE 4.1 instructions with TA prefix and ImmT == Imm8.
 627 //
 628 class SS48I<bits<8> o, Format F, dag outs, dag ins, string asm,
 629             list<dag> pattern, InstrItinClass itin = NoItinerary>
 630       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 631         Requires<[UseSSE41]>;
 632 class SS4AIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 633             list<dag> pattern, InstrItinClass itin = NoItinerary>
 634       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 635         Requires<[UseSSE41]>;
 636
 637 // SSE4.2 Instruction Templates:
 638 //
 639 //   SS428I - SSE 4.2 instructions with T8 prefix.
 640 class SS428I<bits<8> o, Format F, dag outs, dag ins, string asm,
 641              list<dag> pattern, InstrItinClass itin = NoItinerary>
 642       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 643         Requires<[UseSSE42]>;
 644
 645 //   SS42FI - SSE 4.2 instructions with T8XD prefix.
 646 // NOTE: 'HasSSE42' is used as SS42FI is only used for CRC32 insns.
 647 class SS42FI<bits<8> o, Format F, dag outs, dag ins, string asm,
 648              list<dag> pattern, InstrItinClass itin = NoItinerary>
 649       : I<o, F, outs, ins, asm, pattern, itin>, T8XD, Requires<[HasSSE42]>;
 650
 651 //   SS42AI = SSE 4.2 instructions with TA prefix
 652 class SS42AI<bits<8> o, Format F, dag outs, dag ins, string asm,
 653              list<dag> pattern, InstrItinClass itin = NoItinerary>
 654       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 655         Requires<[UseSSE42]>;
 656
 657 // AVX Instruction Templates:
 658 //   Instructions introduced in AVX (no SSE equivalent forms)
 659 //
 660 //   AVX8I - AVX instructions with T8PD prefix.
 661 //   AVXAIi8 - AVX instructions with TAPD prefix and ImmT = Imm8.
 662 class AVX8I<bits<8> o, Format F, dag outs, dag ins, string asm,
 663             list<dag> pattern, InstrItinClass itin = NoItinerary>
 664       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 665         Requires<[HasAVX]>;
 666 class AVXAIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 667               list<dag> pattern, InstrItinClass itin = NoItinerary>
 668       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 669         Requires<[HasAVX]>;
 670
 671 // AVX2 Instruction Templates:
 672 //   Instructions introduced in AVX2 (no SSE equivalent forms)
 673 //
 674 //   AVX28I - AVX2 instructions with T8PD prefix.
 675 //   AVX2AIi8 - AVX2 instructions with TAPD prefix and ImmT = Imm8.
 676 class AVX28I<bits<8> o, Format F, dag outs, dag ins, string asm,
 677             list<dag> pattern, InstrItinClass itin = NoItinerary>
 678       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 679         Requires<[HasAVX2]>;
 680 class AVX2AIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 681               list<dag> pattern, InstrItinClass itin = NoItinerary>
 682       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 683         Requires<[HasAVX2]>;
 684
 685
 686 // AVX-512 Instruction Templates:
 687 //   Instructions introduced in AVX-512 (no SSE equivalent forms)
 688 //
 689 //   AVX5128I - AVX-512 instructions with T8PD prefix.
 690 //   AVX512AIi8 - AVX-512 instructions with TAPD prefix and ImmT = Imm8.
 691 //   AVX512PDI  - AVX-512 instructions with PD, double packed.
 692 //   AVX512PSI  - AVX-512 instructions with PS, single packed.
 693 //   AVX512XS8I - AVX-512 instructions with T8 and XS prefixes.
 694 //   AVX512XSI  - AVX-512 instructions with XS prefix, generic domain.
 695 //   AVX512BI   - AVX-512 instructions with PD, int packed domain.
 696 //   AVX512SI   - AVX-512 scalar instructions with PD prefix.
 697
 698 class AVX5128I<bits<8> o, Format F, dag outs, dag ins, string asm,
 699             list<dag> pattern, InstrItinClass itin = NoItinerary>
 700       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 701         Requires<[HasAVX512]>;
 702 class AVX512XS8I<bits<8> o, Format F, dag outs, dag ins, string asm,
 703             list<dag> pattern, InstrItinClass itin = NoItinerary>
 704       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8XS,
 705         Requires<[HasAVX512]>;
 706 class AVX512XSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 707             list<dag> pattern, InstrItinClass itin = NoItinerary>
 708       : I<o, F, outs, ins, asm, pattern, itin>, XS,
 709         Requires<[HasAVX512]>;
 710 class AVX512XDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 711             list<dag> pattern, InstrItinClass itin = NoItinerary>
 712       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, XD,
 713         Requires<[HasAVX512]>;
 714 class AVX512BI<bits<8> o, Format F, dag outs, dag ins, string asm,
 715             list<dag> pattern, InstrItinClass itin = NoItinerary>
 716       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, PD,
 717         Requires<[HasAVX512]>;
 718 class AVX512BIBase : PD {
 719   Domain ExeDomain = SSEPackedInt;
 720 }
 721 class AVX512BIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 722               list<dag> pattern, InstrItinClass itin = NoItinerary>
 723       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, PD,
 724         Requires<[HasAVX512]>;
 725 class AVX512AIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 726               list<dag> pattern, InstrItinClass itin = NoItinerary>
 727       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 728         Requires<[HasAVX512]>;
 729 class AVX512AIi8Base : TAPD {
 730   Domain ExeDomain = SSEPackedInt;
 731   ImmType ImmT = Imm8;
 732 }
 733 class AVX512Ii8<bits<8> o, Format F, dag outs, dag ins, string asm,
 734               list<dag> pattern, InstrItinClass itin = NoItinerary>
 735       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>,
 736         Requires<[HasAVX512]>;
 737 class AVX512PDI<bits<8> o, Format F, dag outs, dag ins, string asm,
 738            list<dag> pattern, InstrItinClass itin = NoItinerary>
 739       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>, PD,
 740         Requires<[HasAVX512]>;
 741 class AVX512PSI<bits<8> o, Format F, dag outs, dag ins, string asm,
 742            list<dag> pattern, InstrItinClass itin = NoItinerary>
 743       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedSingle>, PS,
 744         Requires<[HasAVX512]>;
 745 class AVX512PIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 746               list<dag> pattern, Domain d, InstrItinClass itin = NoItinerary>
 747       : Ii8<o, F, outs, ins, asm, pattern, itin, d>, Requires<[HasAVX512]>;
 748 class AVX512PI<bits<8> o, Format F, dag outs, dag ins, string asm,
 749               list<dag> pattern, Domain d, InstrItinClass itin = NoItinerary>
 750       : I<o, F, outs, ins, asm, pattern, itin, d>, Requires<[HasAVX512]>;
 751 class AVX512FMA3<bits<8> o, Format F, dag outs, dag ins, string asm,
 752            list<dag>pattern, InstrItinClass itin = NoItinerary>
 753       : I<o, F, outs, ins, asm, pattern, itin>, T8PD,
 754         EVEX_4V, Requires<[HasAVX512]>;
 755 class AVX512FMA3Base : T8PD, EVEX_4V;
 756
 757 class AVX512<bits<8> o, Format F, dag outs, dag ins, string asm,
 758            list<dag>pattern, InstrItinClass itin = NoItinerary>
 759       : I<o, F, outs, ins, asm, pattern, itin>, Requires<[HasAVX512]>;
 760
 761 // AES Instruction Templates:
 762 //
 763 // AES8I
 764 // These use the same encoding as the SSE4.2 T8 and TA encodings.
 765 class AES8I<bits<8> o, Format F, dag outs, dag ins, string asm,
 766             list<dag>pattern, InstrItinClass itin = IIC_AES>
 767       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, T8PD,
 768         Requires<[HasAES]>;
 769
 770 class AESAI<bits<8> o, Format F, dag outs, dag ins, string asm,
 771             list<dag> pattern, InstrItinClass itin = NoItinerary>
 772       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 773         Requires<[HasAES]>;
 774
 775 // PCLMUL Instruction Templates
 776 class PCLMULIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 777                list<dag>pattern, InstrItinClass itin = NoItinerary>
 778       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 779         Requires<[HasPCLMUL]>;
 780
 781 class AVXPCLMULIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 782                   list<dag>pattern, InstrItinClass itin = NoItinerary>
 783       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 784         VEX_4V, Requires<[HasAVX, HasPCLMUL]>;
 785
 786 // FMA3 Instruction Templates
 787 class FMA3<bits<8> o, Format F, dag outs, dag ins, string asm,
 788            list<dag>pattern, InstrItinClass itin = NoItinerary>
 789       : I<o, F, outs, ins, asm, pattern, itin>, T8PD,
 790         VEX_4V, FMASC, Requires<[HasFMA]>;
 791
 792 // FMA4 Instruction Templates
 793 class FMA4<bits<8> o, Format F, dag outs, dag ins, string asm,
 794            list<dag>pattern, InstrItinClass itin = NoItinerary>
 795       : Ii8<o, F, outs, ins, asm, pattern, itin>, TAPD,
 796         VEX_4V, VEX_I8IMM, FMASC, Requires<[HasFMA4]>;
 797
 798 // XOP 2, 3 and 4 Operand Instruction Template
 799 class IXOP<bits<8> o, Format F, dag outs, dag ins, string asm,
 800            list<dag> pattern, InstrItinClass itin = NoItinerary>
 801       : I<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>,
 802          XOP9, Requires<[HasXOP]>;
 803
 804 // XOP 2, 3 and 4 Operand Instruction Templates with imm byte
 805 class IXOPi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 806            list<dag> pattern, InstrItinClass itin = NoItinerary>
 807       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedDouble>,
 808          XOP8, Requires<[HasXOP]>;
 809
 810 //  XOP 5 operand instruction (VEX encoding!)
 811 class IXOP5<bits<8> o, Format F, dag outs, dag ins, string asm,
 812            list<dag>pattern, InstrItinClass itin = NoItinerary>
 813       : Ii8<o, F, outs, ins, asm, pattern, itin, SSEPackedInt>, TAPD,
 814         VEX_4V, VEX_I8IMM, Requires<[HasXOP]>;
 815
 816 // X86-64 Instruction templates...
 817 //
 818
 819 class RI<bits<8> o, Format F, dag outs, dag ins, string asm,
 820          list<dag> pattern, InstrItinClass itin = NoItinerary>
 821       : I<o, F, outs, ins, asm, pattern, itin>, REX_W;
 822 class RIi8 <bits<8> o, Format F, dag outs, dag ins, string asm,
 823             list<dag> pattern, InstrItinClass itin = NoItinerary>
 824       : Ii8<o, F, outs, ins, asm, pattern, itin>, REX_W;
 825 class RIi16 <bits<8> o, Format F, dag outs, dag ins, string asm,
 826             list<dag> pattern, InstrItinClass itin = NoItinerary>
 827       : Ii16<o, F, outs, ins, asm, pattern, itin>, REX_W;
 828 class RIi32 <bits<8> o, Format F, dag outs, dag ins, string asm,
 829              list<dag> pattern, InstrItinClass itin = NoItinerary>
 830       : Ii32<o, F, outs, ins, asm, pattern, itin>, REX_W;
 831 class RIi32S <bits<8> o, Format F, dag outs, dag ins, string asm,
 832               list<dag> pattern, InstrItinClass itin = NoItinerary>
 833       : Ii32S<o, F, outs, ins, asm, pattern, itin>, REX_W;
 834
 835 class RIi64<bits<8> o, Format f, dag outs, dag ins, string asm,
 836             list<dag> pattern, InstrItinClass itin = NoItinerary>
 837   : X86Inst<o, f, Imm64, outs, ins, asm, itin>, REX_W {
 838   let Pattern = pattern;
 839   let CodeSize = 3;
 840 }
 841
 842 class RIi64_NOREX<bits<8> o, Format f, dag outs, dag ins, string asm,
 843             list<dag> pattern, InstrItinClass itin = NoItinerary>
 844   : X86Inst<o, f, Imm64, outs, ins, asm, itin> {
 845   let Pattern = pattern;
 846   let CodeSize = 3;
 847 }
 848
 849 class RS2I<bits<8> o, Format F, dag outs, dag ins, string asm,
 850            list<dag> pattern, InstrItinClass itin = NoItinerary>
 851       : S2I<o, F, outs, ins, asm, pattern, itin>, REX_W;
 852 class VRS2I<bits<8> o, Format F, dag outs, dag ins, string asm,
 853            list<dag> pattern, InstrItinClass itin = NoItinerary>
 854       : VS2I<o, F, outs, ins, asm, pattern, itin>, VEX_W;
 855
 856 // MMX Instruction templates
 857 //
 858
 859 // MMXI   - MMX instructions with TB prefix.
 860 // MMXI32 - MMX instructions with TB prefix valid only in 32 bit mode.
 861 // MMXI64 - MMX instructions with TB prefix valid only in 64 bit mode.
 862 // MMX2I  - MMX / SSE2 instructions with PD prefix.
 863 // MMXIi8 - MMX instructions with ImmT == Imm8 and PS prefix.
 864 // MMXIi8 - MMX instructions with ImmT == Imm8 and PS prefix.
 865 // MMXID  - MMX instructions with XD prefix.
 866 // MMXIS  - MMX instructions with XS prefix.
 867 class MMXI<bits<8> o, Format F, dag outs, dag ins, string asm,
 868            list<dag> pattern, InstrItinClass itin = NoItinerary>
 869       : I<o, F, outs, ins, asm, pattern, itin>, PS, Requires<[HasMMX]>;
 870 class MMXI32<bits<8> o, Format F, dag outs, dag ins, string asm,
 871              list<dag> pattern, InstrItinClass itin = NoItinerary>
 872       : I<o, F, outs, ins, asm, pattern, itin>, PS, Requires<[HasMMX,Not64BitMode]>;
 873 class MMXI64<bits<8> o, Format F, dag outs, dag ins, string asm,
 874              list<dag> pattern, InstrItinClass itin = NoItinerary>
 875       : I<o, F, outs, ins, asm, pattern, itin>, PS, Requires<[HasMMX,In64BitMode]>;
 876 class MMXRI<bits<8> o, Format F, dag outs, dag ins, string asm,
 877             list<dag> pattern, InstrItinClass itin = NoItinerary>
 878       : I<o, F, outs, ins, asm, pattern, itin>, PS, REX_W, Requires<[HasMMX]>;
 879 class MMX2I<bits<8> o, Format F, dag outs, dag ins, string asm,
 880             list<dag> pattern, InstrItinClass itin = NoItinerary>
 881       : I<o, F, outs, ins, asm, pattern, itin>, PD, Requires<[HasMMX]>;
 882 class MMXIi8<bits<8> o, Format F, dag outs, dag ins, string asm,
 883              list<dag> pattern, InstrItinClass itin = NoItinerary>
 884       : Ii8<o, F, outs, ins, asm, pattern, itin>, PS, Requires<[HasMMX]>;
 885 class MMXID<bits<8> o, Format F, dag outs, dag ins, string asm,
 886             list<dag> pattern, InstrItinClass itin = NoItinerary>
 887       : Ii8<o, F, outs, ins, asm, pattern, itin>, XD, Requires<[HasMMX]>;
 888 class MMXIS<bits<8> o, Format F, dag outs, dag ins, string asm,
 889             list<dag> pattern, InstrItinClass itin = NoItinerary>
 890       : Ii8<o, F, outs, ins, asm, pattern, itin>, XS, Requires<[HasMMX]>;