RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-20 11:08:27 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Revert r61158 for now, as it caused some test failures.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61159 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2008-12-17 22:17:27 +00:00
parent 25dffa743b
commit c7a21941c5
1 changed files with 36 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
lib/CodeGen/PreAllocSplitting.cpp
View File

@ -41,7 +41,6 @@ static cl::opt<int> 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 {
@ -138,7 +137,7 @@ namespace {
void UpdateSpillSlotInterval(VNInfo*, unsigned, unsigned);
VNInfo* UpdateRegisterInterval(VNInfo*, unsigned, unsigned);
void UpdateRegisterInterval(VNInfo*, unsigned, unsigned);
bool ShrinkWrapToLastUse(MachineBasicBlock*, VNInfo*,
SmallVector<MachineOperand*, 4>&,
@ -410,7 +409,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.
VNInfo*
void
PreAllocSplitting::UpdateRegisterInterval(VNInfo *ValNo, unsigned SpillIndex,
unsigned RestoreIndex) {
assert(LIs->getMBBFromIndex(RestoreIndex) == BarrierMBB &&
@ -513,8 +512,6 @@ 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
@ -703,14 +700,17 @@ 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.
VNInfo* AfterValNo = UpdateRegisterInterval(ValNo,
LIs->getUseIndex(BarrierIdx)+1,
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,41 +722,15 @@ void PreAllocSplitting::RenumberValno(VNInfo* VN) {
// Create the new vreg
unsigned NewVReg = MRI->createVirtualRegister(MRI->getRegClass(CurrLI->reg));
// Create the new live interval
// Copy over the valno and ranges
LiveInterval& NewLI = LIs->getOrCreateInterval(NewVReg);
SmallVector<VNInfo*, 4> 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,
VNInfo* NewVN = NewLI.getNextValue(VN->def, VN->copy,
LIs->getVNInfoAllocator());
NewLI.copyValNumInfo(NewVN, OldVN);
NewLI.MergeValueInAsValue(*CurrLI, OldVN, NewVN);
// Locate two-address redefinitions
for (SmallVector<unsigned, 4>::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);
}
}
NewLI.copyValNumInfo(NewVN, VN);
NewLI.MergeValueInAsValue(*CurrLI, VN, NewVN);
// Remove the valno from the old interval
CurrLI->removeValNo(OldVN);
}
CurrLI->removeValNo(VN);
// Rewrite defs and uses. This is done in two stages to avoid invalidating
// the reg_iterator.
@ -779,8 +753,6 @@ void PreAllocSplitting::RenumberValno(VNInfo* VN) {
MachineOperand& MO = Inst->getOperand(OpIdx);
MO.setReg(NewVReg);
}
NumRenumbers++;
}
bool PreAllocSplitting::Rematerialize(unsigned vreg, VNInfo* ValNo,
@ -1125,6 +1097,8 @@ 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<MachineBasicBlock*,16> Visited;
@ -1143,6 +1117,22 @@ 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;
}