aboutsummaryrefslogtreecommitdiffstats
path: root/lib
diff options
context:
space:
mode:
authorOwen Anderson <resistor@mac.com>2009-01-26 19:18:06 +0000
committerOwen Anderson <resistor@mac.com>2009-01-26 19:18:06 +0000
commitd7250517b06250ca942847dfd6e51ede261c24c9 (patch)
treef32de1ae1d900a676f4ed58a37e9948b29e1cad7 /lib
parent8af1e761f824ca46088780c2fbe1de9e4278f06c (diff)
downloadexternal_llvm-d7250517b06250ca942847dfd6e51ede261c24c9.zip
external_llvm-d7250517b06250ca942847dfd6e51ede261c24c9.tar.gz
external_llvm-d7250517b06250ca942847dfd6e51ede261c24c9.tar.bz2
Get rid of a bunch of dead code now that interval reconstruction is enabled.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@63026 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib')
-rw-r--r--lib/CodeGen/PreAllocSplitting.cpp321
1 files changed, 0 insertions, 321 deletions
diff --git a/lib/CodeGen/PreAllocSplitting.cpp b/lib/CodeGen/PreAllocSplitting.cpp
index 0325f7c..49cc67b 100644
--- a/lib/CodeGen/PreAllocSplitting.cpp
+++ b/lib/CodeGen/PreAllocSplitting.cpp
@@ -139,26 +139,11 @@ namespace {
void UpdateSpillSlotInterval(VNInfo*, unsigned, unsigned);
- VNInfo* UpdateRegisterInterval(VNInfo*, unsigned, unsigned);
-
- bool ShrinkWrapToLastUse(MachineBasicBlock*, VNInfo*,
- SmallVector<MachineOperand*, 4>&,
- SmallPtrSet<MachineInstr*, 4>&);
-
- void ShrinkWrapLiveInterval(VNInfo*, MachineBasicBlock*, MachineBasicBlock*,
- MachineBasicBlock*, SmallPtrSet<MachineBasicBlock*, 8>&,
- DenseMap<MachineBasicBlock*, SmallVector<MachineOperand*, 4> >&,
- DenseMap<MachineBasicBlock*, SmallPtrSet<MachineInstr*, 4> >&,
- SmallVector<MachineBasicBlock*, 4>&);
-
bool SplitRegLiveInterval(LiveInterval*);
bool SplitRegLiveIntervals(const TargetRegisterClass **,
SmallPtrSet<LiveInterval*, 8>&);
- void RepairLiveInterval(LiveInterval* CurrLI, VNInfo* ValNo,
- MachineInstr* DefMI, unsigned RestoreIdx);
-
bool createsNewJoin(LiveRange* LR, MachineBasicBlock* DefMBB,
MachineBasicBlock* BarrierMBB);
bool Rematerialize(unsigned vreg, VNInfo* ValNo,
@@ -423,176 +408,6 @@ PreAllocSplitting::UpdateSpillSlotInterval(VNInfo *ValNo, unsigned SpillIndex,
}
}
-/// UpdateRegisterInterval - Given the specified val# of the current live
-/// interval is being split, and the spill and restore indices, update the live
-/// interval accordingly.
-VNInfo*
-PreAllocSplitting::UpdateRegisterInterval(VNInfo *ValNo, unsigned SpillIndex,
- unsigned RestoreIndex) {
- assert(LIs->getMBBFromIndex(RestoreIndex) == BarrierMBB &&
- "Expect restore in the barrier mbb");
-
- SmallVector<std::pair<unsigned,unsigned>, 4> Before;
- SmallVector<std::pair<unsigned,unsigned>, 4> After;
- SmallVector<unsigned, 4> BeforeKills;
- SmallVector<unsigned, 4> AfterKills;
- SmallPtrSet<const LiveRange*, 4> Processed;
-
- // First, let's figure out which parts of the live interval is now defined
- // by the restore, which are defined by the original definition.
- const LiveRange *LR = CurrLI->getLiveRangeContaining(RestoreIndex);
- After.push_back(std::make_pair(RestoreIndex, LR->end));
- if (CurrLI->isKill(ValNo, LR->end))
- AfterKills.push_back(LR->end);
-
- assert(LR->contains(SpillIndex));
- if (SpillIndex > LR->start) {
- Before.push_back(std::make_pair(LR->start, SpillIndex));
- BeforeKills.push_back(SpillIndex);
- }
- Processed.insert(LR);
-
- // Start from the restore mbb, figure out what part of the live interval
- // are defined by the restore.
- SmallVector<MachineBasicBlock*, 4> WorkList;
- MachineBasicBlock *MBB = BarrierMBB;
- for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
- SE = MBB->succ_end(); SI != SE; ++SI)
- WorkList.push_back(*SI);
-
- SmallPtrSet<MachineBasicBlock*, 4> ProcessedBlocks;
- ProcessedBlocks.insert(MBB);
-
- while (!WorkList.empty()) {
- MBB = WorkList.back();
- WorkList.pop_back();
- unsigned Idx = LIs->getMBBStartIdx(MBB);
- LR = CurrLI->getLiveRangeContaining(Idx);
- if (LR && LR->valno == ValNo && !Processed.count(LR)) {
- After.push_back(std::make_pair(LR->start, LR->end));
- if (CurrLI->isKill(ValNo, LR->end))
- AfterKills.push_back(LR->end);
- Idx = LIs->getMBBEndIdx(MBB);
- if (LR->end > Idx) {
- // Live range extend beyond at least one mbb. Let's see what other
- // mbbs it reaches.
- LIs->findReachableMBBs(LR->start, LR->end, WorkList);
- }
- Processed.insert(LR);
- }
-
- ProcessedBlocks.insert(MBB);
- if (LR)
- for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
- SE = MBB->succ_end(); SI != SE; ++SI)
- if (!ProcessedBlocks.count(*SI))
- WorkList.push_back(*SI);
- }
-
- for (LiveInterval::iterator I = CurrLI->begin(), E = CurrLI->end();
- I != E; ++I) {
- LiveRange *LR = I;
- if (LR->valno == ValNo && !Processed.count(LR)) {
- Before.push_back(std::make_pair(LR->start, LR->end));
- if (CurrLI->isKill(ValNo, LR->end))
- BeforeKills.push_back(LR->end);
- }
- }
-
- // Now create new val#s to represent the live ranges defined by the old def
- // those defined by the restore.
- unsigned AfterDef = ValNo->def;
- MachineInstr *AfterCopy = ValNo->copy;
- bool HasPHIKill = ValNo->hasPHIKill;
- CurrLI->removeValNo(ValNo);
- VNInfo *BValNo = (Before.empty())
- ? NULL
- : CurrLI->getNextValue(AfterDef, AfterCopy, LIs->getVNInfoAllocator());
- if (BValNo)
- CurrLI->addKills(BValNo, BeforeKills);
-
- VNInfo *AValNo = (After.empty())
- ? NULL
- : CurrLI->getNextValue(RestoreIndex, 0, LIs->getVNInfoAllocator());
- if (AValNo) {
- AValNo->hasPHIKill = HasPHIKill;
- CurrLI->addKills(AValNo, AfterKills);
- }
-
- for (unsigned i = 0, e = Before.size(); i != e; ++i) {
- unsigned Start = Before[i].first;
- unsigned End = Before[i].second;
- CurrLI->addRange(LiveRange(Start, End, BValNo));
- }
- for (unsigned i = 0, e = After.size(); i != e; ++i) {
- unsigned Start = After[i].first;
- unsigned End = After[i].second;
- CurrLI->addRange(LiveRange(Start, End, AValNo));
- }
-
- return AValNo;
-}
-
-/// ShrinkWrapToLastUse - There are uses of the current live interval in the
-/// given block, shrink wrap the live interval to the last use (i.e. remove
-/// from last use to the end of the mbb). In case mbb is the where the barrier
-/// is, remove from the last use to the barrier.
-bool
-PreAllocSplitting::ShrinkWrapToLastUse(MachineBasicBlock *MBB, VNInfo *ValNo,
- SmallVector<MachineOperand*, 4> &Uses,
- SmallPtrSet<MachineInstr*, 4> &UseMIs) {
- MachineOperand *LastMO = 0;
- MachineInstr *LastMI = 0;
- if (MBB != BarrierMBB && Uses.size() == 1) {
- // Single use, no need to traverse the block. We can't assume this for the
- // barrier bb though since the use is probably below the barrier.
- LastMO = Uses[0];
- LastMI = LastMO->getParent();
- } else {
- MachineBasicBlock::iterator MEE = MBB->begin();
- MachineBasicBlock::iterator MII;
- if (MBB == BarrierMBB)
- MII = Barrier;
- else
- MII = MBB->end();
- while (MII != MEE) {
- --MII;
- MachineInstr *UseMI = &*MII;
- if (!UseMIs.count(UseMI))
- continue;
- for (unsigned i = 0, e = UseMI->getNumOperands(); i != e; ++i) {
- MachineOperand &MO = UseMI->getOperand(i);
- if (MO.isReg() && MO.getReg() == CurrLI->reg) {
- LastMO = &MO;
- break;
- }
- }
- LastMI = UseMI;
- break;
- }
- }
-
- // Cut off live range from last use (or beginning of the mbb if there
- // are no uses in it) to the end of the mbb.
- unsigned RangeStart, RangeEnd = LIs->getMBBEndIdx(MBB)+1;
- if (LastMI) {
- RangeStart = LIs->getUseIndex(LIs->getInstructionIndex(LastMI))+1;
- assert(!LastMO->isKill() && "Last use already terminates the interval?");
- LastMO->setIsKill();
- } else {
- assert(MBB == BarrierMBB);
- RangeStart = LIs->getMBBStartIdx(MBB);
- }
- if (MBB == BarrierMBB)
- RangeEnd = LIs->getUseIndex(BarrierIdx)+1;
- CurrLI->removeRange(RangeStart, RangeEnd);
- if (LastMI)
- CurrLI->addKill(ValNo, RangeStart);
-
- // Return true if the last use becomes a new kill.
- return LastMI;
-}
-
/// PerformPHIConstruction - From properly set up use and def lists, use a PHI
/// construction algorithm to compute the ranges and valnos for an interval.
VNInfo* PreAllocSplitting::PerformPHIConstruction(
@@ -890,142 +705,6 @@ void PreAllocSplitting::ReconstructLiveInterval(LiveInterval* LI) {
}
}
-/// ShrinkWrapLiveInterval - Recursively traverse the predecessor
-/// chain to find the new 'kills' and shrink wrap the live interval to the
-/// new kill indices.
-void
-PreAllocSplitting::ShrinkWrapLiveInterval(VNInfo *ValNo, MachineBasicBlock *MBB,
- MachineBasicBlock *SuccMBB, MachineBasicBlock *DefMBB,
- SmallPtrSet<MachineBasicBlock*, 8> &Visited,
- DenseMap<MachineBasicBlock*, SmallVector<MachineOperand*, 4> > &Uses,
- DenseMap<MachineBasicBlock*, SmallPtrSet<MachineInstr*, 4> > &UseMIs,
- SmallVector<MachineBasicBlock*, 4> &UseMBBs) {
- if (Visited.count(MBB))
- return;
-
- // If live interval is live in another successor path, then we can't process
- // this block. But we may able to do so after all the successors have been
- // processed.
- if (MBB != BarrierMBB) {
- for (MachineBasicBlock::succ_iterator SI = MBB->succ_begin(),
- SE = MBB->succ_end(); SI != SE; ++SI) {
- MachineBasicBlock *SMBB = *SI;
- if (SMBB == SuccMBB)
- continue;
- if (CurrLI->liveAt(LIs->getMBBStartIdx(SMBB)))
- return;
- }
- }
-
- Visited.insert(MBB);
-
- DenseMap<MachineBasicBlock*, SmallVector<MachineOperand*, 4> >::iterator
- UMII = Uses.find(MBB);
- if (UMII != Uses.end()) {
- // At least one use in this mbb, lets look for the kill.
- DenseMap<MachineBasicBlock*, SmallPtrSet<MachineInstr*, 4> >::iterator
- UMII2 = UseMIs.find(MBB);
- if (ShrinkWrapToLastUse(MBB, ValNo, UMII->second, UMII2->second))
- // Found a kill, shrink wrapping of this path ends here.
- return;
- } else if (MBB == DefMBB) {
- // There are no uses after the def.
- MachineInstr *DefMI = LIs->getInstructionFromIndex(ValNo->def);
- if (UseMBBs.empty()) {
- // The only use must be below barrier in the barrier block. It's safe to
- // remove the def.
- LIs->RemoveMachineInstrFromMaps(DefMI);
- DefMI->eraseFromParent();
- CurrLI->removeRange(ValNo->def, LIs->getMBBEndIdx(MBB)+1);
- }
- } else if (MBB == BarrierMBB) {
- // Remove entire live range from start of mbb to barrier.
- CurrLI->removeRange(LIs->getMBBStartIdx(MBB),
- LIs->getUseIndex(BarrierIdx)+1);
- } else {
- // Remove entire live range of the mbb out of the live interval.
- CurrLI->removeRange(LIs->getMBBStartIdx(MBB), LIs->getMBBEndIdx(MBB)+1);
- }
-
- if (MBB == DefMBB)
- // Reached the def mbb, stop traversing this path further.
- return;
-
- // Traverse the pathes up the predecessor chains further.
- for (MachineBasicBlock::pred_iterator PI = MBB->pred_begin(),
- PE = MBB->pred_end(); PI != PE; ++PI) {
- MachineBasicBlock *Pred = *PI;
- if (Pred == MBB)
- continue;
- if (Pred == DefMBB && ValNo->hasPHIKill)
- // Pred is the def bb and the def reaches other val#s, we must
- // allow the value to be live out of the bb.
- continue;
- if (!CurrLI->liveAt(LIs->getMBBEndIdx(Pred)-1))
- return;
- ShrinkWrapLiveInterval(ValNo, Pred, MBB, DefMBB, Visited,
- Uses, UseMIs, UseMBBs);
- }
-
- return;
-}
-
-
-void PreAllocSplitting::RepairLiveInterval(LiveInterval* CurrLI,
- VNInfo* ValNo,
- MachineInstr* DefMI,
- unsigned RestoreIdx) {
- // Shrink wrap the live interval by walking up the CFG and find the
- // new kills.
- // Now let's find all the uses of the val#.
- DenseMap<MachineBasicBlock*, SmallVector<MachineOperand*, 4> > Uses;
- DenseMap<MachineBasicBlock*, SmallPtrSet<MachineInstr*, 4> > UseMIs;
- SmallPtrSet<MachineBasicBlock*, 4> Seen;
- SmallVector<MachineBasicBlock*, 4> UseMBBs;
- for (MachineRegisterInfo::use_iterator UI = MRI->use_begin(CurrLI->reg),
- UE = MRI->use_end(); UI != UE; ++UI) {
- MachineOperand &UseMO = UI.getOperand();
- MachineInstr *UseMI = UseMO.getParent();
- unsigned UseIdx = LIs->getInstructionIndex(UseMI);
- LiveInterval::iterator ULR = CurrLI->FindLiveRangeContaining(UseIdx);
- if (ULR->valno != ValNo)
- continue;
- MachineBasicBlock *UseMBB = UseMI->getParent();
- // Remember which other mbb's use this val#.
- if (Seen.insert(UseMBB) && UseMBB != BarrierMBB)
- UseMBBs.push_back(UseMBB);
- DenseMap<MachineBasicBlock*, SmallVector<MachineOperand*, 4> >::iterator
- UMII = Uses.find(UseMBB);
- if (UMII != Uses.end()) {
- DenseMap<MachineBasicBlock*, SmallPtrSet<MachineInstr*, 4> >::iterator
- UMII2 = UseMIs.find(UseMBB);
- UMII->second.push_back(&UseMO);
- UMII2->second.insert(UseMI);
- } else {
- SmallVector<MachineOperand*, 4> Ops;
- Ops.push_back(&UseMO);
- Uses.insert(std::make_pair(UseMBB, Ops));
- SmallPtrSet<MachineInstr*, 4> MIs;
- MIs.insert(UseMI);
- UseMIs.insert(std::make_pair(UseMBB, MIs));
- }
- }
-
- // Walk up the predecessor chains.
- SmallPtrSet<MachineBasicBlock*, 8> Visited;
- ShrinkWrapLiveInterval(ValNo, BarrierMBB, NULL, DefMI->getParent(), Visited,
- Uses, UseMIs, UseMBBs);
-
- // Remove live range from barrier to the restore. FIXME: Find a better
- // point to re-start the live interval.
- VNInfo* AfterValNo = UpdateRegisterInterval(ValNo,
- LIs->getUseIndex(BarrierIdx)+1,
- LIs->getDefIndex(RestoreIdx));
-
- // Attempt to renumber the new valno into a new vreg.
- RenumberValno(AfterValNo);
-}
-
/// RenumberValno - Split the given valno out into a new vreg, allowing it to
/// be allocated to a different register. This function creates a new vreg,
/// copies the valno and its live ranges over to the new vreg's interval,