1 //===- llvm/CodeGen/MachineInstrBundle.h - MI bundle utilities --*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // This file provide utility functions to manipulate machine instruction
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLE_H
15 #define LLVM_CODEGEN_MACHINEINSTRBUNDLE_H
17 #include "llvm/CodeGen/MachineBasicBlock.h"
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
27 void finalizeBundle(MachineBasicBlock &MBB,
28 MachineBasicBlock::instr_iterator FirstMI,
29 MachineBasicBlock::instr_iterator LastMI);
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);
39 /// finalizeBundles - Finalize instruction bundles in the specified
40 /// MachineFunction. Return true if any bundles are finalized.
41 bool finalizeBundles(MachineFunction &MF);
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())
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())
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())
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())
77 //===----------------------------------------------------------------------===//
78 // MachineBundleOperand iterator
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.
87 /// for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) {
88 /// if (!MIO->isReg())
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;
100 // If the operands on InstrI are exhausted, advance InstrI to the next
101 // bundled instruction with operands.
104 // Don't advance off the basic block, or into a new bundle.
105 if (++InstrI == InstrE || !InstrI->isInsideBundle()) {
109 OpI = InstrI->operands_begin();
110 OpE = InstrI->operands_end();
115 /// MIBundleOperandIteratorBase - Create an iterator that visits all operands
116 /// on MI, or all operands on every instruction in the bundle containing MI.
118 /// @param MI The instruction to examine.
120 explicit MIBundleOperandIteratorBase(MachineInstr &MI) {
121 InstrI = getBundleStart(MI.getIterator());
122 InstrE = MI.getParent()->instr_end();
123 OpI = InstrI->operands_begin();
124 OpE = InstrI->operands_end();
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) {}
135 /// isValid - Returns true until all the operands have been visited.
136 bool isValid() const { return OpI != OpE; }
138 /// Preincrement. Move to the next operand.
140 assert(isValid() && "Cannot advance MIOperands beyond the last operand");
145 ValueT &operator*() const { return *OpI; }
146 ValueT *operator->() const { return &*OpI; }
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));
155 /// getOperandNo - Returns the number of the current operand relative to its
158 unsigned getOperandNo() const {
159 return OpI - InstrI->operands_begin();
163 /// MIBundleOperands - Iterate over all operands in a bundle of machine
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) {}
173 MIBundleOperands(MachineInstr &MI) : MIBundleOperandIteratorBase(MI) {}
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()};
182 /// ConstMIBundleOperands - Iterate over all operands in a const bundle of
183 /// machine instructions.
185 class ConstMIBundleOperands
186 : public MIBundleOperandIteratorBase<const MachineOperand> {
188 /// Constructor for an iterator past the last iteration.
189 ConstMIBundleOperands(MachineBasicBlock::instr_iterator InstrE,
190 MachineInstr::mop_iterator OpE)
191 : MIBundleOperandIteratorBase(InstrE, OpE) {}
194 ConstMIBundleOperands(const MachineInstr &MI)
195 : MIBundleOperandIteratorBase(const_cast<MachineInstr &>(MI)) {}
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()};
204 inline iterator_range<ConstMIBundleOperands>
205 const_mi_bundle_ops(const MachineInstr &MI) {
206 return make_range(ConstMIBundleOperands(MI),
207 ConstMIBundleOperands::end(*MI.getParent()));
210 inline iterator_range<MIBundleOperands> mi_bundle_ops(MachineInstr &MI) {
211 return make_range(MIBundleOperands(MI),
212 MIBundleOperands::end(*MI.getParent()));
215 /// VirtRegInfo - Information about a virtual register used by a set of
219 /// Reads - One of the operands read the virtual register. This does not
220 /// include undef or internal use operands, see MO::readsReg().
223 /// Writes - One of the operands writes the virtual register.
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
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.
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, unsigned Reg,
242 SmallVectorImpl<std::pair<MachineInstr *, unsigned>> *Ops = nullptr);
244 /// Information about how a physical register Reg is used by a set of
247 /// There is a regmask operand indicating Reg is clobbered.
248 /// \see MachineOperand::CreateRegMask().
251 /// Reg or one of its aliases is defined. The definition may only cover
252 /// parts of the register.
254 /// Reg or a super-register is defined. The definition covers the full
258 /// Reg or one of its aliases is read. The register may only be read
261 /// Reg or a super-register is read. The full register is read.
265 /// - Reg is FullyDefined and all defs of reg or an overlapping
266 /// register are dead, or
267 /// - Reg is completely dead because "defined" by a clobber.
270 /// Reg is Defined and all defs of reg or an overlapping register are
274 /// There is a use operand of reg or a super-register with kill flag set.
278 /// AnalyzePhysRegInBundle - Analyze how the current instruction or bundle uses
279 /// a physical register. This function should not be called after operator++(),
280 /// it expects a fresh iterator.
282 /// @param Reg The physical register to analyze.
283 /// @returns A filled-in PhysRegInfo struct.
284 PhysRegInfo AnalyzePhysRegInBundle(const MachineInstr &MI, unsigned Reg,
285 const TargetRegisterInfo *TRI);
287 } // End llvm namespace