LiveIntervalAnalysis.cpp revision 8640f4e666086cc6e7447dc164105e428e6cb81a
1ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos//===-- LiveIntervals.cpp - Live Interval Analysis ------------------------===// 2ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// 3ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// The LLVM Compiler Infrastructure 4ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// 5ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// This file was developed by the LLVM research group and is distributed under 6ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// the University of Illinois Open Source License. See LICENSE.TXT for details. 7ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// 8ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos//===----------------------------------------------------------------------===// 9ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// 10ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// This file implements the LiveInterval analysis pass which is used 11ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// by the Linear Scan Register allocator. This pass linearizes the 12ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// basic blocks of the function in DFS order and uses the 13ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// LiveVariables pass to conservatively compute live intervals for 14ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// each virtual and physical register. 15ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos// 16ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos//===----------------------------------------------------------------------===// 17ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 18ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#define DEBUG_TYPE "liveintervals" 1998e17cf54345a4e9ab0ded690cdb41c0cd219c8eAlkis Evlogimenos#include "LiveIntervals.h" 20015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner#include "llvm/Value.h" 216b4edbaaf9021e0434f0ce0c3724eb43ed41b770Alkis Evlogimenos#include "llvm/Analysis/LoopInfo.h" 22ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/CodeGen/LiveVariables.h" 23ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/CodeGen/MachineFrameInfo.h" 24ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/CodeGen/MachineInstr.h" 25ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/CodeGen/Passes.h" 26ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/CodeGen/SSARegMap.h" 27ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/Target/MRegisterInfo.h" 28ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/Target/TargetInstrInfo.h" 29ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "llvm/Target/TargetMachine.h" 30e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos#include "Support/CommandLine.h" 31ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "Support/Debug.h" 32ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include "Support/Statistic.h" 33843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos#include "Support/STLExtras.h" 345f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos#include "VirtRegMap.h" 354d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos#include <cmath> 36ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos#include <iostream> 37ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 38ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosusing namespace llvm; 39ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 40ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosnamespace { 41ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos RegisterAnalysis<LiveIntervals> X("liveintervals", 42ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos "Live Interval Analysis"); 43ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 44007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numIntervals 45007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of original intervals"); 46007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 47007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numIntervalsAfter 48007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of intervals after coalescing"); 49007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 50007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numJoins 51007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of interval joins performed"); 52007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 53007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numPeep 54007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of identity moves eliminated after coalescing"); 55007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 56007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numFolded 57d6f6d1a80daf89ad0bddc4b8335e1b2ae1ec3410Alkis Evlogimenos ("liveintervals", "Number of loads/stores folded into instructions"); 58007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 59e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cl::opt<bool> 60e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner EnableJoining("join-liveintervals", 61e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner cl::desc("Join compatible live intervals"), 62e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner cl::init(true)); 63ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos}; 64ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 65ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::getAnalysisUsage(AnalysisUsage &AU) const 66ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 67f6f91bf6680668990ff3804b14cf05beedc56ec4Alkis Evlogimenos AU.addPreserved<LiveVariables>(); 68ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos AU.addRequired<LiveVariables>(); 69f6f91bf6680668990ff3804b14cf05beedc56ec4Alkis Evlogimenos AU.addPreservedID(PHIEliminationID); 70ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos AU.addRequiredID(PHIEliminationID); 714c080863de86448d905beab27686da823b6d44c1Alkis Evlogimenos AU.addRequiredID(TwoAddressInstructionPassID); 726b4edbaaf9021e0434f0ce0c3724eb43ed41b770Alkis Evlogimenos AU.addRequired<LoopInfo>(); 73ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineFunctionPass::getAnalysisUsage(AU); 74ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 75ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 7608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenosvoid LiveIntervals::releaseMemory() 7708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos{ 7808cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos mi2iMap_.clear(); 79843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos i2miMap_.clear(); 8008cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos r2iMap_.clear(); 8108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos r2rMap_.clear(); 8208cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos intervals_.clear(); 8308cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos} 8408cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 8508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 86ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// runOnMachineFunction - Register allocate the whole function 87ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// 88ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosbool LiveIntervals::runOnMachineFunction(MachineFunction &fn) { 89ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mf_ = &fn; 90ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos tm_ = &fn.getTarget(); 91ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mri_ = tm_->getRegisterInfo(); 92ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos lv_ = &getAnalysis<LiveVariables>(); 93ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 94ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // number MachineInstrs 95ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos unsigned miIndex = 0; 96ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineFunction::iterator mbb = mf_->begin(), mbbEnd = mf_->end(); 976097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner mbb != mbbEnd; ++mbb) 98ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), miEnd = mbb->end(); 99ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mi != miEnd; ++mi) { 1006097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner bool inserted = mi2iMap_.insert(std::make_pair(mi, miIndex)).second; 101ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos assert(inserted && "multiple MachineInstr -> index mappings"); 102843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos i2miMap_.push_back(mi); 10339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos miIndex += InstrSlots::NUM; 104ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 105ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 106ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos computeIntervals(); 107ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 108843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos numIntervals += intervals_.size(); 109843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 110843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // join intervals if requested 111e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner if (EnableJoining) joinIntervals(); 112843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 113007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos numIntervalsAfter += intervals_.size(); 114007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 115843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // perform a final pass over the instructions and compute spill 116843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // weights, coalesce virtual registers and remove identity moves 1177a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos const LoopInfo& loopInfo = getAnalysis<LoopInfo>(); 1189bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetInstrInfo& tii = *tm_->getInstrInfo(); 1197a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 120843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 121843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mbbi != mbbe; ++mbbi) { 122843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos MachineBasicBlock* mbb = mbbi; 1237a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos unsigned loopDepth = loopInfo.getLoopDepth(mbb->getBasicBlock()); 1247a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 125843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos for (MachineBasicBlock::iterator mii = mbb->begin(), mie = mbb->end(); 126843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mii != mie; ) { 12743b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos // if the move will be an identity move delete it 128843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos unsigned srcReg, dstReg; 12943b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos if (tii.isMoveInstr(*mii, srcReg, dstReg) && 13043b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos rep(srcReg) == rep(dstReg)) { 1319a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos // remove from def list 132418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval = getOrCreateInterval(rep(dstReg)); 133843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // remove index -> MachineInstr and 134843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // MachineInstr -> index mappings 135843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos Mi2IndexMap::iterator mi2i = mi2iMap_.find(mii); 136843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos if (mi2i != mi2iMap_.end()) { 13739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos i2miMap_[mi2i->second/InstrSlots::NUM] = 0; 138843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mi2iMap_.erase(mi2i); 13908cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos } 140843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mii = mbbi->erase(mii); 141843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos ++numPeep; 1427a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 14343b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos else { 14443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos for (unsigned i = 0; i < mii->getNumOperands(); ++i) { 14543b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos const MachineOperand& mop = mii->getOperand(i); 14643b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos if (mop.isRegister() && mop.getReg() && 14743b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos MRegisterInfo::isVirtualRegister(mop.getReg())) { 14843b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos // replace register with representative register 14943b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos unsigned reg = rep(mop.getReg()); 15043b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos mii->SetMachineOperandReg(i, reg); 15143b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos 15243b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); 15343b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos assert(r2iit != r2iMap_.end()); 15443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos r2iit->second->weight += 15543b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos (mop.isUse() + mop.isDef()) * pow(10.0F, loopDepth); 15643b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 15743b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 158843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos ++mii; 15943b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 1607a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 1617a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 1627a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 1636924063bf2fdcc455bcb87807ab452ab7fc69773Alkis Evlogimenos intervals_.sort(); 16439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** INTERVALS **********\n"); 16501e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos DEBUG(std::copy(intervals_.begin(), intervals_.end(), 166418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner std::ostream_iterator<LiveInterval>(std::cerr, "\n"))); 16739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** MACHINEINSTRS **********\n"); 168843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos DEBUG( 1690f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 1700f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos mbbi != mbbe; ++mbbi) { 171015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner std::cerr << ((Value*)mbbi->getBasicBlock())->getName() << ":\n"; 1720f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos for (MachineBasicBlock::iterator mii = mbbi->begin(), 1730f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos mie = mbbi->end(); mii != mie; ++mii) { 1740f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos std::cerr << getInstructionIndex(mii) << '\t'; 175b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mii->print(std::cerr, tm_); 176843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 177843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos }); 178843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 179ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos return true; 180ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 181ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 18257eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattnernamespace { 18357eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner /// CompareIntervalStar - This is a simple comparison function for interval 18457eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner /// pointers. It compares based on their starting point. 18557eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner struct CompareIntervalStar { 18657eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner bool operator()(LiveInterval *LHS, LiveInterval* RHS) const { 18757eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner return LHS->start() < RHS->start(); 18857eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner } 18957eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner }; 19057eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner} 19157eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner 192418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerstd::vector<LiveInterval*> LiveIntervals::addIntervalsForSpills( 193418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner const LiveInterval& li, 194418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner VirtRegMap& vrm, 195418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner int slot) 196843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos{ 197418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner std::vector<LiveInterval*> added; 19826f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 199a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner assert(li.weight != HUGE_VAL && 200843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos "attempt to spill already spilled interval!"); 201843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 20226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos DEBUG(std::cerr << "\t\t\t\tadding intervals for spills for interval: " 20326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos << li << '\n'); 20426f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 20526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos const TargetRegisterClass* rc = mf_->getSSARegMap()->getRegClass(li.reg); 20639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 207418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner for (LiveInterval::Ranges::const_iterator 2088640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) { 20939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned index = getBaseIndex(i->first); 21039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned end = getBaseIndex(i->second-1) + InstrSlots::NUM; 2118640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner for (; index != end; index += InstrSlots::NUM) { 212843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // skip deleted instructions 2138640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner while (index != end && !getInstructionFromIndex(index)) 2148640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner index += InstrSlots::NUM; 2158640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner if (index == end) break; 2168640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner 21739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos MachineBasicBlock::iterator mi = getInstructionFromIndex(index); 21839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 2195f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos for_operand: 22057eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner for (unsigned i = 0; i != mi->getNumOperands(); ++i) { 221843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos MachineOperand& mop = mi->getOperand(i); 22239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos if (mop.isRegister() && mop.getReg() == li.reg) { 22339354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos if (MachineInstr* fmi = 22439354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mri_->foldMemoryOperand(mi, i, slot)) { 22539354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos lv_->instructionChanged(mi, fmi); 22639354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos vrm.virtFolded(li.reg, mi, fmi); 22739354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mi2iMap_.erase(mi); 22839354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos i2miMap_[index/InstrSlots::NUM] = fmi; 22939354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mi2iMap_[fmi] = index; 23039354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos MachineBasicBlock& mbb = *mi->getParent(); 23139354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mi = mbb.insert(mbb.erase(mi), fmi); 2325f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos ++numFolded; 2335f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos goto for_operand; 2345f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos } 2355f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos else { 2365f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // This is tricky. We need to add information in 2375f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // the interval about the spill code so we have to 2385f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // use our extra load/store slots. 2395f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // 2405f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // If we have a use we are going to have a load so 2415f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // we start the interval from the load slot 2425f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // onwards. Otherwise we start from the def slot. 2435f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos unsigned start = (mop.isUse() ? 2445f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getLoadIndex(index) : 2455f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getDefIndex(index)); 2465f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // If we have a def we are going to have a store 2475f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // right after it so we end the interval after the 2485f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // use of the next instruction. Otherwise we end 2495f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // after the use of this instruction. 2505f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos unsigned end = 1 + (mop.isDef() ? 2518ea13c6233d7dded98d933b435f2727a38149a70Chris Lattner getStoreIndex(index) : 2525f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getUseIndex(index)); 25326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 25426f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // create a new register for this spill 25526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos unsigned nReg = 25626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos mf_->getSSARegMap()->createVirtualRegister(rc); 25726f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos mi->SetMachineOperandReg(i, nReg); 25826f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos vrm.grow(); 25926f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos vrm.assignVirt2StackSlot(nReg, slot); 260418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& nI = getOrCreateInterval(nReg); 26126f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos assert(nI.empty()); 26226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // the spill weight is now infinity as it 26326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // cannot be spilled again 26426f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos nI.weight = HUGE_VAL; 26526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos nI.addRange(start, end); 26626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos added.push_back(&nI); 26726f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // update live variables 268472405e0dc05f6fb8c09af00713ff893fff25b94Chris Lattner lv_->addVirtualRegisterKilled(nReg, mi); 26926f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos DEBUG(std::cerr << "\t\t\t\tadded new interval: " 27026f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos << nI << '\n'); 2715f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos } 272843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 273843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 274843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 275843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 27626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 27757eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // FIXME: This method MUST return intervals in sorted order. If a 27857eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // particular machine instruction both uses and defines the vreg being 27957eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // spilled (e.g., vr = vr + 1) and if the def is processed before the 28057eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // use, the list ends up not sorted. 28157eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // 28257eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // The proper way to fix this is to process all uses of the vreg before we 28357eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // process any defs. However, this would require refactoring the above 28457eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner // blob of code, which I'm not feeling up to right now. 28557eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner std::sort(added.begin(), added.end(), CompareIntervalStar()); 28626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos return added; 287843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos} 288843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 289ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::printRegName(unsigned reg) const 290ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 2914f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos if (MRegisterInfo::isPhysicalRegister(reg)) 292ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos std::cerr << mri_->getName(reg); 293ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos else 29439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos std::cerr << "%reg" << reg; 295ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 296ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 297ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handleVirtualRegisterDef(MachineBasicBlock* mbb, 298ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 299418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval) 300ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 3019a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg)); 3029a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos LiveVariables::VarInfo& vi = lv_->getVarInfo(interval.reg); 303ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 3046097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Virtual registers may be defined multiple times (due to phi 3056097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // elimination). Much of what we do only has to be done once for the vreg. 3066097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // We use an empty interval to detect the first time we see a vreg. 3079a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.empty()) { 3080b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos 3096097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Get the Idx of the defining instructions. 3106097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner unsigned defIndex = getDefIndex(getInstructionIndex(mi)); 3116097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3126097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Loop over all of the blocks that the vreg is defined in. There are 3136097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // two cases we have to handle here. The most common case is a vreg 3146097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // whose lifetime is contained within a basic block. In this case there 3156097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // will be a single kill, in MBB, which comes after the definition. 31674de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner if (vi.Kills.size() == 1 && vi.Kills[0]->getParent() == mbb) { 3176097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // FIXME: what about dead vars? 3186097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner unsigned killIdx; 31974de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner if (vi.Kills[0] != mi) 32074de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner killIdx = getUseIndex(getInstructionIndex(vi.Kills[0]))+1; 3216097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner else 3226097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner killIdx = defIndex+1; 3236097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3246097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // If the kill happens after the definition, we have an intra-block 3256097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live range. 3266097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner if (killIdx > defIndex) { 3276097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner assert(vi.AliveBlocks.empty() && 3286097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner "Shouldn't be alive across any blocks!"); 3296097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner interval.addRange(defIndex, killIdx); 3306097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner return; 3316097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3326097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3336097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3346097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // The other case we handle is when a virtual register lives to the end 3356097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // of the defining block, potentially live across some blocks, then is 3366097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live into some number of blocks, but gets killed. Start by adding a 3376097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // range that goes from this definition to the end of the defining block. 3386097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner interval.addRange(defIndex, 3396097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner getInstructionIndex(&mbb->back()) + InstrSlots::NUM); 3406097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3416097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Iterate over all of the blocks that the variable is completely 3426097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live in, adding [insrtIndex(begin), instrIndex(end)+4) to the 3436097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live interval. 3446097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner for (unsigned i = 0, e = vi.AliveBlocks.size(); i != e; ++i) { 3456097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner if (vi.AliveBlocks[i]) { 3466097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner MachineBasicBlock* mbb = mf_->getBlockNumbered(i); 3476097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner if (!mbb->empty()) { 3486097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner interval.addRange( 3496097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner getInstructionIndex(&mbb->front()), 3506097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner getInstructionIndex(&mbb->back()) + InstrSlots::NUM); 3516097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3526097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3536097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3546097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3556097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Finally, this virtual register is live from the start of any killing 3566097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // block to the 'use' slot of the killing instruction. 3576097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner for (unsigned i = 0, e = vi.Kills.size(); i != e; ++i) { 35874de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner MachineInstr *Kill = vi.Kills[i]; 35974de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner interval.addRange(getInstructionIndex(Kill->getParent()->begin()), 36074de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner getUseIndex(getInstructionIndex(Kill))+1); 3616097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3626097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3636097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } else { 3646097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // If this is the second time we see a virtual register definition, it 3656097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // must be due to phi elimination. In this case, the defined value will 3666097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // be live until the end of the basic block it is defined in. 3676097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner unsigned defIndex = getDefIndex(getInstructionIndex(mi)); 3686097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner interval.addRange(defIndex, 3696097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner getInstructionIndex(&mbb->back()) + InstrSlots::NUM); 370dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 371ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 37239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << '\n'); 373ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 374ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 375ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handlePhysicalRegisterDef(MachineBasicBlock* mbb, 376ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 377418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval) 378ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 379607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // A physical register cannot be live across basic block, so its 380607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // lifetime must end somewhere in its defining basic block. 3819a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg)); 38239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos typedef LiveVariables::killed_iterator KillIter; 383ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 38402ba13c9897ae2b19f9201e57460d7ee2b753a0bAlkis Evlogimenos MachineBasicBlock::iterator e = mbb->end(); 38539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned baseIndex = getInstructionIndex(mi); 38639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned start = getDefIndex(baseIndex); 38739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned end = start; 3884d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos 389607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // If it is not used after definition, it is considered dead at 390607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // the instruction defining it. Hence its interval is: 391607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // [defSlot(def), defSlot(def)+1) 392c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (KillIter ki = lv_->dead_begin(mi), ke = lv_->dead_end(mi); 393af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos ki != ke; ++ki) { 3949a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.reg == ki->second) { 39539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " dead"); 39639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos end = getDefIndex(start) + 1; 397af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos goto exit; 398af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos } 399af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos } 400ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 401607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // If it is not dead on definition, it must be killed by a 402607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // subsequent instruction. Hence its interval is: 40380b27ced2d5e6340bb62d75a8c6f23198e69a1afAlkis Evlogimenos // [defSlot(def), useSlot(kill)+1) 404230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner do { 405230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner ++mi; 40639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos baseIndex += InstrSlots::NUM; 407c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (KillIter ki = lv_->killed_begin(mi), ke = lv_->killed_end(mi); 4084d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos ki != ke; ++ki) { 4099a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.reg == ki->second) { 41039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " killed"); 41139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos end = getUseIndex(baseIndex) + 1; 4124d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos goto exit; 413ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 4144d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos } 415230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner } while (mi != e); 41602ba13c9897ae2b19f9201e57460d7ee2b753a0bAlkis Evlogimenos 417ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosexit: 418230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner assert(start < end && "did not find end of interval?"); 4199a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos interval.addRange(start, end); 42039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << '\n'); 421ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 422ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 423ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handleRegisterDef(MachineBasicBlock* mbb, 424ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 425ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos unsigned reg) 426ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 4274f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos if (MRegisterInfo::isPhysicalRegister(reg)) { 4281a119e24106810310825f44c7bfd232d3272e639Alkis Evlogimenos if (lv_->getAllocatablePhysicalRegisters()[reg]) { 4299a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos handlePhysicalRegisterDef(mbb, mi, getOrCreateInterval(reg)); 43019b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos for (const unsigned* as = mri_->getAliasSet(reg); *as; ++as) 4319a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos handlePhysicalRegisterDef(mbb, mi, getOrCreateInterval(*as)); 432ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 433ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 4349a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos else 4359a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos handleVirtualRegisterDef(mbb, mi, getOrCreateInterval(reg)); 436ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 437ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 4384d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenosunsigned LiveIntervals::getInstructionIndex(MachineInstr* instr) const 4394d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos{ 440843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos Mi2IndexMap::const_iterator it = mi2iMap_.find(instr); 44139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos return (it == mi2iMap_.end() ? 44239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos std::numeric_limits<unsigned>::max() : 44339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos it->second); 444843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos} 445843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 446843b160a2040b3ec4d3452678450afa11704c473Alkis EvlogimenosMachineInstr* LiveIntervals::getInstructionFromIndex(unsigned index) const 447843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos{ 44839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos index /= InstrSlots::NUM; // convert index to vector index 449843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos assert(index < i2miMap_.size() && 450843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos "index does not correspond to an instruction"); 451843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos return i2miMap_[index]; 4524d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos} 4534d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos 454ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// computeIntervals - computes the live intervals for virtual 4554d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos/// registers. for some ordering of the machine instructions [1,N] a 45608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos/// live interval is an interval [i, j) where 1 <= i <= j < N for 457ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// which a variable is live 458ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::computeIntervals() 459ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 46039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** COMPUTING LIVE INTERVALS **********\n"); 46139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** Function: " 462015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner << ((Value*)mf_->getFunction())->getName() << '\n'); 463ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 4646097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); 4656097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner I != E; ++I) { 4666097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner MachineBasicBlock* mbb = I; 467015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner DEBUG(std::cerr << ((Value*)mbb->getBasicBlock())->getName() << ":\n"); 4686b4edbaaf9021e0434f0ce0c3724eb43ed41b770Alkis Evlogimenos 469ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), miEnd = mbb->end(); 470ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mi != miEnd; ++mi) { 471ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos const TargetInstrDescriptor& tid = 4729bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner tm_->getInstrInfo()->get(mi->getOpcode()); 47339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << getInstructionIndex(mi) << "\t"; 474b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mi->print(std::cerr, tm_)); 475ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 476ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // handle implicit defs 47719b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos for (const unsigned* id = tid.ImplicitDefs; *id; ++id) 47819b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos handleRegisterDef(mbb, mi, *id); 479ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 480ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // handle explicit defs 481c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (int i = mi->getNumOperands() - 1; i >= 0; --i) { 482c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos MachineOperand& mop = mi->getOperand(i); 48308cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // handle register defs - build intervals 48471e353ed3530a5da48c3dd3257c410f6c4ce2e3eAlkis Evlogimenos if (mop.isRegister() && mop.getReg() && mop.isDef()) 485be766c72464116a445a02b542a450c4274bab5d0Alkis Evlogimenos handleRegisterDef(mbb, mi, mop.getReg()); 486ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 487ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 488ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 489ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 490b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos 491e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenosunsigned LiveIntervals::rep(unsigned reg) 492169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos{ 493e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Reg2RegMap::iterator it = r2rMap_.find(reg); 494e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos if (it != r2rMap_.end()) 495e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return it->second = rep(it->second); 496e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return reg; 497169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos} 498169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 4991c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattnervoid LiveIntervals::joinIntervalsInMachineBB(MachineBasicBlock *MBB) { 5001c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner DEBUG(std::cerr << ((Value*)MBB->getBasicBlock())->getName() << ":\n"); 5019bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetInstrInfo& tii = *tm_->getInstrInfo(); 502dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 5031c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner for (MachineBasicBlock::iterator mi = MBB->begin(), mie = MBB->end(); 5041c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner mi != mie; ++mi) { 5051c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner const TargetInstrDescriptor& tid = tii.get(mi->getOpcode()); 5061c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner DEBUG(std::cerr << getInstructionIndex(mi) << '\t'; 5071c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner mi->print(std::cerr, tm_);); 5081c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5091c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // we only join virtual registers with allocatable 5101c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // physical registers since we do not have liveness information 5111c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // on not allocatable physical registers 5121c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner unsigned regA, regB; 5131c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (tii.isMoveInstr(*mi, regA, regB) && 5141c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner (MRegisterInfo::isVirtualRegister(regA) || 5151c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner lv_->getAllocatablePhysicalRegisters()[regA]) && 5161c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner (MRegisterInfo::isVirtualRegister(regB) || 5171c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner lv_->getAllocatablePhysicalRegisters()[regB])) { 5181c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5191c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // get representative registers 5201c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner regA = rep(regA); 5211c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner regB = rep(regB); 5221c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5231c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // if they are already joined we continue 5241c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (regA == regB) 5251c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner continue; 5261c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5271c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner Reg2IntervalMap::iterator r2iA = r2iMap_.find(regA); 5281c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner assert(r2iA != r2iMap_.end() && 5291c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner "Found unknown vreg in 'isMoveInstr' instruction"); 5301c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner Reg2IntervalMap::iterator r2iB = r2iMap_.find(regB); 5311c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner assert(r2iB != r2iMap_.end() && 5321c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner "Found unknown vreg in 'isMoveInstr' instruction"); 5331c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5341c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner Intervals::iterator intA = r2iA->second; 5351c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner Intervals::iterator intB = r2iB->second; 5361c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5371c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // both A and B are virtual registers 5381c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (MRegisterInfo::isVirtualRegister(intA->reg) && 5391c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner MRegisterInfo::isVirtualRegister(intB->reg)) { 5401c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5411c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner const TargetRegisterClass *rcA, *rcB; 5421c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner rcA = mf_->getSSARegMap()->getRegClass(intA->reg); 5431c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner rcB = mf_->getSSARegMap()->getRegClass(intB->reg); 5441c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // if they are not of the same register class we continue 5451c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (rcA != rcB) 546e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos continue; 547e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 5481c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // if their intervals do not overlap we join them 5491c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (!intB->overlaps(*intA)) { 5501c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner intA->join(*intB); 5511c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner r2iB->second = r2iA->second; 5521c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner r2rMap_.insert(std::make_pair(intB->reg, intA->reg)); 5531c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner intervals_.erase(intB); 5541c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner } 5551c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner } else if (MRegisterInfo::isPhysicalRegister(intA->reg) ^ 5561c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner MRegisterInfo::isPhysicalRegister(intB->reg)) { 5571c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (MRegisterInfo::isPhysicalRegister(intB->reg)) { 5581c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner std::swap(regA, regB); 5591c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner std::swap(intA, intB); 5601c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner std::swap(r2iA, r2iB); 5611c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner } 56201e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos 5631c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner assert(MRegisterInfo::isPhysicalRegister(intA->reg) && 5641c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner MRegisterInfo::isVirtualRegister(intB->reg) && 5651c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner "A must be physical and B must be virtual"); 5661c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5671c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner const TargetRegisterClass *rcA, *rcB; 5681c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner rcA = mri_->getRegClass(intA->reg); 5691c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner rcB = mf_->getSSARegMap()->getRegClass(intB->reg); 5701c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner // if they are not of the same register class we continue 5711c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (rcA != rcB) 5721c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner continue; 5731c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 5741c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner if (!intA->overlaps(*intB) && 5751c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner !overlapsAliases(*intA, *intB)) { 5761c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner intA->join(*intB); 5771c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner r2iB->second = r2iA->second; 5781c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner r2rMap_.insert(std::make_pair(intB->reg, intA->reg)); 5791c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner intervals_.erase(intB); 580e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 581e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 582e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 583dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 584dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos} 585dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 586cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattnernamespace { 587cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // DepthMBBCompare - Comparison predicate that sort first based on the loop 588cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // depth of the basic block (the unsigned), and then on the MBB number. 589cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner struct DepthMBBCompare { 590cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner typedef std::pair<unsigned, MachineBasicBlock*> DepthMBBPair; 591cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner bool operator()(const DepthMBBPair &LHS, const DepthMBBPair &RHS) const { 592cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner if (LHS.first > RHS.first) return true; // Deeper loops first 593cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner return LHS.first == RHS.first && 594cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner LHS.second->getNumber() < RHS.second->getNumber(); 595cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner } 596cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner }; 597cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner} 598cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner 599cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattnervoid LiveIntervals::joinIntervals() { 600cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner DEBUG(std::cerr << "********** JOINING INTERVALS ***********\n"); 6011c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 602cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner const LoopInfo &LI = getAnalysis<LoopInfo>(); 603cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner if (LI.begin() == LI.end()) { 604cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // If there are no loops in the function, join intervals in function order. 6051c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); 6061c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner I != E; ++I) 6071c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner joinIntervalsInMachineBB(I); 608cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner } else { 609cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Otherwise, join intervals in inner loops before other intervals. 610cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Unfortunately we can't just iterate over loop hierarchy here because 611cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // there may be more MBB's than BB's. Collect MBB's for sorting. 612cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner std::vector<std::pair<unsigned, MachineBasicBlock*> > MBBs; 613cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); 614cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner I != E; ++I) 615cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner MBBs.push_back(std::make_pair(LI.getLoopDepth(I->getBasicBlock()), I)); 616cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner 617cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Sort by loop depth. 618cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner std::sort(MBBs.begin(), MBBs.end(), DepthMBBCompare()); 619cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner 620cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Finally, join intervals in loop nest order. 621cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner for (unsigned i = 0, e = MBBs.size(); i != e; ++i) 622cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner joinIntervalsInMachineBB(MBBs[i].second); 623cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner } 6241c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner} 6251c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 626418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveIntervals::overlapsAliases(const LiveInterval& lhs, 627418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner const LiveInterval& rhs) const 62879b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos{ 6294f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos assert(MRegisterInfo::isPhysicalRegister(lhs.reg) && 63079b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos "first interval must describe a physical register"); 63179b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 63279b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos for (const unsigned* as = mri_->getAliasSet(lhs.reg); *as; ++as) { 63379b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos Reg2IntervalMap::const_iterator r2i = r2iMap_.find(*as); 63479b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos assert(r2i != r2iMap_.end() && "alias does not have interval?"); 63579b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos if (rhs.overlaps(*r2i->second)) 63679b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos return true; 63779b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos } 63879b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 63979b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos return false; 64079b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos} 64179b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 642418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval& LiveIntervals::getOrCreateInterval(unsigned reg) 6439a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos{ 6449a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg); 6459a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (r2iit == r2iMap_.end() || r2iit->first != reg) { 646418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner intervals_.push_back(LiveInterval(reg)); 6479a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos r2iit = r2iMap_.insert(r2iit, std::make_pair(reg, --intervals_.end())); 6489a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos } 6499a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 6509a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos return *r2iit->second; 6519a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos} 6529a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 653418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval::LiveInterval(unsigned r) 654e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos : reg(r), 655a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner weight((MRegisterInfo::isPhysicalRegister(r) ? HUGE_VAL : 0.0F)) 656dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos{ 657dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos} 658dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 659418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveInterval::spilled() const 66039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos{ 661a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner return (weight == HUGE_VAL && 66239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos MRegisterInfo::isVirtualRegister(reg)); 66339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos} 66439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 6650b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos// An example for liveAt(): 66608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 66739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// this = [1,4), liveAt(0) will return false. The instruction defining 66839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// this spans slots [0,3]. The interval belongs to an spilled 66939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// definition of the variable it represents. This is because slot 1 is 67039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// used (def slot) and spans up to slot 3 (store slot). 67108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 672418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveInterval::liveAt(unsigned index) const 673169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos{ 67497017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Range dummy(index, index+1); 67597017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Ranges::const_iterator r = std::upper_bound(ranges.begin(), 67697017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos ranges.end(), 67797017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos dummy); 67897017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (r == ranges.begin()) 67997017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos return false; 68097017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos 68197017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos --r; 6820b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos return index >= r->first && index < r->second; 683169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos} 684169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 6850b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos// An example for overlaps(): 68608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 68708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 0: A = ... 68839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// 4: B = ... 68939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// 8: C = A + B ;; last use of A 69008cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 69108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// The live intervals should look like: 69208cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 69339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// A = [3, 11) 69439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// B = [7, x) 69539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// C = [11, y) 69608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 69708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// A->overlaps(C) should return false since we want to be able to join 69808cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// A and C. 699418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveInterval::overlaps(const LiveInterval& other) const 700169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos{ 70180b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos Ranges::const_iterator i = ranges.begin(); 70297017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Ranges::const_iterator ie = ranges.end(); 70380b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos Ranges::const_iterator j = other.ranges.begin(); 70497017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Ranges::const_iterator je = other.ranges.end(); 70597017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i->first < j->first) { 70697017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos i = std::upper_bound(i, ie, *j); 70797017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i != ranges.begin()) --i; 70897017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 70997017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos else if (j->first < i->first) { 71097017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos j = std::upper_bound(j, je, *i); 71197017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (j != other.ranges.begin()) --j; 71297017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 71397017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos 71497017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos while (i != ie && j != je) { 71597017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i->first == j->first) { 71697017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos return true; 71797017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 71897017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos else { 71997017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i->first > j->first) { 72097017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos swap(i, j); 72197017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos swap(ie, je); 72297017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 72397017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos assert(i->first < j->first); 72480b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos 7250b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos if (i->second > j->first) { 72680b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos return true; 72780b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos } 72880b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos else { 72980b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos ++i; 73080b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos } 73180b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos } 732169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos } 733169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 734169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos return false; 735169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos} 736169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 737418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnervoid LiveInterval::addRange(unsigned start, unsigned end) 738e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 73908cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos assert(start < end && "Invalid range to add!"); 74039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " +[" << start << ',' << end << ")"); 741e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos //assert(start < end && "invalid range?"); 742e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Range range = std::make_pair(start, end); 743e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Ranges::iterator it = 744e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos ranges.insert(std::upper_bound(ranges.begin(), ranges.end(), range), 745e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos range); 746e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 747e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos it = mergeRangesForward(it); 748e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos it = mergeRangesBackward(it); 749e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 750e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 751418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnervoid LiveInterval::join(const LiveInterval& other) 752e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 7536097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner DEBUG(std::cerr << "\t\tjoining " << *this << " with " << other); 754e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Ranges::iterator cur = ranges.begin(); 755e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 756e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos for (Ranges::const_iterator i = other.ranges.begin(), 757e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos e = other.ranges.end(); i != e; ++i) { 758e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cur = ranges.insert(std::upper_bound(cur, ranges.end(), *i), *i); 759e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cur = mergeRangesForward(cur); 760e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cur = mergeRangesBackward(cur); 761e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 762cea44711203cfcb3b18528401ac1ad170677ebfeAlkis Evlogimenos weight += other.weight; 763cea44711203cfcb3b18528401ac1ad170677ebfeAlkis Evlogimenos ++numJoins; 7646097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner DEBUG(std::cerr << ". Result = " << *this << "\n"); 765e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 766e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 767418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval::Ranges::iterator LiveInterval:: 768418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnermergeRangesForward(Ranges::iterator it) 769e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 7707200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos Ranges::iterator n; 7717200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos while ((n = next(it)) != ranges.end()) { 7727200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos if (n->first > it->second) 7737200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos break; 77423c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it->second = std::max(it->second, n->second); 77523c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos n = ranges.erase(n); 776e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 777e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return it; 778e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 779e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 780418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval::Ranges::iterator LiveInterval:: 781418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnermergeRangesBackward(Ranges::iterator it) 782e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 78308cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos while (it != ranges.begin()) { 78423c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos Ranges::iterator p = prior(it); 7857200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos if (it->first > p->second) 7867200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos break; 78708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 78823c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it->first = std::min(it->first, p->first); 78923c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it->second = std::max(it->second, p->second); 79023c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it = ranges.erase(p); 791e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 792e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 793e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return it; 794e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 795e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 796418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerstd::ostream& llvm::operator<<(std::ostream& os, const LiveInterval& li) 797b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos{ 7989a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos os << "%reg" << li.reg << ',' << li.weight; 79939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos if (li.empty()) 80039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos return os << "EMPTY"; 8019a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 8029a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos os << " = "; 803418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner for (LiveInterval::Ranges::const_iterator 804b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) { 80563841bc85d15ca0ce1b3208084f4262f3d33ef21Alkis Evlogimenos os << "[" << i->first << "," << i->second << ")"; 806b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos } 807b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos return os; 808b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos} 809