1 //===-- CodeGen/MachineInstBundle.h - MI bundle utilities -------*- C++ -*-===// 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 // This file provide utility functions to manipulate machine instruction 11 // bundles. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLE_H 16 #define LLVM_CODEGEN_MACHINEINSTRBUNDLE_H 17 18 #include "llvm/CodeGen/MachineBasicBlock.h" 19 20 namespace llvm { 21 22 /// finalizeBundle - Finalize a machine instruction bundle which includes 23 /// a sequence of instructions starting from FirstMI to LastMI (exclusive). 24 /// This routine adds a BUNDLE instruction to represent the bundle, it adds 25 /// IsInternalRead markers to MachineOperands which are defined inside the 26 /// bundle, and it copies externally visible defs and uses to the BUNDLE 27 /// instruction. 28 void finalizeBundle(MachineBasicBlock &MBB, 29 MachineBasicBlock::instr_iterator FirstMI, 30 MachineBasicBlock::instr_iterator LastMI); 31 32 /// finalizeBundle - Same functionality as the previous finalizeBundle except 33 /// the last instruction in the bundle is not provided as an input. This is 34 /// used in cases where bundles are pre-determined by marking instructions 35 /// with 'InsideBundle' marker. It returns the MBB instruction iterator that 36 /// points to the end of the bundle. 37 MachineBasicBlock::instr_iterator finalizeBundle(MachineBasicBlock &MBB, 38 MachineBasicBlock::instr_iterator FirstMI); 39 40 /// finalizeBundles - Finalize instruction bundles in the specified 41 /// MachineFunction. Return true if any bundles are finalized. 42 bool finalizeBundles(MachineFunction &MF); 43 44 /// getBundleStart - Returns the first instruction in the bundle containing MI. 45 /// 46 static inline MachineInstr *getBundleStart(MachineInstr *MI) { 47 MachineBasicBlock::instr_iterator I = MI; 48 while (I->isInsideBundle()) 49 --I; 50 return I; 51 } 52 53 static inline const MachineInstr *getBundleStart(const MachineInstr *MI) { 54 MachineBasicBlock::const_instr_iterator I = MI; 55 while (I->isInsideBundle()) 56 --I; 57 return I; 58 } 59 60 //===----------------------------------------------------------------------===// 61 // MachineOperand iterator 62 // 63 64 /// MachineOperandIteratorBase - Iterator that can visit all operands on a 65 /// MachineInstr, or all operands on a bundle of MachineInstrs. This class is 66 /// not intended to be used directly, use one of the sub-classes instead. 67 /// 68 /// Intended use: 69 /// 70 /// for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) { 71 /// if (!MIO->isReg()) 72 /// continue; 73 /// ... 74 /// } 75 /// 76 class MachineOperandIteratorBase { 77 MachineBasicBlock::instr_iterator InstrI, InstrE; 78 MachineInstr::mop_iterator OpI, OpE; 79 80 // If the operands on InstrI are exhausted, advance InstrI to the next 81 // bundled instruction with operands. 82 void advance() { 83 while (OpI == OpE) { 84 // Don't advance off the basic block, or into a new bundle. 85 if (++InstrI == InstrE || !InstrI->isInsideBundle()) 86 break; 87 OpI = InstrI->operands_begin(); 88 OpE = InstrI->operands_end(); 89 } 90 } 91 92 protected: 93 /// MachineOperandIteratorBase - Create an iterator that visits all operands 94 /// on MI, or all operands on every instruction in the bundle containing MI. 95 /// 96 /// @param MI The instruction to examine. 97 /// @param WholeBundle When true, visit all operands on the entire bundle. 98 /// 99 explicit MachineOperandIteratorBase(MachineInstr *MI, bool WholeBundle) { 100 if (WholeBundle) { 101 InstrI = getBundleStart(MI); 102 InstrE = MI->getParent()->instr_end(); 103 } else { 104 InstrI = InstrE = MI; 105 ++InstrE; 106 } 107 OpI = InstrI->operands_begin(); 108 OpE = InstrI->operands_end(); 109 if (WholeBundle) 110 advance(); 111 } 112 113 MachineOperand &deref() const { return *OpI; } 114 115 public: 116 /// isValid - Returns true until all the operands have been visited. 117 bool isValid() const { return OpI != OpE; } 118 119 /// Preincrement. Move to the next operand. 120 void operator++() { 121 assert(isValid() && "Cannot advance MIOperands beyond the last operand"); 122 ++OpI; 123 advance(); 124 } 125 126 /// getOperandNo - Returns the number of the current operand relative to its 127 /// instruction. 128 /// 129 unsigned getOperandNo() const { 130 return OpI - InstrI->operands_begin(); 131 } 132 133 /// RegInfo - Information about a virtual register used by a set of operands. 134 /// 135 struct RegInfo { 136 /// Reads - One of the operands read the virtual register. This does not 137 /// include <undef> or <internal> use operands, see MO::readsReg(). 138 bool Reads; 139 140 /// Writes - One of the operands writes the virtual register. 141 bool Writes; 142 143 /// Tied - Uses and defs must use the same register. This can be because of 144 /// a two-address constraint, or there may be a partial redefinition of a 145 /// sub-register. 146 bool Tied; 147 }; 148 149 /// analyzeVirtReg - Analyze how the current instruction or bundle uses a 150 /// virtual register. This function should not be called after operator++(), 151 /// it expects a fresh iterator. 152 /// 153 /// @param Reg The virtual register to analyze. 154 /// @param Ops When set, this vector will receive an (MI, OpNum) entry for 155 /// each operand referring to Reg. 156 /// @returns A filled-in RegInfo struct. 157 RegInfo analyzeVirtReg(unsigned Reg, 158 SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops = 0); 159 }; 160 161 /// MIOperands - Iterate over operands of a single instruction. 162 /// 163 class MIOperands : public MachineOperandIteratorBase { 164 public: 165 MIOperands(MachineInstr *MI) : MachineOperandIteratorBase(MI, false) {} 166 MachineOperand &operator* () const { return deref(); } 167 MachineOperand *operator->() const { return &deref(); } 168 }; 169 170 /// ConstMIOperands - Iterate over operands of a single const instruction. 171 /// 172 class ConstMIOperands : public MachineOperandIteratorBase { 173 public: 174 ConstMIOperands(const MachineInstr *MI) 175 : MachineOperandIteratorBase(const_cast<MachineInstr*>(MI), false) {} 176 const MachineOperand &operator* () const { return deref(); } 177 const MachineOperand *operator->() const { return &deref(); } 178 }; 179 180 /// MIBundleOperands - Iterate over all operands in a bundle of machine 181 /// instructions. 182 /// 183 class MIBundleOperands : public MachineOperandIteratorBase { 184 public: 185 MIBundleOperands(MachineInstr *MI) : MachineOperandIteratorBase(MI, true) {} 186 MachineOperand &operator* () const { return deref(); } 187 MachineOperand *operator->() const { return &deref(); } 188 }; 189 190 /// ConstMIBundleOperands - Iterate over all operands in a const bundle of 191 /// machine instructions. 192 /// 193 class ConstMIBundleOperands : public MachineOperandIteratorBase { 194 public: 195 ConstMIBundleOperands(const MachineInstr *MI) 196 : MachineOperandIteratorBase(const_cast<MachineInstr*>(MI), true) {} 197 const MachineOperand &operator* () const { return deref(); } 198 const MachineOperand *operator->() const { return &deref(); } 199 }; 200 201 } // End llvm namespace 202 203 #endif 204
