LLVM  3.7.0
HexagonMCInstrInfo.h
Go to the documentation of this file.
1 //===- HexagonMCInstrInfo.cpp - Utility functions on Hexagon MCInsts ------===//
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 // Utility functions for Hexagon specific MCInst queries
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCINSTRINFO_H
15 #define LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCINSTRINFO_H
16 
17 #include "llvm/MC/MCInst.h"
18 
19 namespace llvm {
20 class MCContext;
21 class MCInstrDesc;
22 class MCInstrInfo;
23 class MCInst;
24 class MCOperand;
25 class MCSubtargetInfo;
26 namespace HexagonII {
27 enum class MemAccessSize;
28 }
30 public:
32  DuplexCandidate(unsigned i, unsigned j, unsigned iClass)
33  : packetIndexI(i), packetIndexJ(j), iClass(iClass) {}
34 };
35 namespace HexagonMCInstrInfo {
36 size_t const innerLoopOffset = 0;
37 int64_t const innerLoopMask = 1 << innerLoopOffset;
38 
39 size_t const outerLoopOffset = 1;
40 int64_t const outerLoopMask = 1 << outerLoopOffset;
41 
42 size_t const bundleInstructionsOffset = 1;
43 
44 // Returns a iterator range of instructions in this bundle
46 
47 // Returns the number of instructions in the bundle
48 size_t bundleSize(MCInst const &MCI);
49 
50 // Clamp off upper 26 bits of extendable operand for emission
51 void clampExtended(MCInstrInfo const &MCII, MCInst &MCI);
52 
53 // Create a duplex instruction given the two subinsts
54 MCInst *deriveDuplex(MCContext &Context, unsigned iClass, MCInst const &inst0,
55  MCInst const &inst1);
56 
57 // Convert this instruction in to a duplex subinst
58 MCInst deriveSubInst(MCInst const &Inst);
59 
60 // Return the extender for instruction at Index or nullptr if none
61 MCInst const *extenderForIndex(MCInst const &MCB, size_t Index);
62 
63 // Return memory access size
65  MCInst const &MCI);
66 
67 // Return number of bits in the constant extended operand.
68 unsigned getBitCount(MCInstrInfo const &MCII, MCInst const &MCI);
69 
70 // Return constant extended operand number.
71 unsigned short getCExtOpNum(MCInstrInfo const &MCII, MCInst const &MCI);
72 
73 MCInstrDesc const &getDesc(MCInstrInfo const &MCII, MCInst const &MCI);
74 
75 // Return which duplex group this instruction belongs to
76 unsigned getDuplexCandidateGroup(MCInst const &MI);
77 
78 // Return a list of all possible instruction duplex combinations
80  MCInst const &MCB);
81 
82 // Return the index of the extendable operand
83 unsigned short getExtendableOp(MCInstrInfo const &MCII, MCInst const &MCI);
84 
85 // Return a reference to the extendable operand
86 MCOperand const &getExtendableOperand(MCInstrInfo const &MCII,
87  MCInst const &MCI);
88 
89 // Return the implicit alignment of the extendable operand
90 unsigned getExtentAlignment(MCInstrInfo const &MCII, MCInst const &MCI);
91 
92 // Return the number of logical bits of the extendable operand
93 unsigned getExtentBits(MCInstrInfo const &MCII, MCInst const &MCI);
94 
95 // Return the max value that a constant extendable operand can have
96 // without being extended.
97 int getMaxValue(MCInstrInfo const &MCII, MCInst const &MCI);
98 
99 // Return the min value that a constant extendable operand can have
100 // without being extended.
101 int getMinValue(MCInstrInfo const &MCII, MCInst const &MCI);
102 
103 // Return instruction name
104 char const *getName(MCInstrInfo const &MCII, MCInst const &MCI);
105 
106 // Return the operand index for the new value.
107 unsigned short getNewValueOp(MCInstrInfo const &MCII, MCInst const &MCI);
108 
109 // Return the operand that consumes or produces a new value.
110 MCOperand const &getNewValueOperand(MCInstrInfo const &MCII, MCInst const &MCI);
111 
112 int getSubTarget(MCInstrInfo const &MCII, MCInst const &MCI);
113 
114 // Return the Hexagon ISA class for the insn.
115 unsigned getType(MCInstrInfo const &MCII, MCInst const &MCI);
116 
117 /// Return the slots used by the insn.
118 unsigned getUnits(MCInstrInfo const &MCII, MCSubtargetInfo const &STI,
119  MCInst const &MCI);
120 
121 // Does the packet have an extender for the instruction at Index
122 bool hasExtenderForIndex(MCInst const &MCB, size_t Index);
123 
124 bool hasImmExt(MCInst const &MCI);
125 
126 // Return whether the instruction is a legal new-value producer.
127 bool hasNewValue(MCInstrInfo const &MCII, MCInst const &MCI);
128 
129 // Return the instruction at Index
130 MCInst const &instruction(MCInst const &MCB, size_t Index);
131 
132 // Returns whether this MCInst is a wellformed bundle
133 bool isBundle(MCInst const &MCI);
134 
135 // Return whether the insn is an actual insn.
136 bool isCanon(MCInstrInfo const &MCII, MCInst const &MCI);
137 
138 // Return the duplex iclass given the two duplex classes
139 unsigned iClassOfDuplexPair(unsigned Ga, unsigned Gb);
140 
141 // Return whether the instruction needs to be constant extended.
142 bool isConstExtended(MCInstrInfo const &MCII, MCInst const &MCI);
143 
144 // Is this double register suitable for use in a duplex subinst
145 bool isDblRegForSubInst(unsigned Reg);
146 
147 // Is this a duplex instruction
148 bool isDuplex(MCInstrInfo const &MCII, MCInst const &MCI);
149 
150 // Can these instructions be duplexed
151 bool isDuplexPair(MCInst const &MIa, MCInst const &MIb);
152 
153 // Can these duplex classes be combine in to a duplex instruction
154 bool isDuplexPairMatch(unsigned Ga, unsigned Gb);
155 
156 // Return true if the insn may be extended based on the operand value.
157 bool isExtendable(MCInstrInfo const &MCII, MCInst const &MCI);
158 
159 // Return whether the instruction must be always extended.
160 bool isExtended(MCInstrInfo const &MCII, MCInst const &MCI);
161 
162 /// Return whether it is a floating-point insn.
163 bool isFloat(MCInstrInfo const &MCII, MCInst const &MCI);
164 
165 // Returns whether this instruction is an immediate extender
166 bool isImmext(MCInst const &MCI);
167 
168 // Returns whether this bundle is an endloop0
169 bool isInnerLoop(MCInst const &MCI);
170 
171 // Is this an integer register
172 bool isIntReg(unsigned Reg);
173 
174 // Is this register suitable for use in a duplex subinst
175 bool isIntRegForSubInst(unsigned Reg);
176 
177 // Return whether the insn is a new-value consumer.
178 bool isNewValue(MCInstrInfo const &MCII, MCInst const &MCI);
179 
180 // Return true if the operand can be constant extended.
181 bool isOperandExtended(MCInstrInfo const &MCII, MCInst const &MCI,
182  unsigned short OperandNum);
183 
184 // Can these two instructions be duplexed
185 bool isOrderedDuplexPair(MCInstrInfo const &MCII, MCInst const &MIa,
186  bool ExtendedA, MCInst const &MIb, bool ExtendedB,
187  bool bisReversable);
188 
189 // Returns whether this bundle is an endloop1
190 bool isOuterLoop(MCInst const &MCI);
191 
192 // Return whether this instruction is predicated
193 bool isPredicated(MCInstrInfo const &MCII, MCInst const &MCI);
194 
195 // Return whether the predicate sense is true
196 bool isPredicatedTrue(MCInstrInfo const &MCII, MCInst const &MCI);
197 
198 // Is this a predicate register
199 bool isPredReg(unsigned Reg);
200 
201 // Return whether the insn is a prefix.
202 bool isPrefix(MCInstrInfo const &MCII, MCInst const &MCI);
203 
204 // Return whether the insn is solo, i.e., cannot be in a packet.
205 bool isSolo(MCInstrInfo const &MCII, MCInst const &MCI);
206 
207 /// Return whether the insn can be packaged only with A and X-type insns.
208 bool isSoloAX(MCInstrInfo const &MCII, MCInst const &MCI);
209 
210 /// Return whether the insn can be packaged only with an A-type insn in slot #1.
211 bool isSoloAin1(MCInstrInfo const &MCII, MCInst const &MCI);
212 
213 // Pad the bundle with nops to satisfy endloop requirements
214 void padEndloop(MCInst &MCI);
215 
216 bool prefersSlot3(MCInstrInfo const &MCII, MCInst const &MCI);
217 
218 // Replace the instructions inside MCB, represented by Candidate
219 void replaceDuplex(MCContext &Context, MCInst &MCB, DuplexCandidate Candidate);
220 
221 // Marks a bundle as endloop0
222 void setInnerLoop(MCInst &MCI);
223 
224 // Marks a bundle as endloop1
225 void setOuterLoop(MCInst &MCI);
226 
227 // Would duplexing this instruction create a requirement to extend
228 bool subInstWouldBeExtended(MCInst const &potentialDuplex);
229 
230 // Attempt to find and replace compound pairs
231 void tryCompound(MCInstrInfo const &MCII, MCContext &Context, MCInst &MCI);
232 }
233 }
234 
235 #endif // LLVM_LIB_TARGET_HEXAGON_MCTARGETDESC_HEXAGONMCINSTRINFO_H
bool isSoloAin1(MCInstrInfo const &MCII, MCInst const &MCI)
Return whether the insn can be packaged only with an A-type insn in slot #1.
bool isDuplex(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned short getNewValueOp(MCInstrInfo const &MCII, MCInst const &MCI)
bool subInstWouldBeExtended(MCInst const &potentialDuplex)
MCInst const * extenderForIndex(MCInst const &MCB, size_t Index)
unsigned getBitCount(MCInstrInfo const &MCII, MCInst const &MCI)
void tryCompound(MCInstrInfo const &MCII, MCContext &Context, MCInst &MCI)
tryCompound - Given a bundle check for compound insns when one is found update the contents fo the bu...
bool isDuplexPair(MCInst const &MIa, MCInst const &MIb)
Symmetrical. See if these two instructions are fit for duplex pair.
void clampExtended(MCInstrInfo const &MCII, MCInst &MCI)
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:138
bool isIntRegForSubInst(unsigned Reg)
bool isBundle(MCInst const &MCI)
bool isSolo(MCInstrInfo const &MCII, MCInst const &MCI)
bool isDblRegForSubInst(unsigned Reg)
bool isOuterLoop(MCInst const &MCI)
bool isNewValue(MCInstrInfo const &MCII, MCInst const &MCI)
bool isImmext(MCInst const &MCI)
MCInst const & instruction(MCInst const &MCB, size_t Index)
Reg
All possible values of the reg field in the ModR/M byte.
DuplexCandidate(unsigned i, unsigned j, unsigned iClass)
void replaceDuplex(MCContext &Context, MCInst &MCB, DuplexCandidate Candidate)
Context object for machine code objects.
Definition: MCContext.h:48
bool isOperandExtended(MCInstrInfo const &MCII, MCInst const &MCI, unsigned short OperandNum)
int getMaxValue(MCInstrInfo const &MCII, MCInst const &MCI)
SmallVector< DuplexCandidate, 8 > getDuplexPossibilties(MCInstrInfo const &MCII, MCInst const &MCB)
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:150
bool isPrefix(MCInstrInfo const &MCII, MCInst const &MCI)
bool isDuplexPairMatch(unsigned Ga, unsigned Gb)
int getMinValue(MCInstrInfo const &MCII, MCInst const &MCI)
char const * getName(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned getDuplexCandidateGroup(MCInst const &MI)
Interface to description of machine instruction set.
Definition: MCInstrInfo.h:24
iterator_range< MCInst::const_iterator > bundleInstructions(MCInst const &MCI)
bool prefersSlot3(MCInstrInfo const &MCII, MCInst const &MCI)
bool isCanon(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned short getExtendableOp(MCInstrInfo const &MCII, MCInst const &MCI)
size_t const bundleInstructionsOffset
bool isExtendable(MCInstrInfo const &MCII, MCInst const &MCI)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
HexagonII::MemAccessSize getAccessSize(MCInstrInfo const &MCII, MCInst const &MCI)
bool isOrderedDuplexPair(MCInstrInfo const &MCII, MCInst const &MIa, bool ExtendedA, MCInst const &MIb, bool ExtendedB, bool bisReversable)
non-Symmetrical. See if these two instructions are fit for duplex pair.
A range adaptor for a pair of iterators.
bool isPredicated(MCInstrInfo const &MCII, MCInst const &MCI)
bool isExtended(MCInstrInfo const &MCII, MCInst const &MCI)
MCInst deriveSubInst(MCInst const &Inst)
bool isSoloAX(MCInstrInfo const &MCII, MCInst const &MCI)
Return whether the insn can be packaged only with A and X-type insns.
bool hasExtenderForIndex(MCInst const &MCB, size_t Index)
MCSubtargetInfo - Generic base class for all target subtargets.
MCInstrDesc const & getDesc(MCInstrInfo const &MCII, MCInst const &MCI)
size_t bundleSize(MCInst const &MCI)
int getSubTarget(MCInstrInfo const &MCII, MCInst const &MCI)
bool hasImmExt(MCInst const &MCI)
bool isInnerLoop(MCInst const &MCI)
bool isFloat(MCInstrInfo const &MCII, MCInst const &MCI)
Return whether it is a floating-point insn.
unsigned getUnits(MCInstrInfo const &MCII, MCSubtargetInfo const &STI, MCInst const &MCI)
Return the slots used by the insn.
bool isConstExtended(MCInstrInfo const &MCII, MCInst const &MCI)
MCInst * deriveDuplex(MCContext &Context, unsigned iClass, MCInst const &inst0, MCInst const &inst1)
bool hasNewValue(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned getType(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned getExtentAlignment(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned short getCExtOpNum(MCInstrInfo const &MCII, MCInst const &MCI)
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:33
unsigned iClassOfDuplexPair(unsigned Ga, unsigned Gb)
bool isPredicatedTrue(MCInstrInfo const &MCII, MCInst const &MCI)
MCOperand const & getExtendableOperand(MCInstrInfo const &MCII, MCInst const &MCI)
MCOperand const & getNewValueOperand(MCInstrInfo const &MCII, MCInst const &MCI)
unsigned getExtentBits(MCInstrInfo const &MCII, MCInst const &MCI)