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=[], bit VOP3Only = 0> :
  72   InstSI <P.Outs64, P.Ins64, "", pattern>,
  73   VOP <opName>,
  74   SIMCInstr<opName#"_e64", SIEncodingFamily.NONE>,
  75   MnemonicAlias<opName#"_e64", opName> {
  76
  77   let isPseudo = 1;
  78   let isCodeGenOnly = 1;
  79   let UseNamedOperandTable = 1;
  80
  81   string Mnemonic = opName;
  82   string AsmOperands = P.Asm64;
  83
  84   let Size = 8;
  85   let mayLoad = 0;
  86   let mayStore = 0;
  87   let hasSideEffects = 0;
  88   let SubtargetPredicate = isGCN;
  89
  90   // Because SGPRs may be allowed if there are multiple operands, we
  91   // need a post-isel hook to insert copies in order to avoid
  92   // violating constant bus requirements.
  93   let hasPostISelHook = 1;
  94
  95   // Using complex patterns gives VOP3 patterns a very high complexity rating,
  96   // but standalone patterns are almost always preferred, so we need to adjust the
  97   // priority lower.  The goal is to use a high number to reduce complexity to
  98   // zero (or less than zero).
  99   let AddedComplexity = -1000;
 100
 101   let VOP3 = 1;
 102   let VALU = 1;
 103   let Uses = [EXEC];
 104
 105   let AsmVariantName = AMDGPUAsmVariants.VOP3;
 106   let AsmMatchConverter =
 107     !if(!eq(VOP3Only,1),
 108         "cvtVOP3",
 109         !if(!eq(P.HasModifiers, 1), "cvtVOP3_2_mod", ""));
 110
 111   VOPProfile Pfl = P;
 112 }
 113
 114 class VOP3_Real <VOP3_Pseudo ps, int EncodingFamily> :
 115   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 116   SIMCInstr <ps.PseudoInstr, EncodingFamily> {
 117
 118   let isPseudo = 0;
 119   let isCodeGenOnly = 0;
 120
 121   let Constraints     = ps.Constraints;
 122   let DisableEncoding = ps.DisableEncoding;
 123
 124   // copy relevant pseudo op flags
 125   let SubtargetPredicate = ps.SubtargetPredicate;
 126   let AsmMatchConverter  = ps.AsmMatchConverter;
 127   let AsmVariantName     = ps.AsmVariantName;
 128   let Constraints        = ps.Constraints;
 129   let DisableEncoding    = ps.DisableEncoding;
 130   let TSFlags            = ps.TSFlags;
 131 }
 132
 133 class VOP3a<VOPProfile P> : Enc64 {
 134   bits<2> src0_modifiers;
 135   bits<9> src0;
 136   bits<2> src1_modifiers;
 137   bits<9> src1;
 138   bits<2> src2_modifiers;
 139   bits<9> src2;
 140   bits<1> clamp;
 141   bits<2> omod;
 142
 143   let Inst{8}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);
 144   let Inst{9}     = !if(P.HasSrc1Mods, src1_modifiers{1}, 0);
 145   let Inst{10}    = !if(P.HasSrc2Mods, src2_modifiers{1}, 0);
 146
 147   let Inst{31-26} = 0x34; //encoding
 148   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 149   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 150   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 151   let Inst{60-59} = !if(P.HasOMod, omod, 0);
 152   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 153   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
 154   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
 155 }
 156
 157 class VOP3a_si <bits<9> op, VOPProfile P> : VOP3a<P> {
 158   let Inst{25-17} = op;
 159   let Inst{11}    = !if(P.HasClamp, clamp{0}, 0);
 160 }
 161
 162 class VOP3a_vi <bits<10> op, VOPProfile P> : VOP3a<P> {
 163   let Inst{25-16} = op;
 164   let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
 165 }
 166
 167 class VOP3e_si <bits<9> op, VOPProfile P> : VOP3a_si <op, P> {
 168   bits<8> vdst;
 169   let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
 170 }
 171
 172 class VOP3e_vi <bits<10> op, VOPProfile P> : VOP3a_vi <op, P> {
 173   bits<8> vdst;
 174   let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
 175 }
 176
 177 class VOP3be <VOPProfile P> : Enc64 {
 178   bits<8> vdst;
 179   bits<2> src0_modifiers;
 180   bits<9> src0;
 181   bits<2> src1_modifiers;
 182   bits<9> src1;
 183   bits<2> src2_modifiers;
 184   bits<9> src2;
 185   bits<7> sdst;
 186   bits<2> omod;
 187
 188   let Inst{7-0}   = vdst;
 189   let Inst{14-8}  = sdst;
 190   let Inst{31-26} = 0x34; //encoding
 191   let Inst{40-32} = !if(P.HasSrc0, src0, 0);
 192   let Inst{49-41} = !if(P.HasSrc1, src1, 0);
 193   let Inst{58-50} = !if(P.HasSrc2, src2, 0);
 194   let Inst{60-59} = !if(P.HasOMod, omod, 0);
 195   let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
 196   let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
 197   let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
 198 }
 199
 200 class VOP3be_si <bits<9> op, VOPProfile P> : VOP3be<P> {
 201   let Inst{25-17} = op;
 202 }
 203
 204 class VOP3be_vi <bits<10> op, VOPProfile P> : VOP3be<P> {
 205   bits<1> clamp;
 206   let Inst{25-16} = op;
 207   let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
 208 }
 209
 210 def SDWA {
 211   // sdwa_sel
 212   int BYTE_0 = 0;
 213   int BYTE_1 = 1;
 214   int BYTE_2 = 2;
 215   int BYTE_3 = 3;
 216   int WORD_0 = 4;
 217   int WORD_1 = 5;
 218   int DWORD = 6;
 219
 220   // dst_unused
 221   int UNUSED_PAD = 0;
 222   int UNUSED_SEXT = 1;
 223   int UNUSED_PRESERVE = 2;
 224 }
 225
 226 class VOP_SDWAe<VOPProfile P> : Enc64 {
 227   bits<8> src0;
 228   bits<3> src0_sel;
 229   bits<2> src0_modifiers; // float: {abs,neg}, int {sext}
 230   bits<3> src1_sel;
 231   bits<2> src1_modifiers;
 232   bits<3> dst_sel;
 233   bits<2> dst_unused;
 234   bits<1> clamp;
 235
 236   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 237   let Inst{42-40} = !if(P.EmitDst, dst_sel{2-0}, SDWA.DWORD);
 238   let Inst{44-43} = !if(P.EmitDst, dst_unused{1-0}, SDWA.UNUSED_PRESERVE);
 239   let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);
 240   let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, SDWA.DWORD);
 241   let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);
 242   let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);
 243   let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, SDWA.DWORD);
 244   let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);
 245   let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);
 246 }
 247
 248 class VOP_SDWA_Pseudo <string opName, VOPProfile P, list<dag> pattern=[]> :
 249   InstSI <P.OutsSDWA, P.InsSDWA, "", pattern>,
 250   VOP <opName>,
 251   SIMCInstr <opName#"_sdwa", SIEncodingFamily.NONE>,
 252   MnemonicAlias <opName#"_sdwa", opName> {
 253
 254   let isPseudo = 1;
 255   let isCodeGenOnly = 1;
 256   let UseNamedOperandTable = 1;
 257
 258   string Mnemonic = opName;
 259   string AsmOperands = P.AsmSDWA;
 260
 261   let Size = 8;
 262   let mayLoad = 0;
 263   let mayStore = 0;
 264   let hasSideEffects = 0;
 265
 266   let VALU = 1;
 267   let SDWA = 1;
 268   let Uses = [EXEC];
 269
 270   let SubtargetPredicate = isVI;
 271   let AssemblerPredicate = !if(P.HasExt, isVI, DisableInst);
 272   let AsmVariantName = !if(P.HasExt, AMDGPUAsmVariants.SDWA,
 273                                      AMDGPUAsmVariants.Disable);
 274   let DecoderNamespace = "SDWA";
 275
 276   VOPProfile Pfl = P;
 277 }
 278
 279 class VOP_SDWA_Real <VOP_SDWA_Pseudo ps> :
 280   InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
 281   SIMCInstr <ps.PseudoInstr, SIEncodingFamily.VI> {
 282
 283   let isPseudo = 0;
 284   let isCodeGenOnly = 0;
 285
 286   let Defs = ps.Defs;
 287   let Uses = ps.Uses;
 288   let SchedRW = ps.SchedRW;
 289   let hasSideEffects = ps.hasSideEffects;
 290
 291   let Constraints     = ps.Constraints;
 292   let DisableEncoding = ps.DisableEncoding;
 293
 294   // Copy relevant pseudo op flags
 295   let SubtargetPredicate   = ps.SubtargetPredicate;
 296   let AssemblerPredicate   = ps.AssemblerPredicate;
 297   let AsmMatchConverter    = ps.AsmMatchConverter;
 298   let AsmVariantName       = ps.AsmVariantName;
 299   let UseNamedOperandTable = ps.UseNamedOperandTable;
 300   let DecoderNamespace     = ps.DecoderNamespace;
 301   let Constraints          = ps.Constraints;
 302   let DisableEncoding      = ps.DisableEncoding;
 303   let TSFlags              = ps.TSFlags;
 304 }
 305
 306 class VOP_DPPe<VOPProfile P> : Enc64 {
 307   bits<2> src0_modifiers;
 308   bits<8> src0;
 309   bits<2> src1_modifiers;
 310   bits<9> dpp_ctrl;
 311   bits<1> bound_ctrl;
 312   bits<4> bank_mask;
 313   bits<4> row_mask;
 314
 315   let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
 316   let Inst{48-40} = dpp_ctrl;
 317   let Inst{51}    = bound_ctrl;
 318   let Inst{52}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // src0_neg
 319   let Inst{53}    = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // src0_abs
 320   let Inst{54}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // src1_neg
 321   let Inst{55}    = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // src1_abs
 322   let Inst{59-56} = bank_mask;
 323   let Inst{63-60} = row_mask;
 324 }
 325
 326 class VOP_DPP <string OpName, VOPProfile P> :
 327   InstSI <P.OutsDPP, P.InsDPP, OpName#P.AsmDPP, []>,
 328   VOP_DPPe<P> {
 329
 330   let mayLoad = 0;
 331   let mayStore = 0;
 332   let hasSideEffects = 0;
 333   let UseNamedOperandTable = 1;
 334
 335   let VALU = 1;
 336   let DPP = 1;
 337   let Size = 8;
 338
 339   let AsmMatchConverter = !if(!eq(P.HasModifiers,1), "cvtDPP", "");
 340   let SubtargetPredicate = isVI;
 341   let AssemblerPredicate = !if(P.HasExt, isVI, DisableInst);
 342   let AsmVariantName = !if(P.HasExt, AMDGPUAsmVariants.DPP,
 343                                      AMDGPUAsmVariants.Disable);
 344   let DecoderNamespace = "DPP";
 345 }
 346
 347 include "VOPCInstructions.td"
 348 include "VOP1Instructions.td"
 349 include "VOP2Instructions.td"
 350 include "VOP3Instructions.td"