LiveIntervalAnalysis.cpp revision 80b27ced2d5e6340bb62d75a8c6f23198e69a1af
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> 60e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos join("join-liveintervals", 61e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cl::desc("Join compatible live intervals"), 623877652e683cc85dd3cd512d6af0accbce84cad5Alkis Evlogimenos cl::init(false)); 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 mbbi2mbbMap_.clear(); 7908cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos mi2iMap_.clear(); 80843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos i2miMap_.clear(); 8108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos r2iMap_.clear(); 8208cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos r2rMap_.clear(); 8308cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos intervals_.clear(); 8408cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos} 8508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 8608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 87ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// runOnMachineFunction - Register allocate the whole function 88ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// 89ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosbool LiveIntervals::runOnMachineFunction(MachineFunction &fn) { 90ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mf_ = &fn; 91ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos tm_ = &fn.getTarget(); 92ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mri_ = tm_->getRegisterInfo(); 93ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos lv_ = &getAnalysis<LiveVariables>(); 94ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 95ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // number MachineInstrs 96ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos unsigned miIndex = 0; 97ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineFunction::iterator mbb = mf_->begin(), mbbEnd = mf_->end(); 98ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mbb != mbbEnd; ++mbb) { 998ba9771549bcff6109ad45ff3944a1b6c3c54b46Chris Lattner unsigned mbbIdx = mbb->getNumber(); 100015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner bool inserted = mbbi2mbbMap_.insert(std::make_pair(mbbIdx, 101015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner mbb)).second; 102ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos assert(inserted && "multiple index -> MachineBasicBlock"); 103ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 104ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), miEnd = mbb->end(); 105ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mi != miEnd; ++mi) { 106c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos inserted = mi2iMap_.insert(std::make_pair(mi, miIndex)).second; 107ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos assert(inserted && "multiple MachineInstr -> index mappings"); 108843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos i2miMap_.push_back(mi); 10939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos miIndex += InstrSlots::NUM; 110ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 111ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 112ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 113ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos computeIntervals(); 114ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 115843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos numIntervals += intervals_.size(); 116843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 117843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // join intervals if requested 118843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos if (join) joinIntervals(); 119843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 120007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos numIntervalsAfter += intervals_.size(); 121007726ca6f64ea74c20ddb90093ee8d6801733afAlkis Evlogimenos 122843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // perform a final pass over the instructions and compute spill 123843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // weights, coalesce virtual registers and remove identity moves 1247a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos const LoopInfo& loopInfo = getAnalysis<LoopInfo>(); 1259bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetInstrInfo& tii = *tm_->getInstrInfo(); 1267a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 127843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 128843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mbbi != mbbe; ++mbbi) { 129843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos MachineBasicBlock* mbb = mbbi; 1307a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos unsigned loopDepth = loopInfo.getLoopDepth(mbb->getBasicBlock()); 1317a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 132843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos for (MachineBasicBlock::iterator mii = mbb->begin(), mie = mbb->end(); 133843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mii != mie; ) { 13443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos // if the move will be an identity move delete it 135843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos unsigned srcReg, dstReg; 13643b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos if (tii.isMoveInstr(*mii, srcReg, dstReg) && 13743b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos rep(srcReg) == rep(dstReg)) { 1389a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos // remove from def list 139418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval = getOrCreateInterval(rep(dstReg)); 140843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // remove index -> MachineInstr and 141843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // MachineInstr -> index mappings 142843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos Mi2IndexMap::iterator mi2i = mi2iMap_.find(mii); 143843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos if (mi2i != mi2iMap_.end()) { 14439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos i2miMap_[mi2i->second/InstrSlots::NUM] = 0; 145843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mi2iMap_.erase(mi2i); 14608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos } 147843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos mii = mbbi->erase(mii); 148843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos ++numPeep; 1497a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 15043b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos else { 15143b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos for (unsigned i = 0; i < mii->getNumOperands(); ++i) { 15243b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos const MachineOperand& mop = mii->getOperand(i); 15343b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos if (mop.isRegister() && mop.getReg() && 15443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos MRegisterInfo::isVirtualRegister(mop.getReg())) { 15543b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos // replace register with representative register 15643b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos unsigned reg = rep(mop.getReg()); 15743b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos mii->SetMachineOperandReg(i, reg); 15843b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos 15943b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos Reg2IntervalMap::iterator r2iit = r2iMap_.find(reg); 16043b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos assert(r2iit != r2iMap_.end()); 16143b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos r2iit->second->weight += 16243b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos (mop.isUse() + mop.isDef()) * pow(10.0F, loopDepth); 16343b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 16443b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 165843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos ++mii; 16643b61f724ef68810c63fc54c99e88f9b278f05c0Alkis Evlogimenos } 1677a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 1687a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos } 1697a40eaaceec0af76d5b97610f3d4e7a47a19d245Alkis Evlogimenos 1706924063bf2fdcc455bcb87807ab452ab7fc69773Alkis Evlogimenos intervals_.sort(); 17139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** INTERVALS **********\n"); 17201e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos DEBUG(std::copy(intervals_.begin(), intervals_.end(), 173418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner std::ostream_iterator<LiveInterval>(std::cerr, "\n"))); 17439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** MACHINEINSTRS **********\n"); 175843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos DEBUG( 1760f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 1770f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos mbbi != mbbe; ++mbbi) { 178015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner std::cerr << ((Value*)mbbi->getBasicBlock())->getName() << ":\n"; 1790f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos for (MachineBasicBlock::iterator mii = mbbi->begin(), 1800f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos mie = mbbi->end(); mii != mie; ++mii) { 1810f338a1e8cd8167d22e2d011e0bec7eaadc6154aAlkis Evlogimenos std::cerr << getInstructionIndex(mii) << '\t'; 182b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mii->print(std::cerr, tm_); 183843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 184843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos }); 185843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 186ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos return true; 187ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 188ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 189418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerstd::vector<LiveInterval*> LiveIntervals::addIntervalsForSpills( 190418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner const LiveInterval& li, 191418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner VirtRegMap& vrm, 192418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner int slot) 193843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos{ 194418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner std::vector<LiveInterval*> added; 19526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 196a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner assert(li.weight != HUGE_VAL && 197843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos "attempt to spill already spilled interval!"); 198843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 19926f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos DEBUG(std::cerr << "\t\t\t\tadding intervals for spills for interval: " 20026f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos << li << '\n'); 20126f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 20226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos const TargetRegisterClass* rc = mf_->getSSARegMap()->getRegClass(li.reg); 20339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 204418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner for (LiveInterval::Ranges::const_iterator 20526f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) { 20639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned index = getBaseIndex(i->first); 20739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned end = getBaseIndex(i->second-1) + InstrSlots::NUM; 20839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos for (; index < end; index += InstrSlots::NUM) { 209843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos // skip deleted instructions 21039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos while (!getInstructionFromIndex(index)) index += InstrSlots::NUM; 21139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos MachineBasicBlock::iterator mi = getInstructionFromIndex(index); 21239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 2135f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos for_operand: 214843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 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() ? 2455f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos getUseIndex(index+InstrSlots::NUM) : 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; 25926f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos nI.addRange(start, end); 26026f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos added.push_back(&nI); 26126f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos // update live variables 26226f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos lv_->addVirtualRegisterKilled(nReg, mi->getParent(),mi); 26326f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos DEBUG(std::cerr << "\t\t\t\tadded new interval: " 26426f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos << nI << '\n'); 2655f37502bfbadfa65de087627bd67fd58bb03725cAlkis Evlogimenos } 266843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 267843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 268843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 269843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos } 27026f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos 27126f5a69e52b64e035d26c135979a39b39fd6ba3eAlkis Evlogimenos return added; 272843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos} 273843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 274ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::printRegName(unsigned reg) const 275ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 2764f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos if (MRegisterInfo::isPhysicalRegister(reg)) 277ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos std::cerr << mri_->getName(reg); 278ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos else 27939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos std::cerr << "%reg" << reg; 280ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 281ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 282ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handleVirtualRegisterDef(MachineBasicBlock* mbb, 283ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 284418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval) 285ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 2869a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg)); 2879a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos LiveVariables::VarInfo& vi = lv_->getVarInfo(interval.reg); 288ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 289607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // Iterate over all of the blocks that the variable is completely 290607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // live in, adding [insrtIndex(begin), instrIndex(end)+4) to the 291607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // live interval. Obviously we only need to do this once. 2929a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.empty()) { 293ad48cd6327df13ad4b8530733bbf115224bf9562Alkis Evlogimenos for (unsigned i = 0, e = vi.AliveBlocks.size(); i != e; ++i) { 294ad48cd6327df13ad4b8530733bbf115224bf9562Alkis Evlogimenos if (vi.AliveBlocks[i]) { 2958490f9c92e354fd9cd242bae89b24e6c59e5c794Chris Lattner MachineBasicBlock* mbb = mf_->getBlockNumbered(i); 296ad48cd6327df13ad4b8530733bbf115224bf9562Alkis Evlogimenos if (!mbb->empty()) { 2979a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos interval.addRange( 29839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos getInstructionIndex(&mbb->front()), 29939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos getInstructionIndex(&mbb->back()) + InstrSlots::NUM); 300ad48cd6327df13ad4b8530733bbf115224bf9562Alkis Evlogimenos } 30152220f61bba91ab787d4cc0aee47df4e2ca55c04Alkis Evlogimenos } 302ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 303dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 304ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 30539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned baseIndex = getInstructionIndex(mi); 3060b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos 307dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos bool killedInDefiningBasicBlock = false; 308dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos for (int i = 0, e = vi.Kills.size(); i != e; ++i) { 309dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos MachineBasicBlock* killerBlock = vi.Kills[i].first; 310dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos MachineInstr* killerInstr = vi.Kills[i].second; 311dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos unsigned start = (mbb == killerBlock ? 31239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos getDefIndex(baseIndex) : 313c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos getInstructionIndex(&killerBlock->front())); 314c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos unsigned end = (killerInstr == mi ? 31539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos // dead 31639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos start + 1 : 31739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos // killed 31839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos getUseIndex(getInstructionIndex(killerInstr))+1); 31908cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // we do not want to add invalid ranges. these can happen when 32008cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // a variable has its latest use and is redefined later on in 32108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // the same basic block (common with variables introduced by 32208cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // PHI elimination) 32343f692f90f6b27304570e1b1807542dff4b8e847Alkis Evlogimenos if (start < end) { 32443f692f90f6b27304570e1b1807542dff4b8e847Alkis Evlogimenos killedInDefiningBasicBlock |= mbb == killerBlock; 3259a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos interval.addRange(start, end); 32643f692f90f6b27304570e1b1807542dff4b8e847Alkis Evlogimenos } 327dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 328ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 329dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos if (!killedInDefiningBasicBlock) { 33039a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned end = getInstructionIndex(&mbb->back()) + InstrSlots::NUM; 3319a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos interval.addRange(getDefIndex(baseIndex), end); 332ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 33339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << '\n'); 334ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 335ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 336ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handlePhysicalRegisterDef(MachineBasicBlock* mbb, 337ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 338418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner LiveInterval& interval) 339ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 340607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // A physical register cannot be live across basic block, so its 341607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // lifetime must end somewhere in its defining basic block. 3429a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg)); 34339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos typedef LiveVariables::killed_iterator KillIter; 344ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 34502ba13c9897ae2b19f9201e57460d7ee2b753a0bAlkis Evlogimenos MachineBasicBlock::iterator e = mbb->end(); 34639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned baseIndex = getInstructionIndex(mi); 34739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned start = getDefIndex(baseIndex); 34839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos unsigned end = start; 3494d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos 350607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // If it is not used after definition, it is considered dead at 351607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // the instruction defining it. Hence its interval is: 352607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // [defSlot(def), defSlot(def)+1) 353c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (KillIter ki = lv_->dead_begin(mi), ke = lv_->dead_end(mi); 354af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos ki != ke; ++ki) { 3559a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.reg == ki->second) { 35639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " dead"); 35739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos end = getDefIndex(start) + 1; 358af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos goto exit; 359af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos } 360af25473d5e99e0c0968746e12d8827e4b712bd31Alkis Evlogimenos } 361ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 362607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // If it is not dead on definition, it must be killed by a 363607baea7d2f3155a4ca391a1d9fb1f4b0178ebb2Alkis Evlogimenos // subsequent instruction. Hence its interval is: 36480b27ced2d5e6340bb62d75a8c6f23198e69a1afAlkis Evlogimenos // [defSlot(def), useSlot(kill)+1) 365230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner do { 366230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner ++mi; 36739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos baseIndex += InstrSlots::NUM; 368c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (KillIter ki = lv_->killed_begin(mi), ke = lv_->killed_end(mi); 3694d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos ki != ke; ++ki) { 3709a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (interval.reg == ki->second) { 37139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " killed"); 37239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos end = getUseIndex(baseIndex) + 1; 3734d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos goto exit; 374ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 3754d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos } 376230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner } while (mi != e); 37702ba13c9897ae2b19f9201e57460d7ee2b753a0bAlkis Evlogimenos 378ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosexit: 379230b4fb8a0d7b2b0e0d533cf37b05a084d140a5cChris Lattner assert(start < end && "did not find end of interval?"); 3809a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos interval.addRange(start, end); 38139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << '\n'); 382ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 383ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 384ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::handleRegisterDef(MachineBasicBlock* mbb, 385ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock::iterator mi, 386ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos unsigned reg) 387ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 3884f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos if (MRegisterInfo::isPhysicalRegister(reg)) { 3891a119e24106810310825f44c7bfd232d3272e639Alkis Evlogimenos if (lv_->getAllocatablePhysicalRegisters()[reg]) { 3909a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos handlePhysicalRegisterDef(mbb, mi, getOrCreateInterval(reg)); 39119b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos for (const unsigned* as = mri_->getAliasSet(reg); *as; ++as) 3929a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos handlePhysicalRegisterDef(mbb, mi, getOrCreateInterval(*as)); 393ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 394ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 3959a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos else 3969a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos handleVirtualRegisterDef(mbb, mi, getOrCreateInterval(reg)); 397ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 398ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 3994d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenosunsigned LiveIntervals::getInstructionIndex(MachineInstr* instr) const 4004d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos{ 401843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos Mi2IndexMap::const_iterator it = mi2iMap_.find(instr); 40239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos return (it == mi2iMap_.end() ? 40339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos std::numeric_limits<unsigned>::max() : 40439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos it->second); 405843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos} 406843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos 407843b160a2040b3ec4d3452678450afa11704c473Alkis EvlogimenosMachineInstr* LiveIntervals::getInstructionFromIndex(unsigned index) const 408843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos{ 40939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos index /= InstrSlots::NUM; // convert index to vector index 410843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos assert(index < i2miMap_.size() && 411843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos "index does not correspond to an instruction"); 412843b160a2040b3ec4d3452678450afa11704c473Alkis Evlogimenos return i2miMap_[index]; 4134d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos} 4144d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos 415ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// computeIntervals - computes the live intervals for virtual 4164d46e1e521c0df1990ea50f8146d22bd77ea71a6Alkis Evlogimenos/// registers. for some ordering of the machine instructions [1,N] a 41708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos/// live interval is an interval [i, j) where 1 <= i <= j < N for 418ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos/// which a variable is live 419ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenosvoid LiveIntervals::computeIntervals() 420ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos{ 42139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** COMPUTING LIVE INTERVALS **********\n"); 42239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** Function: " 423015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner << ((Value*)mf_->getFunction())->getName() << '\n'); 424ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 425ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MbbIndex2MbbMap::iterator 426ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos it = mbbi2mbbMap_.begin(), itEnd = mbbi2mbbMap_.end(); 427ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos it != itEnd; ++it) { 428ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos MachineBasicBlock* mbb = it->second; 429015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner DEBUG(std::cerr << ((Value*)mbb->getBasicBlock())->getName() << ":\n"); 4306b4edbaaf9021e0434f0ce0c3724eb43ed41b770Alkis Evlogimenos 431ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), miEnd = mbb->end(); 432ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos mi != miEnd; ++mi) { 433ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos const TargetInstrDescriptor& tid = 4349bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner tm_->getInstrInfo()->get(mi->getOpcode()); 43539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << getInstructionIndex(mi) << "\t"; 436b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mi->print(std::cerr, tm_)); 437ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 438ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // handle implicit defs 43919b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos for (const unsigned* id = tid.ImplicitDefs; *id; ++id) 44019b6486d3891c8a02a301aa1b44348a420772fcfAlkis Evlogimenos handleRegisterDef(mbb, mi, *id); 441ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos 442ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos // handle explicit defs 443c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (int i = mi->getNumOperands() - 1; i >= 0; --i) { 444c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos MachineOperand& mop = mi->getOperand(i); 44508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos // handle register defs - build intervals 44671e353ed3530a5da48c3dd3257c410f6c4ce2e3eAlkis Evlogimenos if (mop.isRegister() && mop.getReg() && mop.isDef()) 447be766c72464116a445a02b542a450c4274bab5d0Alkis Evlogimenos handleRegisterDef(mbb, mi, mop.getReg()); 448ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 449ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 450ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos } 451ff0cbe175df40e0d2b36e59c6fb72f211f1cba4cAlkis Evlogimenos} 452b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos 453e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenosunsigned LiveIntervals::rep(unsigned reg) 454169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos{ 455e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Reg2RegMap::iterator it = r2rMap_.find(reg); 456e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos if (it != r2rMap_.end()) 457e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return it->second = rep(it->second); 458e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return reg; 459169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos} 460169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 461e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenosvoid LiveIntervals::joinIntervals() 462dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos{ 46339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "********** JOINING INTERVALS ***********\n"); 464dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 4659bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetInstrInfo& tii = *tm_->getInstrInfo(); 466dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 467c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (MachineFunction::iterator mbbi = mf_->begin(), mbbe = mf_->end(); 468c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos mbbi != mbbe; ++mbbi) { 469c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos MachineBasicBlock* mbb = mbbi; 470015959ee38e4fd4a920f6b0065c50e524762f580Chris Lattner DEBUG(std::cerr << ((Value*)mbb->getBasicBlock())->getName() << ":\n"); 471e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 472c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos for (MachineBasicBlock::iterator mi = mbb->begin(), mie = mbb->end(); 473c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos mi != mie; ++mi) { 4749bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetInstrDescriptor& tid = tii.get(mi->getOpcode()); 47539a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << getInstructionIndex(mi) << '\t'; 476b140762a45d21aaed054f15adaff0fc2274d939dTanya Lattner mi->print(std::cerr, tm_);); 477e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 47801e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos // we only join virtual registers with allocatable 47901e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos // physical registers since we do not have liveness information 48001e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos // on not allocatable physical registers 48101e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos unsigned regA, regB; 48201e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos if (tii.isMoveInstr(*mi, regA, regB) && 48301e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos (MRegisterInfo::isVirtualRegister(regA) || 48401e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos lv_->getAllocatablePhysicalRegisters()[regA]) && 48501e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos (MRegisterInfo::isVirtualRegister(regB) || 48601e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos lv_->getAllocatablePhysicalRegisters()[regB])) { 487e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 488e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos // get representative registers 48901e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos regA = rep(regA); 49001e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos regB = rep(regB); 491e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 492e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos // if they are already joined we continue 49301e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos if (regA == regB) 494e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos continue; 495e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 49601e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos Reg2IntervalMap::iterator r2iA = r2iMap_.find(regA); 49701e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos assert(r2iA != r2iMap_.end()); 49801e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos Reg2IntervalMap::iterator r2iB = r2iMap_.find(regB); 49901e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos assert(r2iB != r2iMap_.end()); 50001e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos 50101e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos Intervals::iterator intA = r2iA->second; 50201e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos Intervals::iterator intB = r2iB->second; 50301e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos 50401e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos // both A and B are virtual registers 50501e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos if (MRegisterInfo::isVirtualRegister(intA->reg) && 50601e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos MRegisterInfo::isVirtualRegister(intB->reg)) { 50701e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos 50801e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos const TargetRegisterClass *rcA, *rcB; 50901e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos rcA = mf_->getSSARegMap()->getRegClass(intA->reg); 51001e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos rcB = mf_->getSSARegMap()->getRegClass(intB->reg); 5115de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos // if they are not of the same register class we continue 5125de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos if (rcA != rcB) 5135de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos continue; 51401e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos 51501e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos // if their intervals do not overlap we join them 51601e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos if (!intB->overlaps(*intA)) { 51701e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos intA->join(*intB); 51801e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos r2iB->second = r2iA->second; 51901e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos r2rMap_.insert(std::make_pair(intB->reg, intA->reg)); 52001e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos intervals_.erase(intB); 521e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 522e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 523b0b0ebaac09a930f7cbd302255fa23c5d8107e66Alkis Evlogimenos else if (MRegisterInfo::isPhysicalRegister(intA->reg) ^ 52401e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos MRegisterInfo::isPhysicalRegister(intB->reg)) { 52501e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos if (MRegisterInfo::isPhysicalRegister(intB->reg)) { 52601e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos std::swap(regA, regB); 52701e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos std::swap(intA, intB); 52801e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos std::swap(r2iA, r2iB); 529e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 53001e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos 53101e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos assert(MRegisterInfo::isPhysicalRegister(intA->reg) && 53201e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos MRegisterInfo::isVirtualRegister(intB->reg) && 53301e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos "A must be physical and B must be virtual"); 534676cf8cb1d613d626f826a45b44658ae35f58c7cAlkis Evlogimenos 5355de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos const TargetRegisterClass *rcA, *rcB; 5365de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos rcA = mri_->getRegClass(intA->reg); 5375de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos rcB = mf_->getSSARegMap()->getRegClass(intB->reg); 5385de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos // if they are not of the same register class we continue 5395de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos if (rcA != rcB) 5405de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos continue; 5415de868b0b2daf145d7991bc9b3bf25807bcc7ca7Alkis Evlogimenos 54201e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos if (!intA->overlaps(*intB) && 5439a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos !overlapsAliases(*intA, *intB)) { 54401e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos intA->join(*intB); 54501e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos r2iB->second = r2iA->second; 54601e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos r2rMap_.insert(std::make_pair(intB->reg, intA->reg)); 54701e74a2aab64c5901a62d9ba9e1c263759929390Alkis Evlogimenos intervals_.erase(intB); 548e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 549e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 550e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 551e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 552dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos } 553dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos} 554dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 555418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveIntervals::overlapsAliases(const LiveInterval& lhs, 556418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner const LiveInterval& rhs) const 55779b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos{ 5584f67b8664889d9e93b452a9a5f099d41d1bd235aAlkis Evlogimenos assert(MRegisterInfo::isPhysicalRegister(lhs.reg) && 55979b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos "first interval must describe a physical register"); 56079b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 56179b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos for (const unsigned* as = mri_->getAliasSet(lhs.reg); *as; ++as) { 56279b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos Reg2IntervalMap::const_iterator r2i = r2iMap_.find(*as); 56379b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos assert(r2i != r2iMap_.end() && "alias does not have interval?"); 56479b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos if (rhs.overlaps(*r2i->second)) 56579b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos return true; 56679b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos } 56779b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 56879b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos return false; 56979b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos} 57079b0c3f0b9d91bbda354a2c6f22b6578655a5143Alkis Evlogimenos 571418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval& LiveIntervals::getOrCreateInterval(unsigned reg) 5729a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos{ 5739a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos Reg2IntervalMap::iterator r2iit = r2iMap_.lower_bound(reg); 5749a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos if (r2iit == r2iMap_.end() || r2iit->first != reg) { 575418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner intervals_.push_back(LiveInterval(reg)); 5769a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos r2iit = r2iMap_.insert(r2iit, std::make_pair(reg, --intervals_.end())); 5779a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos } 5789a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 5799a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos return *r2iit->second; 5809a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos} 5819a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 582418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval::LiveInterval(unsigned r) 583e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos : reg(r), 584a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner weight((MRegisterInfo::isPhysicalRegister(r) ? HUGE_VAL : 0.0F)) 585dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos{ 586dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos} 587dd2cc65f34f9b7bfda1cd0c42becedfc361d46f8Alkis Evlogimenos 588418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveInterval::spilled() const 58939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos{ 590a19eedeb7aafc418ef2f017b8215ceafa7f1a76cChris Lattner return (weight == HUGE_VAL && 59139a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos MRegisterInfo::isVirtualRegister(reg)); 59239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos} 59339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos 5940b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos// An example for liveAt(): 59508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 59639a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// this = [1,4), liveAt(0) will return false. The instruction defining 59739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// this spans slots [0,3]. The interval belongs to an spilled 59839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// definition of the variable it represents. This is because slot 1 is 59939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// used (def slot) and spans up to slot 3 (store slot). 60008cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 601418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveInterval::liveAt(unsigned index) const 602169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos{ 60397017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Range dummy(index, index+1); 60497017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Ranges::const_iterator r = std::upper_bound(ranges.begin(), 60597017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos ranges.end(), 60697017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos dummy); 60797017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (r == ranges.begin()) 60897017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos return false; 60997017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos 61097017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos --r; 6110b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos return index >= r->first && index < r->second; 612169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos} 613169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 6140b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos// An example for overlaps(): 61508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 61608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 0: A = ... 61739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// 4: B = ... 61839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// 8: C = A + B ;; last use of A 61908cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 62008cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// The live intervals should look like: 62108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 62239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// A = [3, 11) 62339a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// B = [7, x) 62439a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos// C = [11, y) 62508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// 62608cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// A->overlaps(C) should return false since we want to be able to join 62708cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos// A and C. 628418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerbool LiveInterval::overlaps(const LiveInterval& other) const 629169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos{ 63080b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos Ranges::const_iterator i = ranges.begin(); 63197017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Ranges::const_iterator ie = ranges.end(); 63280b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos Ranges::const_iterator j = other.ranges.begin(); 63397017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos Ranges::const_iterator je = other.ranges.end(); 63497017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i->first < j->first) { 63597017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos i = std::upper_bound(i, ie, *j); 63697017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i != ranges.begin()) --i; 63797017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 63897017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos else if (j->first < i->first) { 63997017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos j = std::upper_bound(j, je, *i); 64097017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (j != other.ranges.begin()) --j; 64197017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 64297017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos 64397017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos while (i != ie && j != je) { 64497017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i->first == j->first) { 64597017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos return true; 64697017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 64797017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos else { 64897017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos if (i->first > j->first) { 64997017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos swap(i, j); 65097017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos swap(ie, je); 65197017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos } 65297017de1872e08ffcdde2fccdfd399647c1ccc4aAlkis Evlogimenos assert(i->first < j->first); 65380b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos 6540b8cb2bc47a6bee59c8c3f46d4cc047badf7f8acAlkis Evlogimenos if (i->second > j->first) { 65580b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos return true; 65680b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos } 65780b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos else { 65880b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos ++i; 65980b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos } 66080b378cf7c3dce77029dc3118e1f63bc6d389da1Alkis Evlogimenos } 661169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos } 662169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 663169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos return false; 664169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos} 665169cfd01964fc03828a7f2cad5d710890fbb08d8Alkis Evlogimenos 666418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnervoid LiveInterval::addRange(unsigned start, unsigned end) 667e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 66808cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos assert(start < end && "Invalid range to add!"); 66939a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << " +[" << start << ',' << end << ")"); 670e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos //assert(start < end && "invalid range?"); 671e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Range range = std::make_pair(start, end); 672e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Ranges::iterator it = 673e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos ranges.insert(std::upper_bound(ranges.begin(), ranges.end(), range), 674e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos range); 675e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 676e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos it = mergeRangesForward(it); 677e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos it = mergeRangesBackward(it); 678e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 679e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 680418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnervoid LiveInterval::join(const LiveInterval& other) 681e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 68239a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos DEBUG(std::cerr << "\t\tjoining " << *this << " with " << other << '\n'); 683e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos Ranges::iterator cur = ranges.begin(); 684e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 685e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos for (Ranges::const_iterator i = other.ranges.begin(), 686e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos e = other.ranges.end(); i != e; ++i) { 687e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cur = ranges.insert(std::upper_bound(cur, ranges.end(), *i), *i); 688e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cur = mergeRangesForward(cur); 689e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos cur = mergeRangesBackward(cur); 690e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 691cea44711203cfcb3b18528401ac1ad170677ebfeAlkis Evlogimenos weight += other.weight; 692cea44711203cfcb3b18528401ac1ad170677ebfeAlkis Evlogimenos ++numJoins; 693e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 694e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 695418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval::Ranges::iterator LiveInterval:: 696418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnermergeRangesForward(Ranges::iterator it) 697e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 6987200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos Ranges::iterator n; 6997200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos while ((n = next(it)) != ranges.end()) { 7007200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos if (n->first > it->second) 7017200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos break; 70223c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it->second = std::max(it->second, n->second); 70323c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos n = ranges.erase(n); 704e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 705e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return it; 706e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 707e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 708418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnerLiveInterval::Ranges::iterator LiveInterval:: 709418da55c89c9ba355b51dceecb16f4388ef35119Chris LattnermergeRangesBackward(Ranges::iterator it) 710e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos{ 71108cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos while (it != ranges.begin()) { 71223c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos Ranges::iterator p = prior(it); 7137200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos if (it->first > p->second) 7147200c6b82acb8401048a2bc8a423f23b48db6731Alkis Evlogimenos break; 71508cec00588ec1a8fa85b208555f006d7396ae7a4Alkis Evlogimenos 71623c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it->first = std::min(it->first, p->first); 71723c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it->second = std::max(it->second, p->second); 71823c114fd3bec342ac1a2a45801b892d6b4517afcAlkis Evlogimenos it = ranges.erase(p); 719e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos } 720e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 721e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos return it; 722e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos} 723e88280a4224730dcf8076e0d9a20973c5761fd06Alkis Evlogimenos 724418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattnerstd::ostream& llvm::operator<<(std::ostream& os, const LiveInterval& li) 725b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos{ 7269a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos os << "%reg" << li.reg << ',' << li.weight; 72739a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos if (li.empty()) 72839a0d5c1123cfe4ddf826690b6744cc7248e3149Alkis Evlogimenos return os << "EMPTY"; 7299a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos 7309a8b490735d216435862a3d52e669357f165550fAlkis Evlogimenos os << " = "; 731418da55c89c9ba355b51dceecb16f4388ef35119Chris Lattner for (LiveInterval::Ranges::const_iterator 732b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos i = li.ranges.begin(), e = li.ranges.end(); i != e; ++i) { 73363841bc85d15ca0ce1b3208084f4262f3d33ef21Alkis Evlogimenos os << "[" << i->first << "," << i->second << ")"; 734b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos } 735b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos return os; 736b27ef248f579b354aab434f63c417ab1103e47e2Alkis Evlogimenos} 737