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 inline MachineInstr *getBundleStart(MachineInstr *MI) { 47 MachineBasicBlock::instr_iterator I(MI); 48 while (I->isBundledWithPred()) 49 --I; 50 return &*I; 51 } 52 53 inline const MachineInstr *getBundleStart(const MachineInstr *MI) { 54 MachineBasicBlock::const_instr_iterator I(MI); 55 while (I->isBundledWithPred()) 56 --I; 57 return &*I; 58 } 59 60 /// Return an iterator pointing beyond the bundle containing MI. 61 inline MachineBasicBlock::instr_iterator 62 getBundleEnd(MachineInstr *MI) { 63 MachineBasicBlock::instr_iterator I(MI); 64 while (I->isBundledWithSucc()) 65 ++I; 66 return ++I; 67 } 68 69 /// Return an iterator pointing beyond the bundle containing MI. 70 inline MachineBasicBlock::const_instr_iterator 71 getBundleEnd(const MachineInstr *MI) { 72 MachineBasicBlock::const_instr_iterator I(MI); 73 while (I->isBundledWithSucc()) 74 ++I; 75 return ++I; 76 } 77 78 //===----------------------------------------------------------------------===// 79 // MachineOperand iterator 80 // 81 82 /// MachineOperandIteratorBase - Iterator that can visit all operands on a 83 /// MachineInstr, or all operands on a bundle of MachineInstrs. This class is 84 /// not intended to be used directly, use one of the sub-classes instead. 85 /// 86 /// Intended use: 87 /// 88 /// for (MIBundleOperands MIO(MI); MIO.isValid(); ++MIO) { 89 /// if (!MIO->isReg()) 90 /// continue; 91 /// ... 92 /// } 93 /// 94 class MachineOperandIteratorBase { 95 MachineBasicBlock::instr_iterator InstrI, InstrE; 96 MachineInstr::mop_iterator OpI, OpE; 97 98 // If the operands on InstrI are exhausted, advance InstrI to the next 99 // bundled instruction with operands. 100 void advance() { 101 while (OpI == OpE) { 102 // Don't advance off the basic block, or into a new bundle. 103 if (++InstrI == InstrE || !InstrI->isInsideBundle()) 104 break; 105 OpI = InstrI->operands_begin(); 106 OpE = InstrI->operands_end(); 107 } 108 } 109 110 protected: 111 /// MachineOperandIteratorBase - Create an iterator that visits all operands 112 /// on MI, or all operands on every instruction in the bundle containing MI. 113 /// 114 /// @param MI The instruction to examine. 115 /// @param WholeBundle When true, visit all operands on the entire bundle. 116 /// 117 explicit MachineOperandIteratorBase(MachineInstr *MI, bool WholeBundle) { 118 if (WholeBundle) { 119 InstrI = getBundleStart(MI)->getIterator(); 120 InstrE = MI->getParent()->instr_end(); 121 } else { 122 InstrI = InstrE = MI->getIterator(); 123 ++InstrE; 124 } 125 OpI = InstrI->operands_begin(); 126 OpE = InstrI->operands_end(); 127 if (WholeBundle) 128 advance(); 129 } 130 131 MachineOperand &deref() const { return *OpI; } 132 133 public: 134 /// isValid - Returns true until all the operands have been visited. 135 bool isValid() const { return OpI != OpE; } 136 137 /// Preincrement. Move to the next operand. 138 void operator++() { 139 assert(isValid() && "Cannot advance MIOperands beyond the last operand"); 140 ++OpI; 141 advance(); 142 } 143 144 /// getOperandNo - Returns the number of the current operand relative to its 145 /// instruction. 146 /// 147 unsigned getOperandNo() const { 148 return OpI - InstrI->operands_begin(); 149 } 150 151 /// VirtRegInfo - Information about a virtual register used by a set of operands. 152 /// 153 struct VirtRegInfo { 154 /// Reads - One of the operands read the virtual register. This does not 155 /// include <undef> or <internal> use operands, see MO::readsReg(). 156 bool Reads; 157 158 /// Writes - One of the operands writes the virtual register. 159 bool Writes; 160 161 /// Tied - Uses and defs must use the same register. This can be because of 162 /// a two-address constraint, or there may be a partial redefinition of a 163 /// sub-register. 164 bool Tied; 165 }; 166 167 /// Information about how a physical register Reg is used by a set of 168 /// operands. 169 struct PhysRegInfo { 170 /// There is a regmask operand indicating Reg is clobbered. 171 /// \see MachineOperand::CreateRegMask(). 172 bool Clobbered; 173 174 /// Reg or one of its aliases is defined. The definition may only cover 175 /// parts of the register. 176 bool Defined; 177 /// Reg or a super-register is defined. The definition covers the full 178 /// register. 179 bool FullyDefined; 180 181 /// Reg or ont of its aliases is read. The register may only be read 182 /// partially. 183 bool Read; 184 /// Reg or a super-register is read. The full register is read. 185 bool FullyRead; 186 187 /// Reg is FullyDefined and all defs of reg or an overlapping register are 188 /// dead. 189 bool DeadDef; 190 191 /// There is a use operand of reg or a super-register with kill flag set. 192 bool Killed; 193 }; 194 195 /// analyzeVirtReg - Analyze how the current instruction or bundle uses a 196 /// virtual register. This function should not be called after operator++(), 197 /// it expects a fresh iterator. 198 /// 199 /// @param Reg The virtual register to analyze. 200 /// @param Ops When set, this vector will receive an (MI, OpNum) entry for 201 /// each operand referring to Reg. 202 /// @returns A filled-in RegInfo struct. 203 VirtRegInfo analyzeVirtReg(unsigned Reg, 204 SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops = nullptr); 205 206 /// analyzePhysReg - Analyze how the current instruction or bundle uses a 207 /// physical register. This function should not be called after operator++(), 208 /// it expects a fresh iterator. 209 /// 210 /// @param Reg The physical register to analyze. 211 /// @returns A filled-in PhysRegInfo struct. 212 PhysRegInfo analyzePhysReg(unsigned Reg, const TargetRegisterInfo *TRI); 213 }; 214 215 /// MIOperands - Iterate over operands of a single instruction. 216 /// 217 class MIOperands : public MachineOperandIteratorBase { 218 public: 219 MIOperands(MachineInstr *MI) : MachineOperandIteratorBase(MI, false) {} 220 MachineOperand &operator* () const { return deref(); } 221 MachineOperand *operator->() const { return &deref(); } 222 }; 223 224 /// ConstMIOperands - Iterate over operands of a single const instruction. 225 /// 226 class ConstMIOperands : public MachineOperandIteratorBase { 227 public: 228 ConstMIOperands(const MachineInstr *MI) 229 : MachineOperandIteratorBase(const_cast<MachineInstr*>(MI), false) {} 230 const MachineOperand &operator* () const { return deref(); } 231 const MachineOperand *operator->() const { return &deref(); } 232 }; 233 234 /// MIBundleOperands - Iterate over all operands in a bundle of machine 235 /// instructions. 236 /// 237 class MIBundleOperands : public MachineOperandIteratorBase { 238 public: 239 MIBundleOperands(MachineInstr *MI) : MachineOperandIteratorBase(MI, true) {} 240 MachineOperand &operator* () const { return deref(); } 241 MachineOperand *operator->() const { return &deref(); } 242 }; 243 244 /// ConstMIBundleOperands - Iterate over all operands in a const bundle of 245 /// machine instructions. 246 /// 247 class ConstMIBundleOperands : public MachineOperandIteratorBase { 248 public: 249 ConstMIBundleOperands(const MachineInstr *MI) 250 : MachineOperandIteratorBase(const_cast<MachineInstr*>(MI), true) {} 251 const MachineOperand &operator* () const { return deref(); } 252 const MachineOperand *operator->() const { return &deref(); } 253 }; 254 255 } // End llvm namespace 256 257 #endif 258