contrib/llvm/lib/Target/AMDGPU/VOPInstructions.td

   1 //===-- VOPInstructions.td - Vector Instruction Defintions ----------------===//
   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 // dummies for outer let
  11 class LetDummies {
  12   bit isCommutable;
  13   bit isConvertibleToThreeAddress;
  14   bit isMoveImm;
  15   bit isReMaterializable;
  16   bit isAsCheapAsAMove;
  17   bit VOPAsmPrefer32Bit;
  18   Predicate SubtargetPredicate;
  19   string Constraints;
  20   string DisableEncoding;
  21   list<SchedReadWrite> SchedRW;
  22   list<Register> Uses;
  23   list<Register> Defs;
  24 }
  25
  26 class VOP <string opName> {
  27   string OpName = opName;
  28 }
  29
  30 class VOPAnyCommon <dag outs, dag ins, string asm, list<dag> pattern> :
  31     InstSI <outs, ins, asm, pattern> {
  32
  33   let mayLoad = 0;
  34   let mayStore = 0;
  35   let hasSideEffects = 0;
  36   let UseNamedOperandTable = 1;
  37   let VALU = 1;
  38   let Uses = [EXEC];
  39 }
  40
  41 class VOP3Common <dag outs, dag ins, string asm = "",
  42                   list<dag> pattern = [], bit HasMods = 0,
  43                   bit VOP3Only = 0> :
  44   VOPAnyCommon <outs, ins, asm, pattern> {
  45
  46   // Using complex patterns gives VOP3 patterns a very high complexity rating,
  47   // but standalone patterns are almost always preferred, so we need to adjust the
  48   // priority lower.  The goal is to use a high number to reduce complexity to
  49   // zero (or less than zero).
  50   let AddedComplexity = -1000;
  51
  52   let VOP3 = 1;
  53
  54   let AsmMatchConverter =
  55     !if(!eq(VOP3Only,1),
  56         "cvtVOP3",
  57         !if(!eq(HasMods,1), "cvtVOP3_2_mod", ""));
  58
  59   let AsmVariantName = AMDGPUAsmVariants.VOP3;
  60
  61   let isCodeGenOnly = 0;
  62
  63   int Size = 8;
  64
  65   // Because SGPRs may be allowed if there are multiple operands, we
  66   // need a post-isel hook to insert copies in order to avoid
  67   // violating constant bus requirements.
  68   let hasPostISelHook = 1;
  69 }
  70
  71 class VOP3_Pseudo <string opName, VOPProfile P, list<dag> pattern = [],
  72                    bit VOP3Only = 0, bit isVOP3P = 0> :
  73   InstSI <P.Outs64, !if(!and(isVOP3P, P.IsPacked), P.InsVOP3P, P.Ins64), "", pattern>,
  74   VOP <opName>,
  75   SIMCInstr<opName#"_e64", SIEncodingFamily.NONE>,
  76   MnemonicAlias<opName#"_e64", opName> {
  77
  78   let isPseudo = 1;
  79   let isCodeGenOnly = 1;
  80   let UseNamedOperandTable = 1;
  81
  82   string Mnemonic = opName;
  83   string AsmOperands = !if(!and(isVOP3P, P.IsPacked), P.AsmVOP3P, P.Asm64);
  84
  85   let Size = 8;
  86   let mayLoad = 0;
  87   let mayStore = 0;
  88   let hasSideEffects = 0;
  89   let SubtargetPredicate = isGCN;
  90
  91   // Because SGPRs may be allowed if there are multiple operands, we
  92   // need a post-isel hook to insert copies in order to avoid
  93   // violating constant bus requirements.
  94   let hasPostISelHook = 1;
  95
  96   // Using complex patterns gives VOP3 patterns a very high complexity rating,
  97   // but standalone patterns are almost always preferred, so we need to adjust the
  98   // priority lower.  The goal is to use a high number to reduce complexity to
  99   // zero (or less than zero).
 100   let AddedComplexity = -1000;
 101
 102   let VOP3 = 1;
 103   let VALU = 1;
 104   let FPClamp = P.HasFPClamp;
 105   let Uses = [EXEC];
 106
 107   let AsmVariantName = AMDGPUAsmVariants.VOP3;
 108   let AsmMatchConverter =
 109     !if(!eq(VOP3Only,1),
 110         !if(!and(P.IsPacked, isVOP3P), "cvtVOP3P", "cvtVOP3"),
 111         !if(!eq(P.HasModifiers, 1),
 112             "cvtVOP3_2_mod",
 113             !if(!eq(P.HasOMod, 1), "cvtVOP3OMod", "")
 114         )
 115     );
 116
 117   VOPProfile Pfl = P;
 118 }
 119
 120 class VOP3P_Pseudo <string opName, VOPProfile P, list<dag> pattern = []> :
 121   VOP3_Pseudo<opName, P, pattern, 1, 1> {
 122   let VOP3P = 1;
 123 }
 124
 125 class VOP3_Real <VOP3_Pseudo ps, int EncodingFamily> :
 126   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 127   SIMCInstr <ps.PseudoInstr, EncodingFamily> {
 128
 129   let isPseudo = 0;
 130   let isCodeGenOnly = 0;
 131   let UseNamedOperandTable = 1;
 132
 133   let Constraints     = ps.Constraints;
 134   let DisableEncoding = ps.DisableEncoding;
 135
 136   // copy relevant pseudo op flags
 137   let SubtargetPredicate = ps.SubtargetPredicate;
 138   let AsmMatchConverter  = ps.AsmMatchConverter;
 139   let AsmVariantName     = ps.AsmVariantName;
 140   let Constraints        = ps.Constraints;
 141   let DisableEncoding    = ps.DisableEncoding;
 142   let TSFlags            = ps.TSFlags;
 143   let UseNamedOperandTable = ps.UseNamedOperandTable;
 144   let Uses                 = ps.Uses;
 145 }
 146
 147 // XXX - Is there any reason to distingusih this from regular VOP3
 148 // here?
 149 class VOP3P_Real<VOP3P_Pseudo ps, int EncodingFamily> :
 150   VOP3_Real<ps, EncodingFamily>;
 151
 152 class VOP3a<VOPProfile P> : Enc64 {
 153   bits<2> src0_modifiers;
 154   bits<9> src0;
 155   bits<2> src1_modifiers;
 156   bits<9> src1;
 157   bits<2> src2_modifiers;
 158   bits<9> src2;
 159   bits<1> clamp;
 160   bits<2> omod;
 161
 162   let Inst{8}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);
 163   let Inst{9}     = !if(P.HasSrc1Mods, src1_modifiers{1}, 0);
 164   let Inst{10}    = !if(P.HasSrc2Mods, src2_modifiers{1}, 0);
 165
 166   let Inst{31-26} = 0x34; //encoding
 167   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 168   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 169   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 170   let Inst{60-59} = !if(P.HasOMod, omod, 0);
 171   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 172   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
 173   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
 174 }
 175
 176 class VOP3a_si <bits<9> op, VOPProfile P> : VOP3a<P> {
 177   let Inst{25-17} = op;
 178   let Inst{11}    = !if(P.HasClamp, clamp{0}, 0);
 179 }
 180
 181 class VOP3a_vi <bits<10> op, VOPProfile P> : VOP3a<P> {
 182   let Inst{25-16} = op;
 183   let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
 184 }
 185
 186 class VOP3e_si <bits<9> op, VOPProfile P> : VOP3a_si <op, P> {
 187   bits<8> vdst;
 188   let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
 189 }
 190
 191 class VOP3e_vi <bits<10> op, VOPProfile P> : VOP3a_vi <op, P> {
 192   bits<8> vdst;
 193   let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
 194 }
 195
 196 class VOP3be <VOPProfile P> : Enc64 {
 197   bits<8> vdst;
 198   bits<2> src0_modifiers;
 199   bits<9> src0;
 200   bits<2> src1_modifiers;
 201   bits<9> src1;
 202   bits<2> src2_modifiers;
 203   bits<9> src2;
 204   bits<7> sdst;
 205   bits<2> omod;
 206
 207   let Inst{7-0}   = vdst;
 208   let Inst{14-8}  = sdst;
 209   let Inst{31-26} = 0x34; //encoding
 210   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 211   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 212   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 213   let Inst{60-59} = !if(P.HasOMod, omod, 0);
 214   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 215   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
 216   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
 217 }
 218
 219 class VOP3Pe <bits<10> op, VOPProfile P> : Enc64 {
 220   bits<8> vdst;
 221   // neg, neg_hi, op_sel put in srcN_modifiers
 222   bits<4> src0_modifiers;
 223   bits<9> src0;
 224   bits<4> src1_modifiers;
 225   bits<9> src1;
 226   bits<4> src2_modifiers;
 227   bits<9> src2;
 228   bits<1> clamp;
 229
 230   let Inst{7-0} = vdst;
 231   let Inst{8} = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // neg_hi src0
 232   let Inst{9} = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // neg_hi src1
 233   let Inst{10} = !if(P.HasSrc2Mods, src2_modifiers{1}, 0); // neg_hi src2
 234
 235   let Inst{11} = !if(P.HasOpSel, src0_modifiers{2}, 0); // op_sel(0)
 236   let Inst{12} = !if(P.HasOpSel, src1_modifiers{2}, 0); // op_sel(1)
 237   let Inst{13} = !if(P.HasOpSel, src2_modifiers{2}, 0); // op_sel(2)
 238
 239   let Inst{14} = !if(P.HasOpSel, src2_modifiers{3}, 0); // op_sel_hi(2)
 240
 241   let Inst{15} = !if(P.HasClamp, clamp{0}, 0);
 242
 243   let Inst{25-16} = op;
 244   let Inst{31-26} = 0x34; //encoding
 245   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 246   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 247   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 248   let Inst{59}    = !if(P.HasOpSel, src0_modifiers{3}, 0); // op_sel_hi(0)
 249   let Inst{60}    = !if(P.HasOpSel, src1_modifiers{3}, 0); // op_sel_hi(1)
 250   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // neg (lo)
 251   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // neg (lo)
 252   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0); // neg (lo)
 253 }
 254
 255 class VOP3be_si <bits<9> op, VOPProfile P> : VOP3be<P> {
 256   let Inst{25-17} = op;
 257 }
 258
 259 class VOP3be_vi <bits<10> op, VOPProfile P> : VOP3be<P> {
 260   bits<1> clamp;
 261   let Inst{25-16} = op;
 262   let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
 263 }
 264
 265 def SDWA {
 266   // sdwa_sel
 267   int BYTE_0 = 0;
 268   int BYTE_1 = 1;
 269   int BYTE_2 = 2;
 270   int BYTE_3 = 3;
 271   int WORD_0 = 4;
 272   int WORD_1 = 5;
 273   int DWORD = 6;
 274
 275   // dst_unused
 276   int UNUSED_PAD = 0;
 277   int UNUSED_SEXT = 1;
 278   int UNUSED_PRESERVE = 2;
 279 }
 280
 281 class VOP_SDWAe<VOPProfile P> : Enc64 {
 282   bits<8> src0;
 283   bits<3> src0_sel;
 284   bits<2> src0_modifiers; // float: {abs,neg}, int {sext}
 285   bits<3> src1_sel;
 286   bits<2> src1_modifiers;
 287   bits<3> dst_sel;
 288   bits<2> dst_unused;
 289   bits<1> clamp;
 290
 291   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 292   let Inst{42-40} = !if(P.EmitDst, dst_sel{2-0}, SDWA.DWORD);
 293   let Inst{44-43} = !if(P.EmitDst, dst_unused{1-0}, SDWA.UNUSED_PRESERVE);
 294   let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);
 295   let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, SDWA.DWORD);
 296   let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);
 297   let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);
 298   let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, SDWA.DWORD);
 299   let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);
 300   let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);
 301 }
 302
 303 // gfx9 SDWA basic encoding
 304 class VOP_SDWA9e<VOPProfile P> : Enc64 {
 305   bits<9> src0; // {src0_sgpr{0}, src0{7-0}}
 306   bits<3> src0_sel;
 307   bits<2> src0_modifiers; // float: {abs,neg}, int {sext}
 308   bits<3> src1_sel;
 309   bits<2> src1_modifiers;
 310   bits<1> src1_sgpr;
 311
 312   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 313   let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, SDWA.DWORD);
 314   let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);
 315   let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);
 316   let Inst{55}    = !if(P.HasSrc0, src0{8}, 0);
 317   let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, SDWA.DWORD);
 318   let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);
 319   let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);
 320   let Inst{63}    = 0; // src1_sgpr - should be specified in subclass
 321 }
 322
 323 // gfx9 SDWA-A
 324 class VOP_SDWA9Ae<VOPProfile P> : VOP_SDWA9e<P> {
 325   bits<3> dst_sel;
 326   bits<2> dst_unused;
 327   bits<1> clamp;
 328   bits<2> omod;
 329
 330   let Inst{42-40} = !if(P.EmitDst, dst_sel{2-0}, SDWA.DWORD);
 331   let Inst{44-43} = !if(P.EmitDst, dst_unused{1-0}, SDWA.UNUSED_PRESERVE);
 332   let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);
 333   let Inst{47-46} = !if(P.HasSDWAOMod, omod{1-0}, 0);
 334 }
 335
 336 // gfx9 SDWA-B
 337 class VOP_SDWA9Be<VOPProfile P> : VOP_SDWA9e<P> {
 338   bits<8> sdst; // {vcc_sdst{0}, sdst{6-0}}
 339
 340   let Inst{46-40} = !if(P.EmitDst, sdst{6-0}, 0);
 341   let Inst{47} = !if(P.EmitDst, sdst{7}, 0);
 342 }
 343
 344 class VOP_SDWA_Pseudo <string opName, VOPProfile P, list<dag> pattern=[]> :
 345   InstSI <P.OutsSDWA, P.InsSDWA, "", pattern>,
 346   VOP <opName>,
 347   SIMCInstr <opName#"_sdwa", SIEncodingFamily.NONE>,
 348   MnemonicAlias <opName#"_sdwa", opName> {
 349
 350   let isPseudo = 1;
 351   let isCodeGenOnly = 1;
 352   let UseNamedOperandTable = 1;
 353
 354   string Mnemonic = opName;
 355   string AsmOperands = P.AsmSDWA;
 356
 357   let Size = 8;
 358   let mayLoad = 0;
 359   let mayStore = 0;
 360   let hasSideEffects = 0;
 361
 362   let VALU = 1;
 363   let SDWA = 1;
 364   let Uses = [EXEC];
 365
 366   let SubtargetPredicate = !if(P.HasExt, HasSDWA, DisableInst);
 367   let AssemblerPredicate = !if(P.HasExt, HasSDWA, DisableInst);
 368   let AsmVariantName = !if(P.HasExt, AMDGPUAsmVariants.SDWA,
 369                                      AMDGPUAsmVariants.Disable);
 370   let DecoderNamespace = "SDWA";
 371
 372   VOPProfile Pfl = P;
 373 }
 374
 375 // GFX9 adds two features to SDWA:
 376 // 1.   Add 3 fields to the SDWA microcode word: S0, S1 and OMOD.
 377 //    a. S0 and S1 indicate that source 0 and 1 respectively are SGPRs rather
 378 //       than VGPRs (at most 1 can be an SGPR);
 379 //    b. OMOD is the standard output modifier (result *2, *4, /2)
 380 // 2.   Add a new version of the SDWA microcode word for VOPC: SDWAB. This
 381 //    replaces OMOD and the dest fields with SD and SDST (SGPR destination)
 382 //    field.
 383 //    a. When SD=1, the SDST is used as the destination for the compare result;
 384 //    b.when SD=0, VCC is used.
 385 //
 386 // In GFX9, V_MAC_F16, V_MAC_F32 opcodes cannot be used with SDWA
 387
 388 class VOP_SDWA9_Pseudo <string opName, VOPProfile P, list<dag> pattern=[]> :
 389   InstSI <P.OutsSDWA9, P.InsSDWA9, "", pattern>,
 390   VOP <opName>,
 391   SIMCInstr <opName#"_sdwa9", SIEncodingFamily.NONE>,
 392   MnemonicAlias <opName#"_sdwa9", opName> {
 393
 394   let isPseudo = 1;
 395   let isCodeGenOnly = 1;
 396   let UseNamedOperandTable = 1;
 397
 398   string Mnemonic = opName;
 399   string AsmOperands = P.AsmSDWA9;
 400
 401   let Size = 8;
 402   let mayLoad = 0;
 403   let mayStore = 0;
 404   let hasSideEffects = 0;
 405
 406   let VALU = 1;
 407   let SDWA = 1;
 408   let Uses = [EXEC];
 409
 410   let SubtargetPredicate = !if(P.HasSDWA9, HasSDWA9, DisableInst);
 411   let AssemblerPredicate = !if(P.HasSDWA9, HasSDWA9, DisableInst);
 412   let AsmVariantName = !if(P.HasSDWA9, AMDGPUAsmVariants.SDWA9,
 413                                      AMDGPUAsmVariants.Disable);
 414   let DecoderNamespace = "SDWA9";
 415
 416   VOPProfile Pfl = P;
 417 }
 418
 419 class VOP_SDWA_Real <VOP_SDWA_Pseudo ps> :
 420   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 421   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.VI> {
 422
 423   let isPseudo = 0;
 424   let isCodeGenOnly = 0;
 425
 426   let Defs = ps.Defs;
 427   let Uses = ps.Uses;
 428   let SchedRW = ps.SchedRW;
 429   let hasSideEffects = ps.hasSideEffects;
 430
 431   let Constraints     = ps.Constraints;
 432   let DisableEncoding = ps.DisableEncoding;
 433
 434   // Copy relevant pseudo op flags
 435   let SubtargetPredicate   = ps.SubtargetPredicate;
 436   let AssemblerPredicate   = ps.AssemblerPredicate;
 437   let AsmMatchConverter    = ps.AsmMatchConverter;
 438   let AsmVariantName       = ps.AsmVariantName;
 439   let UseNamedOperandTable = ps.UseNamedOperandTable;
 440   let DecoderNamespace     = ps.DecoderNamespace;
 441   let Constraints          = ps.Constraints;
 442   let DisableEncoding      = ps.DisableEncoding;
 443   let TSFlags              = ps.TSFlags;
 444 }
 445
 446 class VOP_SDWA9_Real <VOP_SDWA9_Pseudo ps> :
 447   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 448   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.VI> {
 449
 450   let isPseudo = 0;
 451   let isCodeGenOnly = 0;
 452
 453   let Defs = ps.Defs;
 454   let Uses = ps.Uses;
 455   let SchedRW = ps.SchedRW;
 456   let hasSideEffects = ps.hasSideEffects;
 457
 458   let Constraints     = ps.Constraints;
 459   let DisableEncoding = ps.DisableEncoding;
 460
 461   // Copy relevant pseudo op flags
 462   let SubtargetPredicate   = ps.SubtargetPredicate;
 463   let AssemblerPredicate   = ps.AssemblerPredicate;
 464   let AsmMatchConverter    = ps.AsmMatchConverter;
 465   let AsmVariantName       = ps.AsmVariantName;
 466   let UseNamedOperandTable = ps.UseNamedOperandTable;
 467   let DecoderNamespace     = ps.DecoderNamespace;
 468   let Constraints          = ps.Constraints;
 469   let DisableEncoding      = ps.DisableEncoding;
 470   let TSFlags              = ps.TSFlags;
 471 }
 472
 473 class VOP_DPPe<VOPProfile P> : Enc64 {
 474   bits<2> src0_modifiers;
 475   bits<8> src0;
 476   bits<2> src1_modifiers;
 477   bits<9> dpp_ctrl;
 478   bits<1> bound_ctrl;
 479   bits<4> bank_mask;
 480   bits<4> row_mask;
 481
 482   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 483   let Inst{48-40} = dpp_ctrl;
 484   let Inst{51}    = bound_ctrl;
 485   let Inst{52}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // src0_neg
 486   let Inst{53}    = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // src0_abs
 487   let Inst{54}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // src1_neg
 488   let Inst{55}    = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // src1_abs
 489   let Inst{59-56} = bank_mask;
 490   let Inst{63-60} = row_mask;
 491 }
 492
 493 class VOP_DPP <string OpName, VOPProfile P> :
 494   InstSI <P.OutsDPP, P.InsDPP, OpName#P.AsmDPP, []>,
 495   VOP_DPPe<P> {
 496
 497   let mayLoad = 0;
 498   let mayStore = 0;
 499   let hasSideEffects = 0;
 500   let UseNamedOperandTable = 1;
 501
 502   let VALU = 1;
 503   let DPP = 1;
 504   let Size = 8;
 505
 506   let AsmMatchConverter = !if(!eq(P.HasModifiers,1), "cvtDPP", "");
 507   let SubtargetPredicate = HasDPP;
 508   let AssemblerPredicate = !if(P.HasExt, HasDPP, DisableInst);
 509   let AsmVariantName = !if(P.HasExt, AMDGPUAsmVariants.DPP,
 510                                      AMDGPUAsmVariants.Disable);
 511   let DecoderNamespace = "DPP";
 512 }
 513
 514 include "VOPCInstructions.td"
 515 include "VOP1Instructions.td"
 516 include "VOP2Instructions.td"
 517 include "VOP3Instructions.td"
 518 include "VOP3PInstructions.td"