lib/Target/AMDGPU/VOPInstructions.td

   1 //===-- VOPInstructions.td - Vector Instruction Defintions ----------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 // dummies for outer let
  10 class LetDummies {
  11   bit isCommutable;
  12   bit isConvertibleToThreeAddress;
  13   bit isMoveImm;
  14   bit isReMaterializable;
  15   bit isAsCheapAsAMove;
  16   bit VOPAsmPrefer32Bit;
  17   Predicate SubtargetPredicate;
  18   string Constraints;
  19   string DisableEncoding;
  20   list<SchedReadWrite> SchedRW;
  21   list<Register> Uses;
  22   list<Register> Defs;
  23 }
  24
  25 class VOP <string opName> {
  26   string OpName = opName;
  27 }
  28
  29 class VOPAnyCommon <dag outs, dag ins, string asm, list<dag> pattern> :
  30     InstSI <outs, ins, asm, pattern> {
  31
  32   let mayLoad = 0;
  33   let mayStore = 0;
  34   let hasSideEffects = 0;
  35   let UseNamedOperandTable = 1;
  36   let VALU = 1;
  37   let Uses = [EXEC];
  38 }
  39
  40 class VOP_Pseudo <string opName, string suffix, VOPProfile P, dag outs, dag ins,
  41                   string asm, list<dag> pattern> :
  42   InstSI <outs, ins, asm, pattern>,
  43   VOP <opName>,
  44   SIMCInstr <opName#suffix, SIEncodingFamily.NONE>,
  45   MnemonicAlias<opName#suffix, opName> {
  46
  47   let isPseudo = 1;
  48   let isCodeGenOnly = 1;
  49   let UseNamedOperandTable = 1;
  50
  51   string Mnemonic = opName;
  52   VOPProfile Pfl = P;
  53
  54   string AsmOperands;
  55 }
  56
  57 class VOP3Common <dag outs, dag ins, string asm = "",
  58                   list<dag> pattern = [], bit HasMods = 0,
  59                   bit VOP3Only = 0> :
  60   VOPAnyCommon <outs, ins, asm, pattern> {
  61
  62   // Using complex patterns gives VOP3 patterns a very high complexity rating,
  63   // but standalone patterns are almost always preferred, so we need to adjust the
  64   // priority lower.  The goal is to use a high number to reduce complexity to
  65   // zero (or less than zero).
  66   let AddedComplexity = -1000;
  67
  68   let VOP3 = 1;
  69
  70   let AsmVariantName = AMDGPUAsmVariants.VOP3;
  71   let AsmMatchConverter = !if(!eq(HasMods,1), "cvtVOP3", "");
  72
  73   let isCodeGenOnly = 0;
  74
  75   int Size = 8;
  76
  77   // Because SGPRs may be allowed if there are multiple operands, we
  78   // need a post-isel hook to insert copies in order to avoid
  79   // violating constant bus requirements.
  80   let hasPostISelHook = 1;
  81 }
  82
  83 class VOP3_Pseudo <string opName, VOPProfile P, list<dag> pattern = [],
  84                    bit VOP3Only = 0, bit isVOP3P = 0, bit isVop3OpSel = 0> :
  85   VOP_Pseudo <opName, "_e64", P, P.Outs64,
  86               !if(isVop3OpSel,
  87                   P.InsVOP3OpSel,
  88                   !if(!and(isVOP3P, P.IsPacked), P.InsVOP3P, P.Ins64)),
  89               "", pattern> {
  90
  91   let VOP3_OPSEL = isVop3OpSel;
  92   let IsPacked = P.IsPacked;
  93
  94   let AsmOperands = !if(isVop3OpSel,
  95                         P.AsmVOP3OpSel,
  96                         !if(!and(isVOP3P, P.IsPacked), P.AsmVOP3P, P.Asm64));
  97
  98   let Size = 8;
  99   let mayLoad = 0;
 100   let mayStore = 0;
 101   let hasSideEffects = 0;
 102
 103   // Because SGPRs may be allowed if there are multiple operands, we
 104   // need a post-isel hook to insert copies in order to avoid
 105   // violating constant bus requirements.
 106   let hasPostISelHook = 1;
 107
 108   // Using complex patterns gives VOP3 patterns a very high complexity rating,
 109   // but standalone patterns are almost always preferred, so we need to adjust the
 110   // priority lower.  The goal is to use a high number to reduce complexity to
 111   // zero (or less than zero).
 112   let AddedComplexity = -1000;
 113
 114   let VOP3 = 1;
 115   let VALU = 1;
 116   let FPClamp = P.HasFPClamp;
 117   let IntClamp = P.HasIntClamp;
 118   let ClampLo = P.HasClampLo;
 119   let ClampHi = P.HasClampHi;
 120
 121   let Uses = [EXEC];
 122
 123   let AsmVariantName = AMDGPUAsmVariants.VOP3;
 124   let AsmMatchConverter =
 125     !if(isVOP3P,
 126         "cvtVOP3P",
 127         !if(!or(P.HasModifiers, !or(P.HasOMod, P.HasIntClamp)),
 128             "cvtVOP3",
 129             ""));
 130 }
 131
 132 class VOP3P_Pseudo <string opName, VOPProfile P, list<dag> pattern = []> :
 133   VOP3_Pseudo<opName, P, pattern, 1, 1> {
 134   let VOP3P = 1;
 135 }
 136
 137 class VOP3_Real <VOP_Pseudo ps, int EncodingFamily> :
 138   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 139   SIMCInstr <ps.PseudoInstr, EncodingFamily> {
 140
 141   let isPseudo = 0;
 142   let isCodeGenOnly = 0;
 143   let UseNamedOperandTable = 1;
 144
 145   let Constraints     = ps.Constraints;
 146   let DisableEncoding = ps.DisableEncoding;
 147
 148   // copy relevant pseudo op flags
 149   let SubtargetPredicate = ps.SubtargetPredicate;
 150   let AsmMatchConverter  = ps.AsmMatchConverter;
 151   let AsmVariantName     = ps.AsmVariantName;
 152   let Constraints        = ps.Constraints;
 153   let DisableEncoding    = ps.DisableEncoding;
 154   let TSFlags            = ps.TSFlags;
 155   let UseNamedOperandTable = ps.UseNamedOperandTable;
 156   let Uses                 = ps.Uses;
 157   let Defs                 = ps.Defs;
 158
 159   VOPProfile Pfl = ps.Pfl;
 160 }
 161
 162 // XXX - Is there any reason to distingusih this from regular VOP3
 163 // here?
 164 class VOP3P_Real<VOP_Pseudo ps, int EncodingFamily> :
 165   VOP3_Real<ps, EncodingFamily>;
 166
 167 class VOP3a<VOPProfile P> : Enc64 {
 168   bits<4> src0_modifiers;
 169   bits<9> src0;
 170   bits<3> src1_modifiers;
 171   bits<9> src1;
 172   bits<3> src2_modifiers;
 173   bits<9> src2;
 174   bits<1> clamp;
 175   bits<2> omod;
 176
 177   let Inst{8}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);
 178   let Inst{9}     = !if(P.HasSrc1Mods, src1_modifiers{1}, 0);
 179   let Inst{10}    = !if(P.HasSrc2Mods, src2_modifiers{1}, 0);
 180
 181   let Inst{31-26} = 0x34; //encoding
 182   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 183   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 184   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 185   let Inst{60-59} = !if(P.HasOMod, omod, 0);
 186   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 187   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
 188   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
 189 }
 190
 191 class VOP3a_si <bits<9> op, VOPProfile P> : VOP3a<P> {
 192   let Inst{25-17} = op;
 193   let Inst{11}    = !if(P.HasClamp, clamp{0}, 0);
 194 }
 195
 196 class VOP3a_vi <bits<10> op, VOPProfile P> : VOP3a<P> {
 197   let Inst{25-16} = op;
 198   let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
 199 }
 200
 201 class VOP3e_si <bits<9> op, VOPProfile P> : VOP3a_si <op, P> {
 202   bits<8> vdst;
 203   let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
 204 }
 205
 206 class VOP3e_vi <bits<10> op, VOPProfile P> : VOP3a_vi <op, P> {
 207   bits<8> vdst;
 208   let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
 209 }
 210
 211 class VOP3OpSel_gfx9 <bits<10> op, VOPProfile P> : VOP3e_vi <op, P> {
 212   let Inst{11} = !if(P.HasSrc0, src0_modifiers{2}, 0);
 213   let Inst{12} = !if(P.HasSrc1, src1_modifiers{2}, 0);
 214   let Inst{13} = !if(P.HasSrc2, src2_modifiers{2}, 0);
 215   let Inst{14} = !if(P.HasDst,  src0_modifiers{3}, 0);
 216 }
 217
 218 // NB: For V_INTERP* opcodes, src0 is encoded as src1 and vice versa
 219 class VOP3Interp_vi <bits<10> op, VOPProfile P> : VOP3e_vi <op, P> {
 220   bits<2> attrchan;
 221   bits<6> attr;
 222   bits<1> high;
 223
 224   let Inst{8}     = 0; // No modifiers for src0
 225   let Inst{61}    = 0;
 226
 227   let Inst{9}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);
 228   let Inst{62}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 229
 230   let Inst{37-32} = attr;
 231   let Inst{39-38} = attrchan;
 232   let Inst{40}    = !if(P.HasHigh, high, 0);
 233
 234   let Inst{49-41} = src0;
 235 }
 236
 237 class VOP3be <VOPProfile P> : Enc64 {
 238   bits<8> vdst;
 239   bits<2> src0_modifiers;
 240   bits<9> src0;
 241   bits<2> src1_modifiers;
 242   bits<9> src1;
 243   bits<2> src2_modifiers;
 244   bits<9> src2;
 245   bits<7> sdst;
 246   bits<2> omod;
 247
 248   let Inst{7-0}   = vdst;
 249   let Inst{14-8}  = sdst;
 250   let Inst{31-26} = 0x34; //encoding
 251   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 252   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 253   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 254   let Inst{60-59} = !if(P.HasOMod, omod, 0);
 255   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 256   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
 257   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
 258 }
 259
 260 class VOP3Pe <bits<10> op, VOPProfile P> : Enc64 {
 261   bits<8> vdst;
 262   // neg, neg_hi, op_sel put in srcN_modifiers
 263   bits<4> src0_modifiers;
 264   bits<9> src0;
 265   bits<4> src1_modifiers;
 266   bits<9> src1;
 267   bits<4> src2_modifiers;
 268   bits<9> src2;
 269   bits<1> clamp;
 270
 271   let Inst{7-0} = vdst;
 272   let Inst{8} = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // neg_hi src0
 273   let Inst{9} = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // neg_hi src1
 274   let Inst{10} = !if(P.HasSrc2Mods, src2_modifiers{1}, 0); // neg_hi src2
 275
 276   let Inst{11} = !if(!and(P.HasSrc0, P.HasOpSel), src0_modifiers{2}, 0); // op_sel(0)
 277   let Inst{12} = !if(!and(P.HasSrc1, P.HasOpSel), src1_modifiers{2}, 0); // op_sel(1)
 278   let Inst{13} = !if(!and(P.HasSrc2, P.HasOpSel), src2_modifiers{2}, 0); // op_sel(2)
 279
 280   let Inst{14} = !if(!and(P.HasSrc2, P.HasOpSel), src2_modifiers{3}, 0); // op_sel_hi(2)
 281
 282   let Inst{15} = !if(P.HasClamp, clamp{0}, 0);
 283
 284   let Inst{25-16} = op;
 285   let Inst{31-26} = 0x34; //encoding
 286   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 287   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 288   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 289   let Inst{59}    = !if(!and(P.HasSrc0, P.HasOpSel), src0_modifiers{3}, 0); // op_sel_hi(0)
 290   let Inst{60}    = !if(!and(P.HasSrc1, P.HasOpSel), src1_modifiers{3}, 0); // op_sel_hi(1)
 291   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // neg (lo)
 292   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // neg (lo)
 293   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0); // neg (lo)
 294 }
 295
 296 class VOP3be_si <bits<9> op, VOPProfile P> : VOP3be<P> {
 297   let Inst{25-17} = op;
 298 }
 299
 300 class VOP3be_vi <bits<10> op, VOPProfile P> : VOP3be<P> {
 301   bits<1> clamp;
 302   let Inst{25-16} = op;
 303   let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
 304 }
 305
 306 def SDWA {
 307   // sdwa_sel
 308   int BYTE_0 = 0;
 309   int BYTE_1 = 1;
 310   int BYTE_2 = 2;
 311   int BYTE_3 = 3;
 312   int WORD_0 = 4;
 313   int WORD_1 = 5;
 314   int DWORD = 6;
 315
 316   // dst_unused
 317   int UNUSED_PAD = 0;
 318   int UNUSED_SEXT = 1;
 319   int UNUSED_PRESERVE = 2;
 320 }
 321
 322 class VOP_SDWAe<VOPProfile P> : Enc64 {
 323   bits<8> src0;
 324   bits<3> src0_sel;
 325   bits<2> src0_modifiers; // float: {abs,neg}, int {sext}
 326   bits<3> src1_sel;
 327   bits<2> src1_modifiers;
 328   bits<3> dst_sel;
 329   bits<2> dst_unused;
 330   bits<1> clamp;
 331
 332   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 333   let Inst{42-40} = !if(P.EmitDst, dst_sel{2-0}, 0);
 334   let Inst{44-43} = !if(P.EmitDst, dst_unused{1-0}, 0);
 335   let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);
 336   let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, 0);
 337   let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);
 338   let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);
 339   let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, 0);
 340   let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);
 341   let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);
 342 }
 343
 344 // GFX9 adds two features to SDWA:
 345 // 1.   Add 3 fields to the SDWA microcode word: S0, S1 and OMOD.
 346 //    a. S0 and S1 indicate that source 0 and 1 respectively are SGPRs rather
 347 //       than VGPRs (at most 1 can be an SGPR);
 348 //    b. OMOD is the standard output modifier (result *2, *4, /2)
 349 // 2.   Add a new version of the SDWA microcode word for VOPC: SDWAB. This
 350 //    replaces OMOD and the dest fields with SD and SDST (SGPR destination)
 351 //    field.
 352 //    a. When SD=1, the SDST is used as the destination for the compare result;
 353 //    b. When SD=0, VCC is used.
 354 //
 355 // In GFX9, V_MAC_F16, V_MAC_F32 opcodes cannot be used with SDWA
 356
 357 // gfx9 SDWA basic encoding
 358 class VOP_SDWA9e<VOPProfile P> : Enc64 {
 359   bits<9> src0; // {src0_sgpr{0}, src0{7-0}}
 360   bits<3> src0_sel;
 361   bits<2> src0_modifiers; // float: {abs,neg}, int {sext}
 362   bits<3> src1_sel;
 363   bits<2> src1_modifiers;
 364   bits<1> src1_sgpr;
 365
 366   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 367   let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, 0);
 368   let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);
 369   let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);
 370   let Inst{55}    = !if(P.HasSrc0, src0{8}, 0);
 371   let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, 0);
 372   let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);
 373   let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);
 374   let Inst{63}    = 0; // src1_sgpr - should be specified in subclass
 375 }
 376
 377 // gfx9 SDWA-A
 378 class VOP_SDWA9Ae<VOPProfile P> : VOP_SDWA9e<P> {
 379   bits<3> dst_sel;
 380   bits<2> dst_unused;
 381   bits<1> clamp;
 382   bits<2> omod;
 383
 384   let Inst{42-40} = !if(P.EmitDst, dst_sel{2-0}, 0);
 385   let Inst{44-43} = !if(P.EmitDst, dst_unused{1-0}, 0);
 386   let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);
 387   let Inst{47-46} = !if(P.HasSDWAOMod, omod{1-0}, 0);
 388 }
 389
 390 // gfx9 SDWA-B
 391 class VOP_SDWA9Be<VOPProfile P> : VOP_SDWA9e<P> {
 392   bits<8> sdst; // {vcc_sdst{0}, sdst{6-0}}
 393
 394   let Inst{46-40} = !if(P.EmitDst, sdst{6-0}, 0);
 395   let Inst{47} = !if(P.EmitDst, sdst{7}, 0);
 396 }
 397
 398 class VOP_SDWA_Pseudo <string opName, VOPProfile P, list<dag> pattern=[]> :
 399   InstSI <P.OutsSDWA, P.InsSDWA, "", pattern>,
 400   VOP <opName>,
 401   SIMCInstr <opName#"_sdwa", SIEncodingFamily.NONE>,
 402   MnemonicAlias <opName#"_sdwa", opName> {
 403
 404   let isPseudo = 1;
 405   let isCodeGenOnly = 1;
 406   let UseNamedOperandTable = 1;
 407
 408   string Mnemonic = opName;
 409   string AsmOperands = P.AsmSDWA;
 410   string AsmOperands9 = P.AsmSDWA9;
 411
 412   let Size = 8;
 413   let mayLoad = 0;
 414   let mayStore = 0;
 415   let hasSideEffects = 0;
 416
 417   let VALU = 1;
 418   let SDWA = 1;
 419   let Uses = [EXEC];
 420
 421   let SubtargetPredicate = !if(P.HasExtSDWA, HasSDWA, DisableInst);
 422   let AssemblerPredicate = !if(P.HasExtSDWA, HasSDWA, DisableInst);
 423   let AsmVariantName = !if(P.HasExtSDWA, AMDGPUAsmVariants.SDWA,
 424                                          AMDGPUAsmVariants.Disable);
 425   let DecoderNamespace = "SDWA";
 426
 427   VOPProfile Pfl = P;
 428 }
 429
 430 class VOP_SDWA_Real <VOP_SDWA_Pseudo ps> :
 431   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 432   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.SDWA> {
 433
 434   let isPseudo = 0;
 435   let isCodeGenOnly = 0;
 436
 437   let Defs = ps.Defs;
 438   let Uses = ps.Uses;
 439   let SchedRW = ps.SchedRW;
 440   let hasSideEffects = ps.hasSideEffects;
 441
 442   let Constraints     = ps.Constraints;
 443   let DisableEncoding = ps.DisableEncoding;
 444
 445   // Copy relevant pseudo op flags
 446   let SubtargetPredicate   = ps.SubtargetPredicate;
 447   let AssemblerPredicate   = ps.AssemblerPredicate;
 448   let AsmMatchConverter    = ps.AsmMatchConverter;
 449   let AsmVariantName       = ps.AsmVariantName;
 450   let UseNamedOperandTable = ps.UseNamedOperandTable;
 451   let DecoderNamespace     = ps.DecoderNamespace;
 452   let Constraints          = ps.Constraints;
 453   let DisableEncoding      = ps.DisableEncoding;
 454   let TSFlags              = ps.TSFlags;
 455 }
 456
 457 class VOP_SDWA9_Real <VOP_SDWA_Pseudo ps> :
 458   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands9, []>,
 459   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.SDWA9> {
 460
 461   let isPseudo = 0;
 462   let isCodeGenOnly = 0;
 463
 464   let Defs = ps.Defs;
 465   let Uses = ps.Uses;
 466   let SchedRW = ps.SchedRW;
 467   let hasSideEffects = ps.hasSideEffects;
 468
 469   let Constraints     = ps.Constraints;
 470   let DisableEncoding = ps.DisableEncoding;
 471
 472   let SubtargetPredicate = !if(ps.Pfl.HasExtSDWA9, HasSDWA9, DisableInst);
 473   let AssemblerPredicate = !if(ps.Pfl.HasExtSDWA9, HasSDWA9, DisableInst);
 474   let AsmVariantName = !if(ps.Pfl.HasExtSDWA9, AMDGPUAsmVariants.SDWA9,
 475                                                AMDGPUAsmVariants.Disable);
 476   let DecoderNamespace = "SDWA9";
 477
 478   // Copy relevant pseudo op flags
 479   let AsmMatchConverter    = ps.AsmMatchConverter;
 480   let UseNamedOperandTable = ps.UseNamedOperandTable;
 481   let Constraints          = ps.Constraints;
 482   let DisableEncoding      = ps.DisableEncoding;
 483   let TSFlags              = ps.TSFlags;
 484 }
 485
 486 class VOP_DPPe<VOPProfile P> : Enc64 {
 487   bits<2> src0_modifiers;
 488   bits<8> src0;
 489   bits<2> src1_modifiers;
 490   bits<9> dpp_ctrl;
 491   bits<1> bound_ctrl;
 492   bits<4> bank_mask;
 493   bits<4> row_mask;
 494
 495   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 496   let Inst{48-40} = dpp_ctrl;
 497   let Inst{51}    = bound_ctrl;
 498   let Inst{52}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // src0_neg
 499   let Inst{53}    = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // src0_abs
 500   let Inst{54}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // src1_neg
 501   let Inst{55}    = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // src1_abs
 502   let Inst{59-56} = bank_mask;
 503   let Inst{63-60} = row_mask;
 504 }
 505
 506 class VOP_DPP_Pseudo <string OpName, VOPProfile P, list<dag> pattern=[]> :
 507   InstSI <P.OutsDPP, P.InsDPP, OpName#P.AsmDPP, pattern>,
 508   VOP <OpName>,
 509   SIMCInstr <OpName#"_dpp", SIEncodingFamily.NONE>,
 510   MnemonicAlias <OpName#"_dpp", OpName> {
 511
 512   let isPseudo = 1;
 513   let isCodeGenOnly = 1;
 514
 515   let mayLoad = 0;
 516   let mayStore = 0;
 517   let hasSideEffects = 0;
 518   let UseNamedOperandTable = 1;
 519
 520   let VALU = 1;
 521   let DPP = 1;
 522   let Size = 8;
 523   let Uses = [EXEC];
 524   let isConvergent = 1;
 525
 526   string Mnemonic = OpName;
 527   string AsmOperands = P.AsmDPP;
 528
 529   let AsmMatchConverter = !if(!eq(P.HasModifiers,1), "cvtDPP", "");
 530   let SubtargetPredicate = HasDPP;
 531   let AssemblerPredicate = !if(P.HasExtDPP, HasDPP, DisableInst);
 532   let AsmVariantName = !if(P.HasExtDPP, AMDGPUAsmVariants.DPP,
 533                                         AMDGPUAsmVariants.Disable);
 534   let Constraints = !if(P.NumSrcArgs, "$old = $vdst", "");
 535   let DisableEncoding = !if(P.NumSrcArgs, "$old", "");
 536   let DecoderNamespace = "DPP";
 537
 538   VOPProfile Pfl = P;
 539 }
 540
 541 class VOP_DPP_Real <VOP_DPP_Pseudo ps, int EncodingFamily> :
 542   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 543   SIMCInstr <ps.PseudoInstr, EncodingFamily> {
 544
 545   let isPseudo = 0;
 546   let isCodeGenOnly = 0;
 547
 548   let Defs = ps.Defs;
 549   let Uses = ps.Uses;
 550   let SchedRW = ps.SchedRW;
 551   let hasSideEffects = ps.hasSideEffects;
 552
 553   let Constraints     = ps.Constraints;
 554   let DisableEncoding = ps.DisableEncoding;
 555
 556   // Copy relevant pseudo op flags
 557   let isConvergent         = ps.isConvergent;
 558   let SubtargetPredicate   = ps.SubtargetPredicate;
 559   let AssemblerPredicate   = ps.AssemblerPredicate;
 560   let AsmMatchConverter    = ps.AsmMatchConverter;
 561   let AsmVariantName       = ps.AsmVariantName;
 562   let UseNamedOperandTable = ps.UseNamedOperandTable;
 563   let DecoderNamespace     = ps.DecoderNamespace;
 564   let Constraints          = ps.Constraints;
 565   let DisableEncoding      = ps.DisableEncoding;
 566   let TSFlags              = ps.TSFlags;
 567 }
 568
 569 class getNumNodeArgs<SDPatternOperator Op> {
 570   SDNode N = !cast<SDNode>(Op);
 571   SDTypeProfile TP = N.TypeProfile;
 572   int ret = TP.NumOperands;
 573 }
 574
 575
 576 class getDivergentFrag<SDPatternOperator Op> {
 577
 578   int NumSrcArgs = getNumNodeArgs<Op>.ret;
 579   PatFrag ret = PatFrag <
 580     !if(!eq(NumSrcArgs, 1),
 581              (ops node:$src0),
 582              !if(!eq(NumSrcArgs, 2),
 583                (ops node:$src0, node:$src1),
 584                (ops node:$src0, node:$src1, node:$src2))),
 585     !if(!eq(NumSrcArgs, 1),
 586              (Op $src0),
 587              !if(!eq(NumSrcArgs, 2),
 588                (Op $src0, $src1),
 589                (Op $src0, $src1, $src2))),
 590     [{ return N->isDivergent(); }]
 591   >;
 592 }
 593
 594 class VOPPatGen<SDPatternOperator Op, VOPProfile P> {
 595
 596   PatFrag Operator = getDivergentFrag < Op >.ret;
 597
 598   dag Ins = !foreach(tmp, P.Ins32, !subst(ins, Operator,
 599                                          !subst(P.Src0RC32, P.Src0VT,
 600                                                !subst(P.Src1RC32, P.Src1VT, tmp))));
 601
 602
 603   dag Outs = !foreach(tmp, P.Outs32, !subst(outs, set,
 604                                            !subst(P.DstRC, P.DstVT, tmp)));
 605
 606   list<dag> ret =  [!con(Outs, (set Ins))];
 607 }
 608
 609 class VOPPatOrNull<SDPatternOperator Op, VOPProfile P> {
 610   list<dag> ret = !if(!ne(P.NeedPatGen,PatGenMode.NoPattern), VOPPatGen<Op, P>.ret, []);
 611 }
 612
 613 class DivergentFragOrOp<SDPatternOperator Op, VOPProfile P> {
 614   SDPatternOperator ret = !if(!eq(P.NeedPatGen,PatGenMode.Pattern),
 615    !if(!isa<SDNode>(Op), getDivergentFrag<Op>.ret, Op), Op);
 616 }
 617
 618 include "VOPCInstructions.td"
 619 include "VOP1Instructions.td"
 620 include "VOP2Instructions.td"
 621 include "VOP3Instructions.td"
 622 include "VOP3PInstructions.td"