LiveIntervalAnalysis.cpp revision 7ac2d3146a196fa0120c579ecd2ddd69652ad230
1a3b8b5c0e0a1d0942288568b2012592184ca67c5Chris Lattner//===-- LiveIntervalAnalysis.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" 19a3b8b5c0e0a1d0942288568b2012592184ca67c5Chris Lattner#include "LiveIntervalAnalysis.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 37ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosusing namespace llvm; 38ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 39ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosnamespace { 40ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos RegisterAnalysis<LiveIntervals> X("liveintervals", 41ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos "Live Interval Analysis"); 42ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 43007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numIntervals 44007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of original intervals"); 45007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 46007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numIntervalsAfter 47007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of intervals after coalescing"); 48007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 49007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numJoins 50007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of interval joins performed"); 51007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 52007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numPeep 53007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos ("liveintervals", "Number of identity moves eliminated after coalescing"); 54007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 55007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos Statistic<> numFolded 56d6f6d1a80daf89ad0bddc4b8335e1b2ae1ec3410Alkis Evlogimenos ("liveintervals", "Number of loads/stores folded into instructions"); 57007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 58e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cl::opt<bool> 59e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner EnableJoining("join-liveintervals", 60e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner cl::desc("Join compatible live intervals"), 61e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner cl::init(true)); 62ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos}; 63ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 64ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::getAnalysisUsage(AnalysisUsage &AU) const 65ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 66f6f91bf6680668990ff3804b14cf05beedc56ec4Alkis Evlogimenos AU.addPreserved<LiveVariables>(); 67ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos AU.addRequired<LiveVariables>(); 68f6f91bf6680668990ff3804b14cf05beedc56ec4Alkis Evlogimenos AU.addPreservedID(PHIEliminationID); 69ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos AU.addRequiredID(PHIEliminationID); 704c080863de86448d905beab27686da823b6d44c1Alkis Evlogimenos AU.addRequiredID(TwoAddressInstructionPassID); 716b4edbaaf9021e0434f0ce0c3724eb43ed41b770Alkis Evlogimenos AU.addRequired<LoopInfo>(); 72ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineFunctionPass::getAnalysisUsage(AU); 73ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 74ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 7508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenosvoid LiveIntervals::releaseMemory() 7608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos{ 7708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos mi2iMap_.clear(); 78843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos i2miMap_.clear(); 7908cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos r2iMap_.clear(); 8008cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos r2rMap_.clear(); 8108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos intervals_.clear(); 8208cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos} 8308cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 8408cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 85ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// runOnMachineFunction - Register allocate the whole function 86ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// 87ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosbool LiveIntervals::runOnMachineFunction(MachineFunction &fn) { 88ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mf_ = &fn; 89ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos tm_ = &fn.getTarget(); 90ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mri_ = tm_->getRegisterInfo(); 91ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos lv_ = &getAnalysis<LiveVariables>(); 92ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 93ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // number MachineInstrs 94ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos unsigned miIndex = 0; 95ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineFunction::iterator mbb = mf_->begin(), mbbEnd = mf_->end(); 966097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner mbb != mbbEnd; ++mbb) 97ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), miEnd = mbb->end(); 98ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mi != miEnd; ++mi) { 996097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner bool inserted = mi2iMap_.insert(std::make_pair(mi, miIndex)).second; 100ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos assert(inserted && "multiple MachineInstr -> index mappings"); 101843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos i2miMap_.push_back(mi); 10239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos miIndex += InstrSlots::NUM; 103ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 104ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 105ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos computeIntervals(); 106ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 107843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos numIntervals += intervals_.size(); 108843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 1097ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner#if 1 1107ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << "********** INTERVALS **********\n"); 1117ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::copy(intervals_.begin(), intervals_.end(), 1127ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner std::ostream_iterator<LiveInterval>(std::cerr, "\n"))); 1137ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner#endif 1147ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 115843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // join intervals if requested 116e1b9536d546b78f8cffc7efbb2ff75d7e15f9749Chris Lattner if (EnableJoining) joinIntervals(); 117843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 118007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos numIntervalsAfter += intervals_.size(); 119007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 120843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // perform a final pass over the instructions and compute spill 121843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // weights, coalesce virtual registers and remove identity moves 1227a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos const LoopInfo& loopInfo = getAnalysis<LoopInfo>(); 1239bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetInstrInfo& tii = *tm_->getInstrInfo(); 1247a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 125843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 126843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mbbi != mbbe; ++mbbi) { 127843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos MachineBasicBlock* mbb = mbbi; 1287a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos unsigned loopDepth = loopInfo.getLoopDepth(mbb->getBasicBlock()); 1297a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 130843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos for (MachineBasicBlock::iterator mii = mbb->begin(), mie = mbb->end(); 131843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mii != mie; ) { 13243b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos // if the move will be an identity move delete it 133843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos unsigned srcReg, dstReg; 13443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos if (tii.isMoveInstr(*mii, srcReg, dstReg) && 13543b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos rep(srcReg) == rep(dstReg)) { 1369a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos // remove from def list 137418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval = getOrCreateInterval(rep(dstReg)); 138843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // remove index -> MachineInstr and 139843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // MachineInstr -> index mappings 140843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos Mi2IndexMap::iterator mi2i = mi2iMap_.find(mii); 141843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos if (mi2i != mi2iMap_.end()) { 14239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos i2miMap_[mi2i->second/InstrSlots::NUM] = 0; 143843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mi2iMap_.erase(mi2i); 14408cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos } 145843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mii = mbbi->erase(mii); 146843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos ++numPeep; 1477a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 14843b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos else { 14943b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos for (unsigned i = 0; i < mii->getNumOperands(); ++i) { 15043b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos const MachineOperand& mop = mii->getOperand(i); 15143b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos if (mop.isRegister() && mop.getReg() && 15243b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos MRegisterInfo::isVirtualRegister(mop.getReg())) { 15343b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos // replace register with representative register 15443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos unsigned reg = rep(mop.getReg()); 15543b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos mii->SetMachineOperandReg(i, reg); 15643b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos 15743b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); 15843b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos assert(r2iit != r2iMap_.end()); 15943b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos r2iit->second->weight += 16043b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos (mop.isUse() + mop.isDef()) * pow(10.0F, loopDepth); 16143b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 16243b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 163843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos ++mii; 16443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 1657a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 1667a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 1677a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 16839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** INTERVALS **********\n"); 16901e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos DEBUG(std::copy(intervals_.begin(), intervals_.end(), 170418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner std::ostream_iterator<LiveInterval>(std::cerr, "\n"))); 17139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** MACHINEINSTRS **********\n"); 172843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos DEBUG( 1730f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 1740f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos mbbi != mbbe; ++mbbi) { 175015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner std::cerr << ((Value*)mbbi->getBasicBlock())->getName() << ":\n"; 1760f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos for (MachineBasicBlock::iterator mii = mbbi->begin(), 1770f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos mie = mbbi->end(); mii != mie; ++mii) { 1780f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos std::cerr << getInstructionIndex(mii) << '\t'; 179b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mii->print(std::cerr, tm_); 180843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 181843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos }); 182843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 183ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos return true; 184ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 185ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 186418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerstd::vector<LiveInterval*> LiveIntervals::addIntervalsForSpills( 187418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner const LiveInterval& li, 188418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner VirtRegMap& vrm, 189418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner int slot) 190843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos{ 191418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner std::vector<LiveInterval*> added; 19226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 193a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner assert(li.weight != HUGE_VAL && 194843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos "attempt to spill already spilled interval!"); 195843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 19626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos DEBUG(std::cerr << "\t\t\t\tadding intervals for spills for interval: " 19726f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos << li << '\n'); 19826f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 19926f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos const TargetRegisterClass* rc = mf_->getSSARegMap()->getRegClass(li.reg); 20039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 201418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner for (LiveInterval::Ranges::const_iterator 2028640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) { 203ec2bc645053e9051ada01fac6a555df17a85c91dChris Lattner unsigned index = getBaseIndex(i->start); 204ec2bc645053e9051ada01fac6a555df17a85c91dChris Lattner unsigned end = getBaseIndex(i->end-1) + InstrSlots::NUM; 2058640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner for (; index != end; index += InstrSlots::NUM) { 206843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // skip deleted instructions 2078640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner while (index != end && !getInstructionFromIndex(index)) 2088640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner index += InstrSlots::NUM; 2098640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner if (index == end) break; 2108640f4e666086cc6e7447dc164105e428e6cb81aChris Lattner 21139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos MachineBasicBlock::iterator mi = getInstructionFromIndex(index); 21239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 2135f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos for_operand: 21457eb15e316c8f186b988dea7f8962ffa827d4a71Chris Lattner for (unsigned i = 0; i != mi->getNumOperands(); ++i) { 215843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos MachineOperand& mop = mi->getOperand(i); 21639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos if (mop.isRegister() && mop.getReg() == li.reg) { 21739354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos if (MachineInstr* fmi = 21839354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mri_->foldMemoryOperand(mi, i, slot)) { 21939354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos lv_->instructionChanged(mi, fmi); 22039354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos vrm.virtFolded(li.reg, mi, fmi); 22139354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mi2iMap_.erase(mi); 22239354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos i2miMap_[index/InstrSlots::NUM] = fmi; 22339354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mi2iMap_[fmi] = index; 22439354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos MachineBasicBlock& mbb = *mi->getParent(); 22539354c99a158685d8bc91b0836c283e936a29cb2Alkis Evlogimenos mi = mbb.insert(mbb.erase(mi), fmi); 2265f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos ++numFolded; 2275f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos goto for_operand; 2285f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos } 2295f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos else { 2305f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // This is tricky. We need to add information in 2315f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // the interval about the spill code so we have to 2325f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // use our extra load/store slots. 2335f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // 2345f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // If we have a use we are going to have a load so 2355f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // we start the interval from the load slot 2365f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // onwards. Otherwise we start from the def slot. 2375f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos unsigned start = (mop.isUse() ? 2385f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getLoadIndex(index) : 2395f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getDefIndex(index)); 2405f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // If we have a def we are going to have a store 2415f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // right after it so we end the interval after the 2425f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // use of the next instruction. Otherwise we end 2435f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos // after the use of this instruction. 2445f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos unsigned end = 1 + (mop.isDef() ? 2458ea13c6233d7dded98d933b435f2727a38149a70Chris Lattner getStoreIndex(index) : 2465f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getUseIndex(index)); 24726f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 24826f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // create a new register for this spill 24926f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos unsigned nReg = 25026f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos mf_->getSSARegMap()->createVirtualRegister(rc); 25126f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos mi->SetMachineOperandReg(i, nReg); 25226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos vrm.grow(); 25326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos vrm.assignVirt2StackSlot(nReg, slot); 254418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& nI = getOrCreateInterval(nReg); 25526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos assert(nI.empty()); 25626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // the spill weight is now infinity as it 25726f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // cannot be spilled again 25826f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos nI.weight = HUGE_VAL; 2597ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner LiveRange LR(start, end, nI.getNextValue()); 2607ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << " +" << LR); 2617ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner nI.addRange(LR); 26226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos added.push_back(&nI); 26326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // update live variables 264472405e0dc05f6fb8c09af00713ff893fff25b94Chris Lattner lv_->addVirtualRegisterKilled(nReg, mi); 26526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos DEBUG(std::cerr << "\t\t\t\tadded new interval: " 26626f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos << nI << '\n'); 2675f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos } 268843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 269843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 270843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 271843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 27226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 27326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos return added; 274843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos} 275843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 276ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::printRegName(unsigned reg) const 277ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 2784f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos if (MRegisterInfo::isPhysicalRegister(reg)) 279ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos std::cerr << mri_->getName(reg); 280ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos else 28139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos std::cerr << "%reg" << reg; 282ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 283ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 284ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handleVirtualRegisterDef(MachineBasicBlock* mbb, 285ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 286418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval) 287ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 2889a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg)); 2899a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos LiveVariables::VarInfo& vi = lv_->getVarInfo(interval.reg); 290ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 2916097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Virtual registers may be defined multiple times (due to phi 2926beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // elimination and 2-addr elimination). Much of what we do only has to be 2936beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // done once for the vreg. We use an empty interval to detect the first 2946beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // time we see a vreg. 2959a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.empty()) { 2966097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Get the Idx of the defining instructions. 2976097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner unsigned defIndex = getDefIndex(getInstructionIndex(mi)); 2986097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 2997ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner unsigned ValNum = interval.getNextValue(); 3007ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner assert(ValNum == 0 && "First value in interval is not 0?"); 3017ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner ValNum = 0; // Clue in the optimizer. 3027ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 3036097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Loop over all of the blocks that the vreg is defined in. There are 3046097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // two cases we have to handle here. The most common case is a vreg 3056097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // whose lifetime is contained within a basic block. In this case there 3066097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // will be a single kill, in MBB, which comes after the definition. 30774de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner if (vi.Kills.size() == 1 && vi.Kills[0]->getParent() == mbb) { 3086097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // FIXME: what about dead vars? 3096097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner unsigned killIdx; 31074de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner if (vi.Kills[0] != mi) 31174de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner killIdx = getUseIndex(getInstructionIndex(vi.Kills[0]))+1; 3126097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner else 3136097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner killIdx = defIndex+1; 3146097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3156097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // If the kill happens after the definition, we have an intra-block 3166097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live range. 3176097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner if (killIdx > defIndex) { 3186097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner assert(vi.AliveBlocks.empty() && 3196097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner "Shouldn't be alive across any blocks!"); 3207ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner LiveRange LR(defIndex, killIdx, ValNum); 3217ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner interval.addRange(LR); 3227ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << " +" << LR << "\n"); 3236097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner return; 3246097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3256097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3266097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3276097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // The other case we handle is when a virtual register lives to the end 3286097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // of the defining block, potentially live across some blocks, then is 3296097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live into some number of blocks, but gets killed. Start by adding a 3306097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // range that goes from this definition to the end of the defining block. 331fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner LiveRange NewLR(defIndex, getInstructionIndex(&mbb->back()) + 3327ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner InstrSlots::NUM, ValNum); 333fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner DEBUG(std::cerr << " +" << NewLR); 334fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner interval.addRange(NewLR); 3356097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3366097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Iterate over all of the blocks that the variable is completely 3376097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live in, adding [insrtIndex(begin), instrIndex(end)+4) to the 3386097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // live interval. 3396097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner for (unsigned i = 0, e = vi.AliveBlocks.size(); i != e; ++i) { 3406097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner if (vi.AliveBlocks[i]) { 3416097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner MachineBasicBlock* mbb = mf_->getBlockNumbered(i); 3426097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner if (!mbb->empty()) { 343fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner LiveRange LR(getInstructionIndex(&mbb->front()), 3447ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner getInstructionIndex(&mbb->back())+InstrSlots::NUM, 3457ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner ValNum); 346fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner interval.addRange(LR); 347fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner DEBUG(std::cerr << " +" << LR); 3486097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3496097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3506097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3516097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3526097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // Finally, this virtual register is live from the start of any killing 3536097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // block to the 'use' slot of the killing instruction. 3546097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner for (unsigned i = 0, e = vi.Kills.size(); i != e; ++i) { 35574de8b1b26b12fda3364382946e519a2e37b6709Chris Lattner MachineInstr *Kill = vi.Kills[i]; 356fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner LiveRange LR(getInstructionIndex(Kill->getParent()->begin()), 3577ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner getUseIndex(getInstructionIndex(Kill))+1, ValNum); 358fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner interval.addRange(LR); 359fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner DEBUG(std::cerr << " +" << LR); 3606097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } 3616097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner 3626097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner } else { 3636097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner // If this is the second time we see a virtual register definition, it 3646beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // must be due to phi elimination or two addr elimination. If this is 3656beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // the result of two address elimination, then the vreg is the first 3666beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // operand, and is a def-and-use. 3676beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner if (mi->getOperand(0).isRegister() && 3686beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner mi->getOperand(0).getReg() == interval.reg && 3696beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner mi->getOperand(0).isDef() && mi->getOperand(0).isUse()) { 3707ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // If this is a two-address definition, then we have already processed 3717ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // the live range. The only problem is that we didn't realize there 3727ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // are actually two values in the live interval. Because of this we 3737ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // need to take the LiveRegion that defines this register and split it 3747ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // into two values. 3757ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner unsigned DefIndex = getDefIndex(getInstructionIndex(vi.DefInst)); 3767ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner unsigned RedefIndex = getDefIndex(getInstructionIndex(mi)); 3777ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 3787ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // Delete the initial value, which should be short and continuous, 3797ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // becuase the 2-addr copy must be in the same MBB as the redef. 3807ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner interval.removeRange(DefIndex, RedefIndex); 3817ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 3827ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner LiveRange LR(DefIndex, RedefIndex, interval.getNextValue()); 3837ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << " replace range with " << LR); 3847ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner interval.addRange(LR); 3857ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 3867ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // If this redefinition is dead, we need to add a dummy unit live 3877ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // range covering the def slot. 3887ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner for (LiveVariables::killed_iterator KI = lv_->dead_begin(mi), 3897ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner E = lv_->dead_end(mi); KI != E; ++KI) 3907ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (KI->second == interval.reg) { 3917ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner interval.addRange(LiveRange(RedefIndex, RedefIndex+1, 0)); 3927ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner break; 3937ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner } 3947ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 3957ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << "RESULT: " << interval); 3967ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 3976beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner } else { 3986beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // Otherwise, this must be because of phi elimination. In this case, 3996beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // the defined value will be live until the end of the basic block it 4006beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner // is defined in. 4016beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner unsigned defIndex = getDefIndex(getInstructionIndex(mi)); 402fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner LiveRange LR(defIndex, 4037ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner getInstructionIndex(&mbb->back()) + InstrSlots::NUM, 4047ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner interval.getNextValue()); 405fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner interval.addRange(LR); 406fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner DEBUG(std::cerr << " +" << LR); 4076beef3e1a085a0f3693fa6eff1b0b702e2c246e7Chris Lattner } 408dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 409ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 41039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << '\n'); 411ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 412ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 413f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattnervoid LiveIntervals::handlePhysicalRegisterDef(MachineBasicBlock *MBB, 414ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 415418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval) 416ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 417607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // A physical register cannot be live across basic block, so its 418607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // lifetime must end somewhere in its defining basic block. 4199a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg)); 42039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos typedef LiveVariables::killed_iterator KillIter; 421ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 42239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned baseIndex = getInstructionIndex(mi); 42339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned start = getDefIndex(baseIndex); 42439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned end = start; 4254d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos 426607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // If it is not used after definition, it is considered dead at 427607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // the instruction defining it. Hence its interval is: 428607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // [defSlot(def), defSlot(def)+1) 429c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (KillIter ki = lv_->dead_begin(mi), ke = lv_->dead_end(mi); 430af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos ki != ke; ++ki) { 4319a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.reg == ki->second) { 43239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " dead"); 43339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos end = getDefIndex(start) + 1; 434af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos goto exit; 435af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos } 436af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos } 437ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 438607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // If it is not dead on definition, it must be killed by a 439607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // subsequent instruction. Hence its interval is: 44080b27ced2d5e6340bb62d75a8c6f23198e69a1afAlkis Evlogimenos // [defSlot(def), useSlot(kill)+1) 4417ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner while (true) { 442230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner ++mi; 443f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner assert(mi != MBB->end() && "physreg was not killed in defining block!"); 44439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos baseIndex += InstrSlots::NUM; 445c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (KillIter ki = lv_->killed_begin(mi), ke = lv_->killed_end(mi); 4464d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos ki != ke; ++ki) { 4479a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.reg == ki->second) { 44839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " killed"); 44939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos end = getUseIndex(baseIndex) + 1; 4504d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos goto exit; 451ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 4524d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos } 453f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner } 45402ba13c9897ae2b19f9201e57460d7ee2b753a0bAlkis Evlogimenos 455ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosexit: 456230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner assert(start < end && "did not find end of interval?"); 4577ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner LiveRange LR(start, end, interval.getNextValue()); 4587ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner interval.addRange(LR); 4597ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << " +" << LR << '\n'); 460ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 461ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 462f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattnervoid LiveIntervals::handleRegisterDef(MachineBasicBlock *MBB, 463f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner MachineBasicBlock::iterator MI, 464f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner unsigned reg) { 465f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner if (MRegisterInfo::isVirtualRegister(reg)) 466f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner handleVirtualRegisterDef(MBB, MI, getOrCreateInterval(reg)); 467f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner else if (lv_->getAllocatablePhysicalRegisters()[reg]) { 468f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner handlePhysicalRegisterDef(MBB, MI, getOrCreateInterval(reg)); 469f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner for (const unsigned* AS = mri_->getAliasSet(reg); *AS; ++AS) 470f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner handlePhysicalRegisterDef(MBB, MI, getOrCreateInterval(*AS)); 471f35fef7060c465dd7b578bf6339a18e8a8911888Chris Lattner } 4724d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos} 4734d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos 474ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// computeIntervals - computes the live intervals for virtual 4754d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos/// registers. for some ordering of the machine instructions [1,N] a 47608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos/// live interval is an interval [i, j) where 1 <= i <= j < N for 477ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// which a variable is live 478ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::computeIntervals() 479ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 48039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** COMPUTING LIVE INTERVALS **********\n"); 48139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** Function: " 482015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner << ((Value*)mf_->getFunction())->getName() << '\n'); 483ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 4846097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); 4856097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner I != E; ++I) { 4866097d13b2a624048dbe02e39e2dfb23bfa269b64Chris Lattner MachineBasicBlock* mbb = I; 487015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner DEBUG(std::cerr << ((Value*)mbb->getBasicBlock())->getName() << ":\n"); 4886b4edbaaf9021e0434f0ce0c3724eb43ed41b770Alkis Evlogimenos 489ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), miEnd = mbb->end(); 490ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mi != miEnd; ++mi) { 491ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos const TargetInstrDescriptor& tid = 4929bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner tm_->getInstrInfo()->get(mi->getOpcode()); 49339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << getInstructionIndex(mi) << "\t"; 494b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mi->print(std::cerr, tm_)); 495ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 496ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // handle implicit defs 49719b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos for (const unsigned* id = tid.ImplicitDefs; *id; ++id) 49819b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos handleRegisterDef(mbb, mi, *id); 499ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 500ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // handle explicit defs 501c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (int i = mi->getNumOperands() - 1; i >= 0; --i) { 502c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos MachineOperand& mop = mi->getOperand(i); 50308cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // handle register defs - build intervals 50471e353ed3530a5da48c3dd3257c410f6c4ce2e3eAlkis Evlogimenos if (mop.isRegister() && mop.getReg() && mop.isDef()) 505be766c72464116a445a02b542a450c4274bab5d0Alkis Evlogimenos handleRegisterDef(mbb, mi, mop.getReg()); 506ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 507ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 508ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 509ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 510b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos 5111c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattnervoid LiveIntervals::joinIntervalsInMachineBB(MachineBasicBlock *MBB) { 5127ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << ((Value*)MBB->getBasicBlock())->getName() << ":\n"); 5137ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner const TargetInstrInfo &TII = *tm_->getInstrInfo(); 5147ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5157ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner for (MachineBasicBlock::iterator mi = MBB->begin(), mie = MBB->end(); 5167ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner mi != mie; ++mi) { 5177ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << getInstructionIndex(mi) << '\t' << *mi); 5187ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5197ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // we only join virtual registers with allocatable 5207ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // physical registers since we do not have liveness information 5217ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // on not allocatable physical registers 5227ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner unsigned regA, regB; 5237ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (TII.isMoveInstr(*mi, regA, regB) && 5247ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner (MRegisterInfo::isVirtualRegister(regA) || 5257ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner lv_->getAllocatablePhysicalRegisters()[regA]) && 5267ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner (MRegisterInfo::isVirtualRegister(regB) || 5277ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner lv_->getAllocatablePhysicalRegisters()[regB])) { 5287ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5297ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // Get representative registers. 5307ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner regA = rep(regA); 5317ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner regB = rep(regB); 5327ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5337ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // If they are already joined we continue. 5347ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (regA == regB) 5357ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner continue; 5367ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5377ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // If they are both physical registers, we cannot join them. 5387ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (MRegisterInfo::isPhysicalRegister(regA) && 5397ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner MRegisterInfo::isPhysicalRegister(regB)) 5407ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner continue; 5417ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5427ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // If they are not of the same register class, we cannot join them. 5437ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (differingRegisterClasses(regA, regB)) 5447ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner continue; 5457ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5467ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner LiveInterval &IntA = getInterval(regA); 5477ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner LiveInterval &IntB = getInterval(regB); 5487ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner assert(IntA.reg == regA && IntB.reg == regB && 5497ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner "Register mapping is horribly broken!"); 5507ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5517ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner bool TriviallyJoinable = 5527ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner IntA.containsOneValue() && IntB.containsOneValue(); 5537ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5547ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner unsigned MIDefIdx = getDefIndex(getInstructionIndex(mi)); 5557ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if ((TriviallyJoinable || !IntB.joinable(IntA, MIDefIdx)) && 5567ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner !overlapsAliases(&IntA, &IntB)) { 5577ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner IntB.join(IntA, MIDefIdx); 5587ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5597ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // FIXME: Turn 'intervals_' into an ilist so we don't need to do these 5607ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // map lookups! 5617ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner intervals_.erase(r2iMap_[regA]); 5627ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner r2iMap_[regA] = r2iMap_[regB]; 5637ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 5647ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (!MRegisterInfo::isPhysicalRegister(regA)) { 5657ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner r2rMap_[regA] = regB; 5667ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner } else { 5677ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // Otherwise merge the data structures the other way so we don't lose 5687ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // the physreg information. 5697ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner r2rMap_[regB] = regA; 5707ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner IntB.reg = regA; 571e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 5727ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << "Joined. Result = " << IntB << "\n"); 5737ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner ++numJoins; 5747ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner } else { 5757ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner DEBUG(std::cerr << "Interference!\n"); 5767ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner } 577dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 5787ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner } 579dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos} 580dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 581cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattnernamespace { 582cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // DepthMBBCompare - Comparison predicate that sort first based on the loop 583cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // depth of the basic block (the unsigned), and then on the MBB number. 584cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner struct DepthMBBCompare { 585cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner typedef std::pair<unsigned, MachineBasicBlock*> DepthMBBPair; 586cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner bool operator()(const DepthMBBPair &LHS, const DepthMBBPair &RHS) const { 587cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner if (LHS.first > RHS.first) return true; // Deeper loops first 588cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner return LHS.first == RHS.first && 589cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner LHS.second->getNumber() < RHS.second->getNumber(); 590cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner } 591cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner }; 592cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner} 593cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner 594cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattnervoid LiveIntervals::joinIntervals() { 595cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner DEBUG(std::cerr << "********** JOINING INTERVALS ***********\n"); 5961c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 597cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner const LoopInfo &LI = getAnalysis<LoopInfo>(); 598cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner if (LI.begin() == LI.end()) { 599cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // If there are no loops in the function, join intervals in function order. 6001c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); 6011c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner I != E; ++I) 6021c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner joinIntervalsInMachineBB(I); 603cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner } else { 604cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Otherwise, join intervals in inner loops before other intervals. 605cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Unfortunately we can't just iterate over loop hierarchy here because 606cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // there may be more MBB's than BB's. Collect MBB's for sorting. 607cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner std::vector<std::pair<unsigned, MachineBasicBlock*> > MBBs; 608cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner for (MachineFunction::iterator I = mf_->begin(), E = mf_->end(); 609cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner I != E; ++I) 610cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner MBBs.push_back(std::make_pair(LI.getLoopDepth(I->getBasicBlock()), I)); 611cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner 612cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Sort by loop depth. 613cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner std::sort(MBBs.begin(), MBBs.end(), DepthMBBCompare()); 614cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner 615cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner // Finally, join intervals in loop nest order. 616cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner for (unsigned i = 0, e = MBBs.size(); i != e; ++i) 617cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner joinIntervalsInMachineBB(MBBs[i].second); 618cc0d156f7bca0811aade0a95b0e7419176383c90Chris Lattner } 6191c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner} 6201c5c0444f1326b58cf05015651f36f2b04ca322dChris Lattner 6217ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner/// Return true if the two specified registers belong to different register 6227ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner/// classes. The registers may be either phys or virt regs. 6237ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattnerbool LiveIntervals::differingRegisterClasses(unsigned RegA, 6247ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner unsigned RegB) const { 6257ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner const TargetRegisterClass *RegClass; 6267ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 6277ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // Get the register classes for the first reg. 6287ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (MRegisterInfo::isVirtualRegister(RegA)) 6297ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner RegClass = mf_->getSSARegMap()->getRegClass(RegA); 6307ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner else 6317ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner RegClass = mri_->getRegClass(RegA); 6327ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 6337ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner // Compare against the regclass for the second reg. 6347ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (MRegisterInfo::isVirtualRegister(RegB)) 6357ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner return RegClass != mf_->getSSARegMap()->getRegClass(RegB); 6367ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner else 6377ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner return RegClass != mri_->getRegClass(RegB); 6387ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner} 6397ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 6407ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattnerbool LiveIntervals::overlapsAliases(const LiveInterval *LHS, 6417ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner const LiveInterval *RHS) const { 6427ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (!MRegisterInfo::isPhysicalRegister(LHS->reg)) { 6437ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (!MRegisterInfo::isPhysicalRegister(RHS->reg)) 6447ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner return false; // vreg-vreg merge has no aliases! 6457ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner std::swap(LHS, RHS); 6467ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner } 6477ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner 6487ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner assert(MRegisterInfo::isPhysicalRegister(LHS->reg) && 6497ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner MRegisterInfo::isVirtualRegister(RHS->reg) && 6507ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner "first interval must describe a physical register"); 65179b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 6527ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner for (const unsigned *AS = mri_->getAliasSet(LHS->reg); *AS; ++AS) { 6537ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner Reg2IntervalMap::const_iterator r2i = r2iMap_.find(*AS); 65479b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos assert(r2i != r2iMap_.end() && "alias does not have interval?"); 6557ac2d3146a196fa0120c579ecd2ddd69652ad230Chris Lattner if (RHS->overlaps(*r2i->second)) 65679b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos return true; 65779b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos } 65879b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 65979b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos return false; 66079b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos} 66179b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 662418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval& LiveIntervals::getOrCreateInterval(unsigned reg) 6639a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos{ 6649a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg); 6659a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (r2iit == r2iMap_.end() || r2iit->first != reg) { 666fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner float Weight = MRegisterInfo::isPhysicalRegister(reg) ? HUGE_VAL :0.0F; 667fb449b9ea5a37fb411aee7d42f6a76119602288dChris Lattner intervals_.push_back(LiveInterval(reg, Weight)); 6689a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos r2iit = r2iMap_.insert(r2iit, std::make_pair(reg, --intervals_.end())); 6699a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos } 6709a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 6719a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos return *r2iit->second; 6729a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos} 6739a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 674