1 //===- HexagonBaseInfo.h - Top level definitions for Hexagon ----*- C++ -*-===//
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 // This file contains small standalone helper functions and enum definitions for
10 // the Hexagon target useful for the compiler back-end and the MC libraries.
11 // As such, it deliberately does not include references to LLVM core
12 // code gen types, passes, etc..
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONBASEINFO_H
17 #define LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONBASEINFO_H
18 
19 #include "HexagonDepITypes.h"
20 #include "MCTargetDesc/HexagonMCTargetDesc.h"
21 
22 namespace llvm {
23 
24 /// HexagonII - This namespace holds all of the target specific flags that
25 /// instruction info tracks.
26 namespace HexagonII {
27   unsigned const TypeCVI_FIRST = TypeCVI_4SLOT_MPY;
28   unsigned const TypeCVI_LAST = TypeCVI_ZW;
29 
30   enum AddrMode {
31     NoAddrMode     = 0,  // No addressing mode
32     Absolute       = 1,  // Absolute addressing mode
33     AbsoluteSet    = 2,  // Absolute set addressing mode
34     BaseImmOffset  = 3,  // Indirect with offset
35     BaseLongOffset = 4,  // Indirect with long offset
36     BaseRegOffset  = 5,  // Indirect with register offset
37     PostInc        = 6   // Post increment addressing mode
38   };
39 
40   enum MemAccessSize {
41     NoMemAccess = 0,
42     ByteAccess,
43     HalfWordAccess,
44     WordAccess,
45     DoubleWordAccess,
46     HVXVectorAccess
47   };
48 
49   // MCInstrDesc TSFlags
50   // *** Must match HexagonInstrFormat*.td ***
51   enum {
52     // This 7-bit field describes the insn type.
53     TypePos = 0,
54     TypeMask = 0x7f,
55 
56     // Solo instructions.
57     SoloPos = 7,
58     SoloMask = 0x1,
59     // Packed only with A or X-type instructions.
60     SoloAXPos = 8,
61     SoloAXMask = 0x1,
62     // Only A-type instruction in first slot or nothing.
63     RestrictSlot1AOKPos = 9,
64     RestrictSlot1AOKMask = 0x1,
65 
66     // Predicated instructions.
67     PredicatedPos = 10,
68     PredicatedMask = 0x1,
69     PredicatedFalsePos = 11,
70     PredicatedFalseMask = 0x1,
71     PredicatedNewPos = 12,
72     PredicatedNewMask = 0x1,
73     PredicateLatePos = 13,
74     PredicateLateMask = 0x1,
75 
76     // New-Value consumer instructions.
77     NewValuePos = 14,
78     NewValueMask = 0x1,
79     // New-Value producer instructions.
80     hasNewValuePos = 15,
81     hasNewValueMask = 0x1,
82     // Which operand consumes or produces a new value.
83     NewValueOpPos = 16,
84     NewValueOpMask = 0x7,
85     // Stores that can become new-value stores.
86     mayNVStorePos = 19,
87     mayNVStoreMask = 0x1,
88     // New-value store instructions.
89     NVStorePos = 20,
90     NVStoreMask = 0x1,
91     // Loads that can become current-value loads.
92     mayCVLoadPos = 21,
93     mayCVLoadMask = 0x1,
94     // Current-value load instructions.
95     CVLoadPos = 22,
96     CVLoadMask = 0x1,
97 
98     // Extendable insns.
99     ExtendablePos = 23,
100     ExtendableMask = 0x1,
101     // Insns must be extended.
102     ExtendedPos = 24,
103     ExtendedMask = 0x1,
104     // Which operand may be extended.
105     ExtendableOpPos = 25,
106     ExtendableOpMask = 0x7,
107     // Signed or unsigned range.
108     ExtentSignedPos = 28,
109     ExtentSignedMask = 0x1,
110     // Number of bits of range before extending operand.
111     ExtentBitsPos = 29,
112     ExtentBitsMask = 0x1f,
113     // Alignment power-of-two before extending operand.
114     ExtentAlignPos = 34,
115     ExtentAlignMask = 0x3,
116 
117     CofMax1Pos = 36,
118     CofMax1Mask = 0x1,
119     CofRelax1Pos = 37,
120     CofRelax1Mask = 0x1,
121     CofRelax2Pos = 38,
122     CofRelax2Mask = 0x1,
123 
124     RestrictNoSlot1StorePos = 39,
125     RestrictNoSlot1StoreMask = 0x1,
126 
127     // Addressing mode for load/store instructions.
128     AddrModePos = 40,
129     AddrModeMask = 0x7,
130     // Access size for load/store instructions.
131     MemAccessSizePos = 43,
132     MemAccesSizeMask = 0xf,
133 
134     // Branch predicted taken.
135     TakenPos = 47,
136     TakenMask = 0x1,
137 
138     // Floating-point instructions.
139     FPPos = 48,
140     FPMask = 0x1,
141 
142     // New-Value producer-2 instructions.
143     hasNewValuePos2 = 50,
144     hasNewValueMask2 = 0x1,
145     // Which operand consumes or produces a new value.
146     NewValueOpPos2 = 51,
147     NewValueOpMask2 = 0x7,
148 
149     // Accumulator instructions.
150     AccumulatorPos = 54,
151     AccumulatorMask = 0x1,
152 
153     // Complex XU, prevent xu competition by preferring slot3
154     PrefersSlot3Pos = 55,
155     PrefersSlot3Mask = 0x1,
156 
157     HasHvxTmpPos = 56,
158     HasHvxTmpMask = 0x1,
159 
160     CVINewPos = 58,
161     CVINewMask = 0x1,
162 
163     isCVIPos = 59,
164     isCVIMask = 0x1,
165 
166     isHVXALUPos = 60,
167     isHVXALUMask = 0x1,
168 
169     isHVXALU2SRCPos = 61,
170     isHVXALU2SRCMask = 0x1,
171 
172     hasUnaryRestrictionPos = 62,
173     hasUnaryRestrictionMask = 0x1,
174   };
175 
176   // *** The code above must match HexagonInstrFormat*.td *** //
177 
178   // Hexagon specific MO operand flag mask.
179   enum HexagonMOTargetFlagVal {
180     // Hexagon-specific MachineOperand target flags.
181     //
182     // When changing these, make sure to update
183     // getSerializableDirectMachineOperandTargetFlags and
184     // getSerializableBitmaskMachineOperandTargetFlags if needed.
185     MO_NO_FLAG,
186 
187     /// MO_PCREL - On a symbol operand, indicates a PC-relative relocation
188     /// Used for computing a global address for PIC compilations
189     MO_PCREL,
190 
191     /// MO_GOT - Indicates a GOT-relative relocation
192     MO_GOT,
193 
194     // Low or high part of a symbol.
195     MO_LO16,
196     MO_HI16,
197 
198     // Offset from the base of the SDA.
199     MO_GPREL,
200 
201     // MO_GDGOT - indicates GOT relative relocation for TLS
202     // GeneralDynamic method
203     MO_GDGOT,
204 
205     // MO_GDPLT - indicates PLT relative relocation for TLS
206     // GeneralDynamic method
207     MO_GDPLT,
208 
209     // MO_IE - indicates non PIC relocation for TLS
210     // Initial Executable method
211     MO_IE,
212 
213     // MO_IEGOT - indicates PIC relocation for TLS
214     // Initial Executable method
215     MO_IEGOT,
216 
217     // MO_TPREL - indicates relocation for TLS
218     // local Executable method
219     MO_TPREL,
220 
221     // HMOTF_ConstExtended
222     // Addendum to above, indicates a const extended op
223     // Can be used as a mask.
224     HMOTF_ConstExtended = 0x80,
225 
226     // Union of all bitmasks (currently only HMOTF_ConstExtended).
227     MO_Bitmasks = HMOTF_ConstExtended
228   };
229 
230   // Hexagon Sub-instruction classes.
231   enum SubInstructionGroup {
232     HSIG_None = 0,
233     HSIG_L1,
234     HSIG_L2,
235     HSIG_S1,
236     HSIG_S2,
237     HSIG_A,
238     HSIG_Compound
239   };
240 
241   // Hexagon Compound classes.
242   enum CompoundGroup {
243     HCG_None = 0,
244     HCG_A,
245     HCG_B,
246     HCG_C
247   };
248 
249   enum InstParseBits {
250     INST_PARSE_MASK       = 0x0000c000,
251     INST_PARSE_PACKET_END = 0x0000c000,
252     INST_PARSE_LOOP_END   = 0x00008000,
253     INST_PARSE_NOT_END    = 0x00004000,
254     INST_PARSE_DUPLEX     = 0x00000000,
255     INST_PARSE_EXTENDER   = 0x00000000
256   };
257 
258   enum InstIClassBits : unsigned {
259     INST_ICLASS_MASK      = 0xf0000000,
260     INST_ICLASS_EXTENDER  = 0x00000000,
261     INST_ICLASS_J_1       = 0x10000000,
262     INST_ICLASS_J_2       = 0x20000000,
263     INST_ICLASS_LD_ST_1   = 0x30000000,
264     INST_ICLASS_LD_ST_2   = 0x40000000,
265     INST_ICLASS_J_3       = 0x50000000,
266     INST_ICLASS_CR        = 0x60000000,
267     INST_ICLASS_ALU32_1   = 0x70000000,
268     INST_ICLASS_XTYPE_1   = 0x80000000,
269     INST_ICLASS_LD        = 0x90000000,
270     INST_ICLASS_ST        = 0xa0000000,
271     INST_ICLASS_ALU32_2   = 0xb0000000,
272     INST_ICLASS_XTYPE_2   = 0xc0000000,
273     INST_ICLASS_XTYPE_3   = 0xd0000000,
274     INST_ICLASS_XTYPE_4   = 0xe0000000,
275     INST_ICLASS_ALU32_3   = 0xf0000000
276   };
277 
278   LLVM_ATTRIBUTE_UNUSED
279   static unsigned getMemAccessSizeInBytes(MemAccessSize S) {
280     switch (S) {
281       case ByteAccess:        return 1;
282       case HalfWordAccess:    return 2;
283       case WordAccess:        return 4;
284       case DoubleWordAccess:  return 8;
285       default:                return 0;
286     }
287   }
288 } // end namespace HexagonII
289 
290 } // end namespace llvm
291 
292 #endif // LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONBASEINFO_H
293