1//==- HexagonInstrFormats.td - Hexagon Instruction Formats --*- tablegen -*-==//
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// Addressing modes for load/store instructions
10class AddrModeType<bits<3> value> {
11  bits<3> Value = value;
12}
13
14def NoAddrMode     : AddrModeType<0>;  // No addressing mode
15def Absolute       : AddrModeType<1>;  // Absolute addressing mode
16def AbsoluteSet    : AddrModeType<2>;  // Absolute set addressing mode
17def BaseImmOffset  : AddrModeType<3>;  // Indirect with offset
18def BaseLongOffset : AddrModeType<4>;  // Indirect with long offset
19def BaseRegOffset  : AddrModeType<5>;  // Indirect with register offset
20def PostInc        : AddrModeType<6>;  // Post increment addressing mode
21
22class MemAccessSize<bits<4> value> {
23  bits<4> Value = value;
24}
25
26// These numbers must match the MemAccessSize enumeration values in
27// HexagonBaseInfo.h.
28def NoMemAccess      : MemAccessSize<0>;
29def ByteAccess       : MemAccessSize<1>;
30def HalfWordAccess   : MemAccessSize<2>;
31def WordAccess       : MemAccessSize<3>;
32def DoubleWordAccess : MemAccessSize<4>;
33def HVXVectorAccess  : MemAccessSize<5>;
34
35
36//===----------------------------------------------------------------------===//
37//                         Instruction Class Declaration +
38//===----------------------------------------------------------------------===//
39
40// "Parse" bits are explicitly NOT defined in the opcode space to prevent
41//  TableGen from using them for generation of the decoder tables.
42class OpcodeHexagon {
43  field bits<32> Inst = ?; // Default to an invalid insn.
44  bits<4> IClass = 0; // ICLASS
45  bits<1> zero = 0;
46
47  let Inst{31-28} = IClass;
48}
49
50class InstHexagon<dag outs, dag ins, string asmstr, list<dag> pattern,
51                  string cstr, InstrItinClass itin, IType type>
52  : Instruction {
53  let Namespace = "Hexagon";
54
55  dag OutOperandList = outs;
56  dag InOperandList = ins;
57  let AsmString = asmstr;
58  let Pattern = pattern;
59  let Constraints = cstr;
60  let Itinerary = itin;
61  let Size = 4;
62
63  // SoftFail is a field the disassembler can use to provide a way for
64  // instructions to not match without killing the whole decode process. It is
65  // mainly used for ARM, but Tablegen expects this field to exist or it fails
66  // to build the decode table.
67  field bits<32> SoftFail = 0;
68
69  // *** Must match MCTargetDesc/HexagonBaseInfo.h ***
70
71  // Instruction type according to the ISA.
72  IType Type = type;
73  let TSFlags{6-0} = Type.Value;
74
75  // Solo instructions, i.e., those that cannot be in a packet with others.
76  bits<1> isSolo = 0;
77  let TSFlags{7} = isSolo;
78  // Packed only with A or X-type instructions.
79  bits<1> isSoloAX = 0;
80  let TSFlags{8} = isSoloAX;
81  // Restricts slot 1 to ALU-only instructions.
82  bits<1> isRestrictSlot1AOK = 0;
83  let TSFlags{9} = isRestrictSlot1AOK;
84
85  // Predicated instructions.
86  bits<1> isPredicated = 0;
87  let TSFlags{10} = isPredicated;
88  bits<1> isPredicatedFalse = 0;
89  let TSFlags{11} = isPredicatedFalse;
90  bits<1> isPredicatedNew = 0;
91  let TSFlags{12} = isPredicatedNew;
92  bits<1> isPredicateLate = 0;
93  let TSFlags{13} = isPredicateLate; // Late predicate producer insn.
94
95  // New-value insn helper fields.
96  bits<1> isNewValue = 0;
97  let TSFlags{14} = isNewValue; // New-value consumer insn.
98  bits<1> hasNewValue = 0;
99  let TSFlags{15} = hasNewValue; // New-value producer insn.
100  bits<3> opNewValue = 0;
101  let TSFlags{18-16} = opNewValue; // New-value produced operand.
102  bits<1> isNVStorable = 0;
103  let TSFlags{19} = isNVStorable; // Store that can become new-value store.
104  bits<1> isNVStore = 0;
105  let TSFlags{20} = isNVStore; // New-value store insn.
106  bits<1> isCVLoadable = 0;
107  let TSFlags{21} = isCVLoadable; // Load that can become cur-value load.
108  bits<1> isCVLoad = 0;
109  let TSFlags{22} = isCVLoad; // Cur-value load insn.
110
111  // Immediate extender helper fields.
112  bits<1> isExtendable = 0;
113  let TSFlags{23} = isExtendable; // Insn may be extended.
114  bits<1> isExtended = 0;
115  let TSFlags{24} = isExtended; // Insn must be extended.
116  bits<3> opExtendable = 0;
117  let TSFlags{27-25} = opExtendable; // Which operand may be extended.
118  bits<1> isExtentSigned = 0;
119  let TSFlags{28} = isExtentSigned; // Signed or unsigned range.
120  bits<5> opExtentBits = 0;
121  let TSFlags{33-29} = opExtentBits; //Number of bits of range before extending.
122  bits<2> opExtentAlign = 0;
123  let TSFlags{35-34} = opExtentAlign; // Alignment exponent before extending.
124
125  bit cofMax1 = 0;
126  let TSFlags{36} = cofMax1;
127  bit cofRelax1 = 0;
128  let TSFlags{37} = cofRelax1;
129  bit cofRelax2 = 0;
130  let TSFlags{38} = cofRelax2;
131
132  bit isRestrictNoSlot1Store = 0;
133  let TSFlags{39} = isRestrictNoSlot1Store;
134
135  // Addressing mode for load/store instructions.
136  AddrModeType addrMode = NoAddrMode;
137  let TSFlags{42-40} = addrMode.Value;
138
139  // Memory access size for mem access instructions (load/store)
140  MemAccessSize accessSize = NoMemAccess;
141  let TSFlags{46-43} = accessSize.Value;
142
143  bits<1> isTaken = 0;
144  let TSFlags {47} = isTaken; // Branch prediction.
145
146  bits<1> isFP = 0;
147  let TSFlags {48} = isFP; // Floating-point.
148
149  bits<1> hasNewValue2 = 0;
150  let TSFlags{50} = hasNewValue2; // Second New-value producer insn.
151  bits<3> opNewValue2 = 0;
152  let TSFlags{53-51} = opNewValue2; // Second New-value produced operand.
153
154  bits<1> isAccumulator = 0;
155  let TSFlags{54} = isAccumulator;
156
157  bits<1> prefersSlot3 = 0;
158  let TSFlags{55} = prefersSlot3; // Complex XU
159
160  bits<1> hasHvxTmp = 0;
161  let TSFlags{56} = hasHvxTmp;  // vector register vX.tmp false-write
162
163  bit CVINew = 0;
164  let TSFlags{58} = CVINew;
165
166  bit isCVI = 0;
167  let TSFlags{59} = isCVI;
168
169  bit isHVXALU = 0;
170  let TSFlags{60} = isHVXALU;
171
172  bit isHVXALU2SRC = 0;
173  let TSFlags{61} = isHVXALU2SRC;
174
175  bit hasUnaryRestriction = 0;
176  let TSFlags{62} = hasUnaryRestriction;
177
178  // Fields used for relation models.
179  bit isNonTemporal = 0;
180  string isNT = ""; // set to "true" for non-temporal vector stores.
181  string BaseOpcode = "";
182  string CextOpcode = "";
183  string PredSense = "";
184  string PNewValue = "";
185  string NValueST  = "";    // Set to "true" for new-value stores.
186  string InputType = "";    // Input is "imm" or "reg" type.
187  string isFloat = "false"; // Set to "true" for the floating-point load/store.
188  string isBrTaken = !if(isTaken, "true", "false"); // Set to "true"/"false" for jump instructions
189
190  let PredSense = !if(isPredicated, !if(isPredicatedFalse, "false", "true"),
191                                    "");
192  let PNewValue = !if(isPredicatedNew, "new", "");
193  let NValueST = !if(isNVStore, "true", "false");
194  let isNT = !if(isNonTemporal, "true", "false");
195
196  let hasSideEffects = 0;
197  // *** Must match MCTargetDesc/HexagonBaseInfo.h ***
198}
199
200class HInst<dag outs, dag ins, string asmstr, InstrItinClass itin, IType type> :
201      InstHexagon<outs, ins, asmstr, [], "", itin, type>;
202
203//===----------------------------------------------------------------------===//
204//                         Instruction Classes Definitions +
205//===----------------------------------------------------------------------===//
206
207let mayLoad = 1 in
208class LDInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
209             string cstr = "", InstrItinClass itin = LD_tc_ld_SLOT01>
210  : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeLD>, OpcodeHexagon;
211
212class CONSTLDInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
213             string cstr = "", InstrItinClass itin = LD_tc_ld_SLOT01>
214  : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeLD>, OpcodeHexagon;
215
216let mayStore = 1 in
217class STInst<dag outs, dag ins, string asmstr, list<dag> pattern = [],
218             string cstr = "", InstrItinClass itin = ST_tc_st_SLOT01>
219  : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeST>, OpcodeHexagon;
220
221let isCodeGenOnly = 1, isPseudo = 1 in
222class Endloop<dag outs, dag ins, string asmstr, list<dag> pattern = [],
223              string cstr = "", InstrItinClass itin = tc_ENDLOOP>
224  : InstHexagon<outs, ins, asmstr, pattern, cstr, itin, TypeENDLOOP>,
225    OpcodeHexagon;
226
227let isCodeGenOnly = 1, isPseudo = 1 in
228class Pseudo<dag outs, dag ins, string asmstr, list<dag> pattern = [],
229             string cstr = "">
230  : InstHexagon<outs, ins, asmstr, pattern, cstr, PSEUDO, TypePSEUDO>,
231    OpcodeHexagon;
232
233let isCodeGenOnly = 1, isPseudo = 1 in
234class PseudoM<dag outs, dag ins, string asmstr, list<dag> pattern = [],
235              string cstr="">
236  : InstHexagon<outs, ins, asmstr, pattern, cstr, PSEUDOM, TypePSEUDO>,
237    OpcodeHexagon;
238
239//===----------------------------------------------------------------------===//
240//                         Special Instructions -
241//===----------------------------------------------------------------------===//
242
243// The 'invalid_decode' instruction is used by the disassembler to
244// show an instruction that didn't decode correctly.  This feature
245// is only leveraged in a special disassembler mode that's activated
246// by a command line flag.
247def tc_invalid : InstrItinClass;
248class Enc_invalid : OpcodeHexagon {
249}
250def invalid_decode : HInst<
251(outs ),
252(ins ),
253"<invalid>",
254tc_invalid, TypeALU32_2op>, Enc_invalid {
255let Inst{13-0} = 0b00000000000000;
256let Inst{31-16} = 0b0000000000000000;
257let isCodeGenOnly = 1;
258}
259
260//===----------------------------------------------------------------------===//
261//                      Duplex Instruction Class Declaration
262//===----------------------------------------------------------------------===//
263
264class OpcodeDuplex {
265  field bits<32> Inst = ?; // Default to an invalid insn.
266  bits<4> IClass = 0; // ICLASS
267  bits<13> ISubHi = 0; // Low sub-insn
268  bits<13> ISubLo = 0; // High sub-insn
269
270  let Inst{31-29} = IClass{3-1};
271  let Inst{13}    = IClass{0};
272  let Inst{15-14} = 0;
273  let Inst{28-16} = ISubHi;
274  let Inst{12-0}  = ISubLo;
275}
276
277class InstDuplex<bits<4> iClass, string cstr = ""> : Instruction,
278                                                     OpcodeDuplex {
279  let Namespace = "Hexagon";
280  IType Type = TypeDUPLEX;  // uses slot 0,1
281  let isCodeGenOnly = 1;
282  let hasSideEffects = 0;
283  dag OutOperandList = (outs);
284  dag InOperandList = (ins);
285  let IClass = iClass;
286  let Constraints = cstr;
287  let Itinerary = DUPLEX;
288  let Size = 4;
289
290  // SoftFail is a field the disassembler can use to provide a way for
291  // instructions to not match without killing the whole decode process. It is
292  // mainly used for ARM, but Tablegen expects this field to exist or it fails
293  // to build the decode table.
294  field bits<32> SoftFail = 0;
295
296  // *** Must match MCTargetDesc/HexagonBaseInfo.h ***
297
298  let TSFlags{6-0} = Type.Value;
299
300  // Predicated instructions.
301  bits<1> isPredicated = 0;
302  let TSFlags{7} = isPredicated;
303  bits<1> isPredicatedFalse = 0;
304  let TSFlags{8} = isPredicatedFalse;
305  bits<1> isPredicatedNew = 0;
306  let TSFlags{9} = isPredicatedNew;
307
308  // New-value insn helper fields.
309  bits<1> isNewValue = 0;
310  let TSFlags{10} = isNewValue; // New-value consumer insn.
311  bits<1> hasNewValue = 0;
312  let TSFlags{11} = hasNewValue; // New-value producer insn.
313  bits<3> opNewValue = 0;
314  let TSFlags{14-12} = opNewValue; // New-value produced operand.
315  bits<1> isNVStorable = 0;
316  let TSFlags{15} = isNVStorable; // Store that can become new-value store.
317  bits<1> isNVStore = 0;
318  let TSFlags{16} = isNVStore; // New-value store insn.
319
320  // Immediate extender helper fields.
321  bits<1> isExtendable = 0;
322  let TSFlags{17} = isExtendable; // Insn may be extended.
323  bits<1> isExtended = 0;
324  let TSFlags{18} = isExtended; // Insn must be extended.
325  bits<3> opExtendable = 0;
326  let TSFlags{21-19} = opExtendable; // Which operand may be extended.
327  bits<1> isExtentSigned = 0;
328  let TSFlags{22} = isExtentSigned; // Signed or unsigned range.
329  bits<5> opExtentBits = 0;
330  let TSFlags{27-23} = opExtentBits; //Number of bits of range before extending.
331  bits<2> opExtentAlign = 0;
332  let TSFlags{29-28} = opExtentAlign; // Alignment exponent before extending.
333}
334
335//===----------------------------------------------------------------------===//
336//                         Instruction Classes Definitions -
337//===----------------------------------------------------------------------===//
338
339include "HexagonInstrFormatsV60.td"
340include "HexagonInstrFormatsV65.td"
341