From 25dffa743b2e2d0ee5fe70254d3a45724580a383 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Wed, 17 Dec 2008 22:06:59 +0000 Subject: [PATCH] Fix miscompilations caused by renumbering, and enable it as part of prealloc splitting. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61158 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/PreAllocSplitting.cpp | 82 +++++++++++++++++-------------- 1 file changed, 46 insertions(+), 36 deletions(-) diff --git a/lib/CodeGen/PreAllocSplitting.cpp b/lib/CodeGen/PreAllocSplitting.cpp index 81dd0b6e5f1..c7491ce2a89 100644 --- a/lib/CodeGen/PreAllocSplitting.cpp +++ b/lib/CodeGen/PreAllocSplitting.cpp @@ -41,6 +41,7 @@ static cl::opt PreSplitLimit("pre-split-limit", cl::init(-1), cl::Hidden); STATISTIC(NumSplits, "Number of intervals split"); STATISTIC(NumRemats, "Number of intervals split by rematerialization"); STATISTIC(NumFolds, "Number of intervals split with spill folding"); +STATISTIC(NumRenumbers, "Number of intervals renumbered into new registers"); namespace { class VISIBILITY_HIDDEN PreAllocSplitting : public MachineFunctionPass { @@ -137,7 +138,7 @@ namespace { void UpdateSpillSlotInterval(VNInfo*, unsigned, unsigned); - void UpdateRegisterInterval(VNInfo*, unsigned, unsigned); + VNInfo* UpdateRegisterInterval(VNInfo*, unsigned, unsigned); bool ShrinkWrapToLastUse(MachineBasicBlock*, VNInfo*, SmallVector&, @@ -409,7 +410,7 @@ 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. -void +VNInfo* PreAllocSplitting::UpdateRegisterInterval(VNInfo *ValNo, unsigned SpillIndex, unsigned RestoreIndex) { assert(LIs->getMBBFromIndex(RestoreIndex) == BarrierMBB && @@ -512,6 +513,8 @@ PreAllocSplitting::UpdateRegisterInterval(VNInfo *ValNo, unsigned SpillIndex, unsigned End = After[i].second; CurrLI->addRange(LiveRange(Start, End, AValNo)); } + + return AValNo; } /// ShrinkWrapToLastUse - There are uses of the current live interval in the @@ -700,17 +703,14 @@ void PreAllocSplitting::RepairLiveInterval(LiveInterval* CurrLI, ShrinkWrapLiveInterval(ValNo, BarrierMBB, NULL, DefMI->getParent(), Visited, Uses, UseMIs, UseMBBs); -#if 0 - if (!ValNo->hasPHIKill) - RenumberValno(); -#endif - // FIXME: If ValNo->hasPHIKill is false, then renumber the val# by - // the restore. - // Remove live range from barrier to the restore. FIXME: Find a better // point to re-start the live interval. - UpdateRegisterInterval(ValNo, LIs->getUseIndex(BarrierIdx)+1, - LIs->getDefIndex(RestoreIdx)); + VNInfo* AfterValNo = UpdateRegisterInterval(ValNo, + LIs->getUseIndex(BarrierIdx)+1, + LIs->getDefIndex(RestoreIdx)); + // Attempt to renumber the new valno into a new vreg. + if (!AfterValNo->hasPHIKill) + RenumberValno(AfterValNo); } /// RenumberValno - Split the given valno out into a new vreg, allowing it to @@ -722,15 +722,41 @@ void PreAllocSplitting::RenumberValno(VNInfo* VN) { // Create the new vreg unsigned NewVReg = MRI->createVirtualRegister(MRI->getRegClass(CurrLI->reg)); - // Copy over the valno and ranges + // Create the new live interval LiveInterval& NewLI = LIs->getOrCreateInterval(NewVReg); - VNInfo* NewVN = NewLI.getNextValue(VN->def, VN->copy, - LIs->getVNInfoAllocator()); - NewLI.copyValNumInfo(NewVN, VN); - NewLI.MergeValueInAsValue(*CurrLI, VN, NewVN); + SmallVector VNsToCopy; + VNsToCopy.push_back(VN); + + // Walk through and copy the valno we care about, and any other valnos + // that are two-address redefinitions of the one we care about. These + // will need to be rewritten as well. + while (!VNsToCopy.empty()) { + VNInfo* OldVN = VNsToCopy.back(); + VNsToCopy.pop_back(); + + // Copy the valno over + VNInfo* NewVN = NewLI.getNextValue(OldVN->def, OldVN->copy, + LIs->getVNInfoAllocator()); + NewLI.copyValNumInfo(NewVN, OldVN); + NewLI.MergeValueInAsValue(*CurrLI, OldVN, NewVN); + + // Locate two-address redefinitions + for (SmallVector::iterator KI = NewVN->kills.begin(), + KE = NewVN->kills.end(); KI != KE; ++KI) { + MachineInstr* MI = LIs->getInstructionFromIndex(*KI); + unsigned DefIdx = MI->findRegisterDefOperandIdx(CurrLI->reg); + if (DefIdx == ~0U) continue; + if (MI->isRegReDefinedByTwoAddr(DefIdx)) { + VNInfo* NextVN = + CurrLI->findDefinedVNInfo(LiveIntervals::getDefIndex(*KI)); + VNsToCopy.push_back(NextVN); + } + } + + // Remove the valno from the old interval + CurrLI->removeValNo(OldVN); + } - // Remove the valno from the old interval - CurrLI->removeValNo(VN); // Rewrite defs and uses. This is done in two stages to avoid invalidating // the reg_iterator. @@ -753,6 +779,8 @@ void PreAllocSplitting::RenumberValno(VNInfo* VN) { MachineOperand& MO = Inst->getOperand(OpIdx); MO.setReg(NewVReg); } + + NumRenumbers++; } bool PreAllocSplitting::Rematerialize(unsigned vreg, VNInfo* ValNo, @@ -1097,8 +1125,6 @@ bool PreAllocSplitting::runOnMachineFunction(MachineFunction &MF) { // Make sure blocks are numbered in order. MF.RenumberBlocks(); -#if 1 - // FIXME: Go top down. MachineBasicBlock *Entry = MF.begin(); SmallPtrSet Visited; @@ -1117,22 +1143,6 @@ bool PreAllocSplitting::runOnMachineFunction(MachineFunction &MF) { MadeChange |= SplitRegLiveIntervals(BarrierRCs); } } -#else - for (MachineFunction::reverse_iterator I = MF.rbegin(), E = MF.rend(); - I != E; ++I) { - BarrierMBB = &*I; - for (MachineBasicBlock::reverse_iterator II = BarrierMBB->rbegin(), - EE = BarrierMBB->rend(); II != EE; ++II) { - Barrier = &*II; - const TargetRegisterClass **BarrierRCs = - Barrier->getDesc().getRegClassBarriers(); - if (!BarrierRCs) - continue; - BarrierIdx = LIs->getInstructionIndex(Barrier); - MadeChange |= SplitRegLiveIntervals(BarrierRCs); - } - } -#endif return MadeChange; } -- 2.34.1