1 //===-- lib/CodeGen/MachineInstrBundle.cpp --------------------------------===// 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 #include "llvm/CodeGen/MachineInstrBundle.h" 11 #include "llvm/CodeGen/MachineInstrBuilder.h" 12 #include "llvm/CodeGen/Passes.h" 13 #include "llvm/CodeGen/MachineFunctionPass.h" 14 #include "llvm/Target/TargetInstrInfo.h" 15 #include "llvm/Target/TargetMachine.h" 16 #include "llvm/Target/TargetRegisterInfo.h" 17 #include "llvm/ADT/SmallSet.h" 18 #include "llvm/ADT/SmallVector.h" 19 using namespace llvm; 20 21 namespace { 22 class UnpackMachineBundles : public MachineFunctionPass { 23 public: 24 static char ID; // Pass identification 25 UnpackMachineBundles() : MachineFunctionPass(ID) { 26 initializeUnpackMachineBundlesPass(*PassRegistry::getPassRegistry()); 27 } 28 29 virtual bool runOnMachineFunction(MachineFunction &MF); 30 }; 31 } // end anonymous namespace 32 33 char UnpackMachineBundles::ID = 0; 34 char &llvm::UnpackMachineBundlesID = UnpackMachineBundles::ID; 35 INITIALIZE_PASS(UnpackMachineBundles, "unpack-mi-bundles", 36 "Unpack machine instruction bundles", false, false) 37 38 bool UnpackMachineBundles::runOnMachineFunction(MachineFunction &MF) { 39 bool Changed = false; 40 for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) { 41 MachineBasicBlock *MBB = &*I; 42 43 for (MachineBasicBlock::instr_iterator MII = MBB->instr_begin(), 44 MIE = MBB->instr_end(); MII != MIE; ) { 45 MachineInstr *MI = &*MII; 46 47 // Remove BUNDLE instruction and the InsideBundle flags from bundled 48 // instructions. 49 if (MI->isBundle()) { 50 while (++MII != MIE && MII->isInsideBundle()) { 51 MII->setIsInsideBundle(false); 52 for (unsigned i = 0, e = MII->getNumOperands(); i != e; ++i) { 53 MachineOperand &MO = MII->getOperand(i); 54 if (MO.isReg() && MO.isInternalRead()) 55 MO.setIsInternalRead(false); 56 } 57 } 58 MI->eraseFromParent(); 59 60 Changed = true; 61 continue; 62 } 63 64 ++MII; 65 } 66 } 67 68 return Changed; 69 } 70 71 72 namespace { 73 class FinalizeMachineBundles : public MachineFunctionPass { 74 public: 75 static char ID; // Pass identification 76 FinalizeMachineBundles() : MachineFunctionPass(ID) { 77 initializeFinalizeMachineBundlesPass(*PassRegistry::getPassRegistry()); 78 } 79 80 virtual bool runOnMachineFunction(MachineFunction &MF); 81 }; 82 } // end anonymous namespace 83 84 char FinalizeMachineBundles::ID = 0; 85 char &llvm::FinalizeMachineBundlesID = FinalizeMachineBundles::ID; 86 INITIALIZE_PASS(FinalizeMachineBundles, "finalize-mi-bundles", 87 "Finalize machine instruction bundles", false, false) 88 89 bool FinalizeMachineBundles::runOnMachineFunction(MachineFunction &MF) { 90 return llvm::finalizeBundles(MF); 91 } 92 93 94 /// finalizeBundle - Finalize a machine instruction bundle which includes 95 /// a sequence of instructions starting from FirstMI to LastMI (exclusive). 96 /// This routine adds a BUNDLE instruction to represent the bundle, it adds 97 /// IsInternalRead markers to MachineOperands which are defined inside the 98 /// bundle, and it copies externally visible defs and uses to the BUNDLE 99 /// instruction. 100 void llvm::finalizeBundle(MachineBasicBlock &MBB, 101 MachineBasicBlock::instr_iterator FirstMI, 102 MachineBasicBlock::instr_iterator LastMI) { 103 assert(FirstMI != LastMI && "Empty bundle?"); 104 105 const TargetMachine &TM = MBB.getParent()->getTarget(); 106 const TargetInstrInfo *TII = TM.getInstrInfo(); 107 const TargetRegisterInfo *TRI = TM.getRegisterInfo(); 108 109 MachineInstrBuilder MIB = BuildMI(MBB, FirstMI, FirstMI->getDebugLoc(), 110 TII->get(TargetOpcode::BUNDLE)); 111 112 SmallVector<unsigned, 8> LocalDefs; 113 SmallSet<unsigned, 8> LocalDefSet; 114 SmallSet<unsigned, 8> DeadDefSet; 115 SmallSet<unsigned, 8> KilledDefSet; 116 SmallVector<unsigned, 8> ExternUses; 117 SmallSet<unsigned, 8> ExternUseSet; 118 SmallSet<unsigned, 8> KilledUseSet; 119 SmallSet<unsigned, 8> UndefUseSet; 120 SmallVector<MachineOperand*, 4> Defs; 121 for (; FirstMI != LastMI; ++FirstMI) { 122 for (unsigned i = 0, e = FirstMI->getNumOperands(); i != e; ++i) { 123 MachineOperand &MO = FirstMI->getOperand(i); 124 if (!MO.isReg()) 125 continue; 126 if (MO.isDef()) { 127 Defs.push_back(&MO); 128 continue; 129 } 130 131 unsigned Reg = MO.getReg(); 132 if (!Reg) 133 continue; 134 assert(TargetRegisterInfo::isPhysicalRegister(Reg)); 135 if (LocalDefSet.count(Reg)) { 136 MO.setIsInternalRead(); 137 if (MO.isKill()) 138 // Internal def is now killed. 139 KilledDefSet.insert(Reg); 140 } else { 141 if (ExternUseSet.insert(Reg)) { 142 ExternUses.push_back(Reg); 143 if (MO.isUndef()) 144 UndefUseSet.insert(Reg); 145 } 146 if (MO.isKill()) 147 // External def is now killed. 148 KilledUseSet.insert(Reg); 149 } 150 } 151 152 for (unsigned i = 0, e = Defs.size(); i != e; ++i) { 153 MachineOperand &MO = *Defs[i]; 154 unsigned Reg = MO.getReg(); 155 if (!Reg) 156 continue; 157 158 if (LocalDefSet.insert(Reg)) { 159 LocalDefs.push_back(Reg); 160 if (MO.isDead()) { 161 DeadDefSet.insert(Reg); 162 } 163 } else { 164 // Re-defined inside the bundle, it's no longer killed. 165 KilledDefSet.erase(Reg); 166 if (!MO.isDead()) 167 // Previously defined but dead. 168 DeadDefSet.erase(Reg); 169 } 170 171 if (!MO.isDead()) { 172 for (const uint16_t *SubRegs = TRI->getSubRegisters(Reg); 173 unsigned SubReg = *SubRegs; ++SubRegs) { 174 if (LocalDefSet.insert(SubReg)) 175 LocalDefs.push_back(SubReg); 176 } 177 } 178 } 179 180 FirstMI->setIsInsideBundle(); 181 Defs.clear(); 182 } 183 184 SmallSet<unsigned, 8> Added; 185 for (unsigned i = 0, e = LocalDefs.size(); i != e; ++i) { 186 unsigned Reg = LocalDefs[i]; 187 if (Added.insert(Reg)) { 188 // If it's not live beyond end of the bundle, mark it dead. 189 bool isDead = DeadDefSet.count(Reg) || KilledDefSet.count(Reg); 190 MIB.addReg(Reg, getDefRegState(true) | getDeadRegState(isDead) | 191 getImplRegState(true)); 192 } 193 } 194 195 for (unsigned i = 0, e = ExternUses.size(); i != e; ++i) { 196 unsigned Reg = ExternUses[i]; 197 bool isKill = KilledUseSet.count(Reg); 198 bool isUndef = UndefUseSet.count(Reg); 199 MIB.addReg(Reg, getKillRegState(isKill) | getUndefRegState(isUndef) | 200 getImplRegState(true)); 201 } 202 } 203 204 /// finalizeBundle - Same functionality as the previous finalizeBundle except 205 /// the last instruction in the bundle is not provided as an input. This is 206 /// used in cases where bundles are pre-determined by marking instructions 207 /// with 'InsideBundle' marker. It returns the MBB instruction iterator that 208 /// points to the end of the bundle. 209 MachineBasicBlock::instr_iterator 210 llvm::finalizeBundle(MachineBasicBlock &MBB, 211 MachineBasicBlock::instr_iterator FirstMI) { 212 MachineBasicBlock::instr_iterator E = MBB.instr_end(); 213 MachineBasicBlock::instr_iterator LastMI = llvm::next(FirstMI); 214 while (LastMI != E && LastMI->isInsideBundle()) 215 ++LastMI; 216 finalizeBundle(MBB, FirstMI, LastMI); 217 return LastMI; 218 } 219 220 /// finalizeBundles - Finalize instruction bundles in the specified 221 /// MachineFunction. Return true if any bundles are finalized. 222 bool llvm::finalizeBundles(MachineFunction &MF) { 223 bool Changed = false; 224 for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) { 225 MachineBasicBlock &MBB = *I; 226 227 MachineBasicBlock::instr_iterator MII = MBB.instr_begin(); 228 assert(!MII->isInsideBundle() && 229 "First instr cannot be inside bundle before finalization!"); 230 231 MachineBasicBlock::instr_iterator MIE = MBB.instr_end(); 232 if (MII == MIE) 233 continue; 234 for (++MII; MII != MIE; ) { 235 if (!MII->isInsideBundle()) 236 ++MII; 237 else { 238 MII = finalizeBundle(MBB, llvm::prior(MII)); 239 Changed = true; 240 } 241 } 242 } 243 244 return Changed; 245 } 246 247 //===----------------------------------------------------------------------===// 248 // MachineOperand iterator 249 //===----------------------------------------------------------------------===// 250 251 MachineOperandIteratorBase::RegInfo 252 MachineOperandIteratorBase::analyzeVirtReg(unsigned Reg, 253 SmallVectorImpl<std::pair<MachineInstr*, unsigned> > *Ops) { 254 RegInfo RI = { false, false, false }; 255 for(; isValid(); ++*this) { 256 MachineOperand &MO = deref(); 257 if (!MO.isReg() || MO.getReg() != Reg) 258 continue; 259 260 // Remember each (MI, OpNo) that refers to Reg. 261 if (Ops) 262 Ops->push_back(std::make_pair(MO.getParent(), getOperandNo())); 263 264 // Both defs and uses can read virtual registers. 265 if (MO.readsReg()) { 266 RI.Reads = true; 267 if (MO.isDef()) 268 RI.Tied = true; 269 } 270 271 // Only defs can write. 272 if (MO.isDef()) 273 RI.Writes = true; 274 else if (!RI.Tied && MO.getParent()->isRegTiedToDefOperand(getOperandNo())) 275 RI.Tied = true; 276 } 277 return RI; 278 } 279