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