1 | //===- llvm/CodeGen/MachineInstrBundle.h - MI bundle utilities --*- 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 provide utility functions to manipulate machine instruction |
10 | // bundles. |
11 | // |
12 | //===----------------------------------------------------------------------===// |
13 | |
14 | #ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLE_H |
15 | #define LLVM_CODEGEN_MACHINEINSTRBUNDLE_H |
16 | |
17 | #include "llvm/CodeGen/MachineBasicBlock.h" |
18 | |
19 | namespace llvm { |
20 | |
21 | /// finalizeBundle - Finalize a machine instruction bundle which includes |
22 | /// a sequence of instructions starting from FirstMI to LastMI (exclusive). |
23 | /// This routine adds a BUNDLE instruction to represent the bundle, it adds |
24 | /// IsInternalRead markers to MachineOperands which are defined inside the |
25 | /// bundle, and it copies externally visible defs and uses to the BUNDLE |
26 | /// instruction. |
27 | void finalizeBundle(MachineBasicBlock &MBB, |
28 | MachineBasicBlock::instr_iterator FirstMI, |
29 | MachineBasicBlock::instr_iterator LastMI); |
30 | |
31 | /// finalizeBundle - Same functionality as the previous finalizeBundle except |
32 | /// the last instruction in the bundle is not provided as an input. This is |
33 | /// used in cases where bundles are pre-determined by marking instructions |
34 | /// with 'InsideBundle' marker. It returns the MBB instruction iterator that |
35 | /// points to the end of the bundle. |
36 | MachineBasicBlock::instr_iterator finalizeBundle(MachineBasicBlock &MBB, |
37 | MachineBasicBlock::instr_iterator FirstMI); |
38 | |
39 | /// finalizeBundles - Finalize instruction bundles in the specified |
40 | /// MachineFunction. Return true if any bundles are finalized. |
41 | bool finalizeBundles(MachineFunction &MF); |
42 | |
43 | /// Returns an iterator to the first instruction in the bundle containing \p I. |
44 | inline MachineBasicBlock::instr_iterator getBundleStart( |
45 | MachineBasicBlock::instr_iterator I) { |
46 | while (I->isBundledWithPred()) |
47 | --I; |
48 | return I; |
49 | } |
50 | |
51 | /// Returns an iterator to the first instruction in the bundle containing \p I. |
52 | inline MachineBasicBlock::const_instr_iterator getBundleStart( |
53 | MachineBasicBlock::const_instr_iterator I) { |
54 | while (I->isBundledWithPred()) |
55 | --I; |
56 | return I; |
57 | } |
58 | |
59 | /// Returns an iterator pointing beyond the bundle containing \p I. |
60 | inline MachineBasicBlock::instr_iterator getBundleEnd( |
61 | MachineBasicBlock::instr_iterator I) { |
62 | while (I->isBundledWithSucc()) |
63 | ++I; |
64 | ++I; |
65 | return I; |
66 | } |
67 | |
68 | /// Returns an iterator pointing beyond the bundle containing \p I. |
69 | inline MachineBasicBlock::const_instr_iterator getBundleEnd( |
70 | MachineBasicBlock::const_instr_iterator I) { |
71 | while (I->isBundledWithSucc()) |
72 | ++I; |
73 | ++I; |
74 | return I; |
75 | } |
76 | |
77 | //===----------------------------------------------------------------------===// |
78 | // MachineBundleOperand iterator |
79 | // |
80 | |
81 | /// MIBundleOperandIteratorBase - Iterator that visits all operands in a bundle |
82 | /// of MachineInstrs. This class is not intended to be used directly, use one |
83 | /// of the sub-classes instead. |
84 | /// |
85 | /// Intended use: |
86 | /// |
87 | /// for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) { |
88 | /// if (!MIO->isReg()) |
89 | /// continue; |
90 | /// ... |
91 | /// } |
92 | /// |
93 | template <typename ValueT> |
94 | class MIBundleOperandIteratorBase |
95 | : public iterator_facade_base<MIBundleOperandIteratorBase<ValueT>, |
96 | std::forward_iterator_tag, ValueT> { |
97 | MachineBasicBlock::instr_iterator InstrI, InstrE; |
98 | MachineInstr::mop_iterator OpI, OpE; |
99 | |
100 | // If the operands on InstrI are exhausted, advance InstrI to the next |
101 | // bundled instruction with operands. |
102 | void advance() { |
103 | while (OpI == OpE) { |
104 | // Don't advance off the basic block, or into a new bundle. |
105 | if (++InstrI == InstrE || !InstrI->isInsideBundle()) { |
106 | InstrI = InstrE; |
107 | break; |
108 | } |
109 | OpI = InstrI->operands_begin(); |
110 | OpE = InstrI->operands_end(); |
111 | } |
112 | } |
113 | |
114 | protected: |
115 | /// MIBundleOperandIteratorBase - Create an iterator that visits all operands |
116 | /// on MI, or all operands on every instruction in the bundle containing MI. |
117 | /// |
118 | /// @param MI The instruction to examine. |
119 | /// |
120 | explicit MIBundleOperandIteratorBase(MachineInstr &MI) { |
121 | InstrI = getBundleStart(I: MI.getIterator()); |
122 | InstrE = MI.getParent()->instr_end(); |
123 | OpI = InstrI->operands_begin(); |
124 | OpE = InstrI->operands_end(); |
125 | advance(); |
126 | } |
127 | |
128 | /// Constructor for an iterator past the last iteration: both instruction |
129 | /// iterators point to the end of the BB and OpI == OpE. |
130 | explicit MIBundleOperandIteratorBase(MachineBasicBlock::instr_iterator InstrE, |
131 | MachineInstr::mop_iterator OpE) |
132 | : InstrI(InstrE), InstrE(InstrE), OpI(OpE), OpE(OpE) {} |
133 | |
134 | public: |
135 | /// isValid - Returns true until all the operands have been visited. |
136 | bool isValid() const { return OpI != OpE; } |
137 | |
138 | /// Preincrement. Move to the next operand. |
139 | void operator++() { |
140 | assert(isValid() && "Cannot advance MIOperands beyond the last operand" ); |
141 | ++OpI; |
142 | advance(); |
143 | } |
144 | |
145 | ValueT &operator*() const { return *OpI; } |
146 | ValueT *operator->() const { return &*OpI; } |
147 | |
148 | bool operator==(const MIBundleOperandIteratorBase &Arg) const { |
149 | // Iterators are equal, if InstrI matches and either OpIs match or OpI == |
150 | // OpE match for both. The second condition allows us to construct an 'end' |
151 | // iterator, without finding the last instruction in a bundle up-front. |
152 | return InstrI == Arg.InstrI && |
153 | (OpI == Arg.OpI || (OpI == OpE && Arg.OpI == Arg.OpE)); |
154 | } |
155 | /// getOperandNo - Returns the number of the current operand relative to its |
156 | /// instruction. |
157 | /// |
158 | unsigned getOperandNo() const { |
159 | return OpI - InstrI->operands_begin(); |
160 | } |
161 | }; |
162 | |
163 | /// MIBundleOperands - Iterate over all operands in a bundle of machine |
164 | /// instructions. |
165 | /// |
166 | class MIBundleOperands : public MIBundleOperandIteratorBase<MachineOperand> { |
167 | /// Constructor for an iterator past the last iteration. |
168 | MIBundleOperands(MachineBasicBlock::instr_iterator InstrE, |
169 | MachineInstr::mop_iterator OpE) |
170 | : MIBundleOperandIteratorBase(InstrE, OpE) {} |
171 | |
172 | public: |
173 | MIBundleOperands(MachineInstr &MI) : MIBundleOperandIteratorBase(MI) {} |
174 | |
175 | /// Returns an iterator past the last iteration. |
176 | static MIBundleOperands end(const MachineBasicBlock &MBB) { |
177 | return {const_cast<MachineBasicBlock &>(MBB).instr_end(), |
178 | const_cast<MachineBasicBlock &>(MBB).instr_begin()->operands_end()}; |
179 | } |
180 | }; |
181 | |
182 | /// ConstMIBundleOperands - Iterate over all operands in a const bundle of |
183 | /// machine instructions. |
184 | /// |
185 | class ConstMIBundleOperands |
186 | : public MIBundleOperandIteratorBase<const MachineOperand> { |
187 | |
188 | /// Constructor for an iterator past the last iteration. |
189 | ConstMIBundleOperands(MachineBasicBlock::instr_iterator InstrE, |
190 | MachineInstr::mop_iterator OpE) |
191 | : MIBundleOperandIteratorBase(InstrE, OpE) {} |
192 | |
193 | public: |
194 | ConstMIBundleOperands(const MachineInstr &MI) |
195 | : MIBundleOperandIteratorBase(const_cast<MachineInstr &>(MI)) {} |
196 | |
197 | /// Returns an iterator past the last iteration. |
198 | static ConstMIBundleOperands end(const MachineBasicBlock &MBB) { |
199 | return {const_cast<MachineBasicBlock &>(MBB).instr_end(), |
200 | const_cast<MachineBasicBlock &>(MBB).instr_begin()->operands_end()}; |
201 | } |
202 | }; |
203 | |
204 | inline iterator_range<ConstMIBundleOperands> |
205 | const_mi_bundle_ops(const MachineInstr &MI) { |
206 | return make_range(x: ConstMIBundleOperands(MI), |
207 | y: ConstMIBundleOperands::end(MBB: *MI.getParent())); |
208 | } |
209 | |
210 | inline iterator_range<MIBundleOperands> mi_bundle_ops(MachineInstr &MI) { |
211 | return make_range(x: MIBundleOperands(MI), |
212 | y: MIBundleOperands::end(MBB: *MI.getParent())); |
213 | } |
214 | |
215 | /// VirtRegInfo - Information about a virtual register used by a set of |
216 | /// operands. |
217 | /// |
218 | struct VirtRegInfo { |
219 | /// Reads - One of the operands read the virtual register. This does not |
220 | /// include undef or internal use operands, see MO::readsReg(). |
221 | bool Reads; |
222 | |
223 | /// Writes - One of the operands writes the virtual register. |
224 | bool Writes; |
225 | |
226 | /// Tied - Uses and defs must use the same register. This can be because of |
227 | /// a two-address constraint, or there may be a partial redefinition of a |
228 | /// sub-register. |
229 | bool Tied; |
230 | }; |
231 | |
232 | /// AnalyzeVirtRegInBundle - Analyze how the current instruction or bundle uses |
233 | /// a virtual register. This function should not be called after operator++(), |
234 | /// it expects a fresh iterator. |
235 | /// |
236 | /// @param Reg The virtual register to analyze. |
237 | /// @param Ops When set, this vector will receive an (MI, OpNum) entry for |
238 | /// each operand referring to Reg. |
239 | /// @returns A filled-in RegInfo struct. |
240 | VirtRegInfo AnalyzeVirtRegInBundle( |
241 | MachineInstr &MI, Register Reg, |
242 | SmallVectorImpl<std::pair<MachineInstr *, unsigned>> *Ops = nullptr); |
243 | |
244 | /// Return a pair of lane masks (reads, writes) indicating which lanes this |
245 | /// instruction uses with Reg. |
246 | std::pair<LaneBitmask, LaneBitmask> |
247 | AnalyzeVirtRegLanesInBundle(const MachineInstr &MI, Register Reg, |
248 | const MachineRegisterInfo &MRI, |
249 | const TargetRegisterInfo &TRI); |
250 | |
251 | /// Information about how a physical register Reg is used by a set of |
252 | /// operands. |
253 | struct PhysRegInfo { |
254 | /// There is a regmask operand indicating Reg is clobbered. |
255 | /// \see MachineOperand::CreateRegMask(). |
256 | bool Clobbered; |
257 | |
258 | /// Reg or one of its aliases is defined. The definition may only cover |
259 | /// parts of the register. |
260 | bool Defined; |
261 | /// Reg or a super-register is defined. The definition covers the full |
262 | /// register. |
263 | bool FullyDefined; |
264 | |
265 | /// Reg or one of its aliases is read. The register may only be read |
266 | /// partially. |
267 | bool Read; |
268 | /// Reg or a super-register is read. The full register is read. |
269 | bool FullyRead; |
270 | |
271 | /// Either: |
272 | /// - Reg is FullyDefined and all defs of reg or an overlapping |
273 | /// register are dead, or |
274 | /// - Reg is completely dead because "defined" by a clobber. |
275 | bool DeadDef; |
276 | |
277 | /// Reg is Defined and all defs of reg or an overlapping register are |
278 | /// dead. |
279 | bool PartialDeadDef; |
280 | |
281 | /// There is a use operand of reg or a super-register with kill flag set. |
282 | bool Killed; |
283 | }; |
284 | |
285 | /// AnalyzePhysRegInBundle - Analyze how the current instruction or bundle uses |
286 | /// a physical register. This function should not be called after operator++(), |
287 | /// it expects a fresh iterator. |
288 | /// |
289 | /// @param Reg The physical register to analyze. |
290 | /// @returns A filled-in PhysRegInfo struct. |
291 | PhysRegInfo AnalyzePhysRegInBundle(const MachineInstr &MI, Register Reg, |
292 | const TargetRegisterInfo *TRI); |
293 | |
294 | } // End llvm namespace |
295 | |
296 | #endif |
297 | |