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
11class 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
26class VOP <string opName> {
27  string OpName = opName;
28}
29
30class 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
41class 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
71class 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), "cvtVOP3_2_mod", ""));
112
113  VOPProfile Pfl = P;
114}
115
116class VOP3P_Pseudo <string opName, VOPProfile P, list<dag> pattern = []> :
117  VOP3_Pseudo<opName, P, pattern, 1, 1> {
118  let VOP3P = 1;
119}
120
121class VOP3_Real <VOP3_Pseudo ps, int EncodingFamily> :
122  InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
123  SIMCInstr <ps.PseudoInstr, EncodingFamily> {
124
125  let isPseudo = 0;
126  let isCodeGenOnly = 0;
127  let UseNamedOperandTable = 1;
128
129  let Constraints     = ps.Constraints;
130  let DisableEncoding = ps.DisableEncoding;
131
132  // copy relevant pseudo op flags
133  let SubtargetPredicate = ps.SubtargetPredicate;
134  let AsmMatchConverter  = ps.AsmMatchConverter;
135  let AsmVariantName     = ps.AsmVariantName;
136  let Constraints        = ps.Constraints;
137  let DisableEncoding    = ps.DisableEncoding;
138  let TSFlags            = ps.TSFlags;
139}
140
141// XXX - Is there any reason to distingusih this from regular VOP3
142// here?
143class VOP3P_Real<VOP3P_Pseudo ps, int EncodingFamily> :
144  VOP3_Real<ps, EncodingFamily>;
145
146class VOP3a<VOPProfile P> : Enc64 {
147  bits<2> src0_modifiers;
148  bits<9> src0;
149  bits<2> src1_modifiers;
150  bits<9> src1;
151  bits<2> src2_modifiers;
152  bits<9> src2;
153  bits<1> clamp;
154  bits<2> omod;
155
156  let Inst{8}     = !if(P.HasSrc0Mods, src0_modifiers{1}, 0);
157  let Inst{9}     = !if(P.HasSrc1Mods, src1_modifiers{1}, 0);
158  let Inst{10}    = !if(P.HasSrc2Mods, src2_modifiers{1}, 0);
159
160  let Inst{31-26} = 0x34; //encoding
161  let Inst{40-32} = !if(P.HasSrc0, src0, 0);
162  let Inst{49-41} = !if(P.HasSrc1, src1, 0);
163  let Inst{58-50} = !if(P.HasSrc2, src2, 0);
164  let Inst{60-59} = !if(P.HasOMod, omod, 0);
165  let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
166  let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
167  let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
168}
169
170class VOP3a_si <bits<9> op, VOPProfile P> : VOP3a<P> {
171  let Inst{25-17} = op;
172  let Inst{11}    = !if(P.HasClamp, clamp{0}, 0);
173}
174
175class VOP3a_vi <bits<10> op, VOPProfile P> : VOP3a<P> {
176  let Inst{25-16} = op;
177  let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
178}
179
180class VOP3e_si <bits<9> op, VOPProfile P> : VOP3a_si <op, P> {
181  bits<8> vdst;
182  let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
183}
184
185class VOP3e_vi <bits<10> op, VOPProfile P> : VOP3a_vi <op, P> {
186  bits<8> vdst;
187  let Inst{7-0} = !if(P.EmitDst, vdst{7-0}, 0);
188}
189
190class VOP3be <VOPProfile P> : Enc64 {
191  bits<8> vdst;
192  bits<2> src0_modifiers;
193  bits<9> src0;
194  bits<2> src1_modifiers;
195  bits<9> src1;
196  bits<2> src2_modifiers;
197  bits<9> src2;
198  bits<7> sdst;
199  bits<2> omod;
200
201  let Inst{7-0}   = vdst;
202  let Inst{14-8}  = sdst;
203  let Inst{31-26} = 0x34; //encoding
204  let Inst{40-32} = !if(P.HasSrc0, src0, 0);
205  let Inst{49-41} = !if(P.HasSrc1, src1, 0);
206  let Inst{58-50} = !if(P.HasSrc2, src2, 0);
207  let Inst{60-59} = !if(P.HasOMod, omod, 0);
208  let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0);
209  let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0);
210  let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0);
211}
212
213class VOP3Pe <bits<10> op, VOPProfile P> : Enc64 {
214  bits<8> vdst;
215  // neg, neg_hi, op_sel put in srcN_modifiers
216  bits<4> src0_modifiers;
217  bits<9> src0;
218  bits<4> src1_modifiers;
219  bits<9> src1;
220  bits<4> src2_modifiers;
221  bits<9> src2;
222  bits<1> clamp;
223
224  let Inst{7-0} = vdst;
225  let Inst{8} = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // neg_hi src0
226  let Inst{9} = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // neg_hi src1
227  let Inst{10} = !if(P.HasSrc2Mods, src2_modifiers{1}, 0); // neg_hi src2
228
229  let Inst{11} = !if(P.HasOpSel, src0_modifiers{2}, 0); // op_sel(0)
230  let Inst{12} = !if(P.HasOpSel, src1_modifiers{2}, 0); // op_sel(1)
231  let Inst{13} = !if(P.HasOpSel, src2_modifiers{2}, 0); // op_sel(2)
232
233  let Inst{14} = !if(P.HasOpSel, src2_modifiers{3}, 0); // op_sel_hi(2)
234
235  let Inst{15} = !if(P.HasClamp, clamp{0}, 0);
236
237  let Inst{25-16} = op;
238  let Inst{31-26} = 0x34; //encoding
239  let Inst{40-32} = !if(P.HasSrc0, src0, 0);
240  let Inst{49-41} = !if(P.HasSrc1, src1, 0);
241  let Inst{58-50} = !if(P.HasSrc2, src2, 0);
242  let Inst{59}    = !if(P.HasOpSel, src0_modifiers{3}, 0); // op_sel_hi(0)
243  let Inst{60}    = !if(P.HasOpSel, src1_modifiers{3}, 0); // op_sel_hi(1)
244  let Inst{61}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // neg (lo)
245  let Inst{62}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // neg (lo)
246  let Inst{63}    = !if(P.HasSrc2Mods, src2_modifiers{0}, 0); // neg (lo)
247}
248
249class VOP3be_si <bits<9> op, VOPProfile P> : VOP3be<P> {
250  let Inst{25-17} = op;
251}
252
253class VOP3be_vi <bits<10> op, VOPProfile P> : VOP3be<P> {
254  bits<1> clamp;
255  let Inst{25-16} = op;
256  let Inst{15}    = !if(P.HasClamp, clamp{0}, 0);
257}
258
259def SDWA {
260  // sdwa_sel
261  int BYTE_0 = 0;
262  int BYTE_1 = 1;
263  int BYTE_2 = 2;
264  int BYTE_3 = 3;
265  int WORD_0 = 4;
266  int WORD_1 = 5;
267  int DWORD = 6;
268
269  // dst_unused
270  int UNUSED_PAD = 0;
271  int UNUSED_SEXT = 1;
272  int UNUSED_PRESERVE = 2;
273}
274
275class VOP_SDWAe<VOPProfile P> : Enc64 {
276  bits<8> src0;
277  bits<3> src0_sel;
278  bits<2> src0_modifiers; // float: {abs,neg}, int {sext}
279  bits<3> src1_sel;
280  bits<2> src1_modifiers;
281  bits<3> dst_sel;
282  bits<2> dst_unused;
283  bits<1> clamp;
284
285  let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
286  let Inst{42-40} = !if(P.EmitDst, dst_sel{2-0}, SDWA.DWORD);
287  let Inst{44-43} = !if(P.EmitDst, dst_unused{1-0}, SDWA.UNUSED_PRESERVE);
288  let Inst{45}    = !if(P.HasSDWAClamp, clamp{0}, 0);
289  let Inst{50-48} = !if(P.HasSrc0, src0_sel{2-0}, SDWA.DWORD);
290  let Inst{53-52} = !if(P.HasSrc0FloatMods, src0_modifiers{1-0}, 0);
291  let Inst{51}    = !if(P.HasSrc0IntMods, src0_modifiers{0}, 0);
292  let Inst{58-56} = !if(P.HasSrc1, src1_sel{2-0}, SDWA.DWORD);
293  let Inst{61-60} = !if(P.HasSrc1FloatMods, src1_modifiers{1-0}, 0);
294  let Inst{59}    = !if(P.HasSrc1IntMods, src1_modifiers{0}, 0);
295}
296
297class VOP_SDWA_Pseudo <string opName, VOPProfile P, list<dag> pattern=[]> :
298  InstSI <P.OutsSDWA, P.InsSDWA, "", pattern>,
299  VOP <opName>,
300  SIMCInstr <opName#"_sdwa", SIEncodingFamily.NONE>,
301  MnemonicAlias <opName#"_sdwa", opName> {
302
303  let isPseudo = 1;
304  let isCodeGenOnly = 1;
305  let UseNamedOperandTable = 1;
306
307  string Mnemonic = opName;
308  string AsmOperands = P.AsmSDWA;
309
310  let Size = 8;
311  let mayLoad = 0;
312  let mayStore = 0;
313  let hasSideEffects = 0;
314
315  let VALU = 1;
316  let SDWA = 1;
317  let Uses = [EXEC];
318
319  let SubtargetPredicate = HasSDWA;
320  let AssemblerPredicate = !if(P.HasExt, HasSDWA, DisableInst);
321  let AsmVariantName = !if(P.HasExt, AMDGPUAsmVariants.SDWA,
322                                     AMDGPUAsmVariants.Disable);
323  let DecoderNamespace = "SDWA";
324
325  VOPProfile Pfl = P;
326}
327
328class VOP_SDWA_Real <VOP_SDWA_Pseudo ps> :
329  InstSI <ps.OutOperandList, ps.InOperandList, ps.Mnemonic # ps.AsmOperands, []>,
330  SIMCInstr <ps.PseudoInstr, SIEncodingFamily.VI> {
331
332  let isPseudo = 0;
333  let isCodeGenOnly = 0;
334
335  let Defs = ps.Defs;
336  let Uses = ps.Uses;
337  let SchedRW = ps.SchedRW;
338  let hasSideEffects = ps.hasSideEffects;
339
340  let Constraints     = ps.Constraints;
341  let DisableEncoding = ps.DisableEncoding;
342
343  // Copy relevant pseudo op flags
344  let SubtargetPredicate   = ps.SubtargetPredicate;
345  let AssemblerPredicate   = ps.AssemblerPredicate;
346  let AsmMatchConverter    = ps.AsmMatchConverter;
347  let AsmVariantName       = ps.AsmVariantName;
348  let UseNamedOperandTable = ps.UseNamedOperandTable;
349  let DecoderNamespace     = ps.DecoderNamespace;
350  let Constraints          = ps.Constraints;
351  let DisableEncoding      = ps.DisableEncoding;
352  let TSFlags              = ps.TSFlags;
353}
354
355class VOP_DPPe<VOPProfile P> : Enc64 {
356  bits<2> src0_modifiers;
357  bits<8> src0;
358  bits<2> src1_modifiers;
359  bits<9> dpp_ctrl;
360  bits<1> bound_ctrl;
361  bits<4> bank_mask;
362  bits<4> row_mask;
363
364  let Inst{39-32} = !if(P.HasSrc0, src0{7-0}, 0);
365  let Inst{48-40} = dpp_ctrl;
366  let Inst{51}    = bound_ctrl;
367  let Inst{52}    = !if(P.HasSrc0Mods, src0_modifiers{0}, 0); // src0_neg
368  let Inst{53}    = !if(P.HasSrc0Mods, src0_modifiers{1}, 0); // src0_abs
369  let Inst{54}    = !if(P.HasSrc1Mods, src1_modifiers{0}, 0); // src1_neg
370  let Inst{55}    = !if(P.HasSrc1Mods, src1_modifiers{1}, 0); // src1_abs
371  let Inst{59-56} = bank_mask;
372  let Inst{63-60} = row_mask;
373}
374
375class VOP_DPP <string OpName, VOPProfile P> :
376  InstSI <P.OutsDPP, P.InsDPP, OpName#P.AsmDPP, []>,
377  VOP_DPPe<P> {
378
379  let mayLoad = 0;
380  let mayStore = 0;
381  let hasSideEffects = 0;
382  let UseNamedOperandTable = 1;
383
384  let VALU = 1;
385  let DPP = 1;
386  let Size = 8;
387
388  let AsmMatchConverter = !if(!eq(P.HasModifiers,1), "cvtDPP", "");
389  let SubtargetPredicate = HasDPP;
390  let AssemblerPredicate = !if(P.HasExt, HasDPP, DisableInst);
391  let AsmVariantName = !if(P.HasExt, AMDGPUAsmVariants.DPP,
392                                     AMDGPUAsmVariants.Disable);
393  let DecoderNamespace = "DPP";
394}
395
396include "VOPCInstructions.td"
397include "VOP1Instructions.td"
398include "VOP2Instructions.td"
399include "VOP3Instructions.td"
400include "VOP3PInstructions.td"
401