diff --git a/lib/CodeGen/StrongPHIElimination.cpp b/lib/CodeGen/StrongPHIElimination.cpp index 5abab305766..57958ca0569 100644 --- a/lib/CodeGen/StrongPHIElimination.cpp +++ b/lib/CodeGen/StrongPHIElimination.cpp @@ -52,8 +52,9 @@ namespace { // used as operands to another another PHI node std::set UsedByAnother; - // RenameSets are the sets of operands (and their VNInfo IDs) to a PHI - // (the defining instruction of the key) that can be renamed without copies. + // RenameSets are the is a map from a PHI-defined register + // to the input registers to be coalesced along with the index + // of the input registers. std::map > RenameSets; // PhiValueNumber holds the ID numbers of the VNs for each phi that we're @@ -466,15 +467,11 @@ void StrongPHIElimination::processBlock(MachineBasicBlock* MBB) { UsedByAnother.insert(SrcReg); } else { // Otherwise, add it to the renaming set - LiveInterval& I = LI.getOrCreateInterval(SrcReg); // We need to subtract one from the index because live ranges are open // at the end. unsigned idx = LI.getMBBEndIdx(P->getOperand(i).getMBB()) - 1; - VNInfo* VN = I.getLiveRangeContaining(idx)->valno; - assert(VN && "No VNInfo for register?"); - - PHIUnion.insert(std::make_pair(SrcReg, VN->id)); + PHIUnion.insert(std::make_pair(SrcReg, idx)); UnionedBlocks.insert(MRI.getVRegDef(SrcReg)->getParent()); } } @@ -744,22 +741,9 @@ void StrongPHIElimination::ScheduleCopies(MachineBasicBlock* MBB, // PHI, we don't create multiple overlapping live intervals. std::set RegHandled; for (SmallVector, 4>::iterator I = - InsertedPHIDests.begin(), E = InsertedPHIDests.end(); I != E; ++I) { - if (!RegHandled.count(I->first)) { - LiveInterval& Interval = LI.getOrCreateInterval(I->first); - VNInfo* VN = Interval.getNextValue( - LI.getInstructionIndex(I->second) + LiveIntervals::InstrSlots::DEF, - I->second, LI.getVNInfoAllocator()); - VN->hasPHIKill = true; - VN->kills.push_back(LI.getMBBEndIdx(I->second->getParent())); - LiveRange LR(LI.getInstructionIndex(I->second) + - LiveIntervals::InstrSlots::DEF, - LI.getMBBEndIdx(I->second->getParent()) + 1, VN); - Interval.addRange(LR); - - RegHandled.insert(I->first); - } - } + InsertedPHIDests.begin(), E = InsertedPHIDests.end(); I != E; ++I) + if (!RegHandled.count(I->first)) + LI.addLiveRangeToEndOfBlock(I->first, I->second); } /// InsertCopies - insert copies into MBB and all of its successors @@ -794,111 +778,30 @@ void StrongPHIElimination::InsertCopies(MachineBasicBlock* MBB, Stacks[*I].pop_back(); } -/// ComputeUltimateVN - Assuming we are going to join two live intervals, -/// compute what the resultant value numbers for each value in the input two -/// ranges will be. This is complicated by copies between the two which can -/// and will commonly cause multiple value numbers to be merged into one. -/// -/// VN is the value number that we're trying to resolve. InstDefiningValue -/// keeps track of the new InstDefiningValue assignment for the result -/// LiveInterval. ThisFromOther/OtherFromThis are sets that keep track of -/// whether a value in this or other is a copy from the opposite set. -/// ThisValNoAssignments/OtherValNoAssignments keep track of value #'s that have -/// already been assigned. -/// -/// ThisFromOther[x] - If x is defined as a copy from the other interval, this -/// contains the value number the copy is from. -/// -static unsigned ComputeUltimateVN(VNInfo *VNI, - SmallVector &NewVNInfo, - DenseMap &ThisFromOther, - DenseMap &OtherFromThis, - SmallVector &ThisValNoAssignments, - SmallVector &OtherValNoAssignments) { - unsigned VN = VNI->id; - - // If the VN has already been computed, just return it. - if (ThisValNoAssignments[VN] >= 0) - return ThisValNoAssignments[VN]; -// assert(ThisValNoAssignments[VN] != -2 && "Cyclic case?"); - - // If this val is not a copy from the other val, then it must be a new value - // number in the destination. - DenseMap::iterator I = ThisFromOther.find(VNI); - if (I == ThisFromOther.end()) { - NewVNInfo.push_back(VNI); - return ThisValNoAssignments[VN] = NewVNInfo.size()-1; - } - VNInfo *OtherValNo = I->second; - - // Otherwise, this *is* a copy from the RHS. If the other side has already - // been computed, return it. - if (OtherValNoAssignments[OtherValNo->id] >= 0) - return ThisValNoAssignments[VN] = OtherValNoAssignments[OtherValNo->id]; - - // Mark this value number as currently being computed, then ask what the - // ultimate value # of the other value is. - ThisValNoAssignments[VN] = -2; - unsigned UltimateVN = - ComputeUltimateVN(OtherValNo, NewVNInfo, OtherFromThis, ThisFromOther, - OtherValNoAssignments, ThisValNoAssignments); - return ThisValNoAssignments[VN] = UltimateVN; -} - void StrongPHIElimination::mergeLiveIntervals(unsigned primary, unsigned secondary, - unsigned secondaryVN) { + unsigned secondaryIdx) { LiveIntervals& LI = getAnalysis(); LiveInterval& LHS = LI.getOrCreateInterval(primary); LiveInterval& RHS = LI.getOrCreateInterval(secondary); - // Compute the final value assignment, assuming that the live ranges can be - // coalesced. - SmallVector LHSValNoAssignments; - SmallVector RHSValNoAssignments; - SmallVector NewVNInfo; + LI.computeNumbering(); - LHSValNoAssignments.resize(LHS.getNumValNums(), -1); - RHSValNoAssignments.resize(RHS.getNumValNums(), -1); - NewVNInfo.reserve(LHS.getNumValNums() + RHS.getNumValNums()); - - for (LiveInterval::vni_iterator I = LHS.vni_begin(), E = LHS.vni_end(); - I != E; ++I) { - VNInfo *VNI = *I; - unsigned VN = VNI->id; - if (LHSValNoAssignments[VN] >= 0 || VNI->def == ~1U) - continue; - - NewVNInfo.push_back(VNI); - LHSValNoAssignments[VN] = NewVNInfo.size()-1; - } - - for (LiveInterval::vni_iterator I = RHS.vni_begin(), E = RHS.vni_end(); - I != E; ++I) { - VNInfo *VNI = *I; - unsigned VN = VNI->id; - if (RHSValNoAssignments[VN] >= 0 || VNI->def == ~1U) - continue; - - NewVNInfo.push_back(VNI); - RHSValNoAssignments[VN] = NewVNInfo.size()-1; - } - - // If we get here, we know that we can coalesce the live ranges. Ask the - // intervals to coalesce themselves now. - - LHS.join(RHS, &LHSValNoAssignments[0], &RHSValNoAssignments[0], NewVNInfo); - LI.removeInterval(secondary); - - // The valno that was previously the input to the PHI node - // now has a PHIKill. - LHS.getValNumInfo(RHSValNoAssignments[secondaryVN])->hasPHIKill = true; + const LiveRange* RangeMergingIn = RHS.getLiveRangeContaining(secondaryIdx); + VNInfo* NewVN = LHS.getNextValue(secondaryIdx, RangeMergingIn->valno->copy, + LI.getVNInfoAllocator()); + NewVN->hasPHIKill = true; + LiveRange NewRange(RangeMergingIn->start, RangeMergingIn->end, NewVN); + LHS.addRange(NewRange); + RHS.removeRange(RangeMergingIn->start, RangeMergingIn->end, true); } bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) { LiveIntervals& LI = getAnalysis(); + LI.dump(); + // Compute DFS numbers of each block computeDFS(Fn); @@ -909,7 +812,7 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) { processBlock(I); // Insert copies - // FIXME: This process should probably preserve LiveVariables + // FIXME: This process should probably preserve LiveIntervals SmallPtrSet visited; InsertCopies(Fn.begin(), visited); @@ -961,5 +864,7 @@ bool StrongPHIElimination::runOnMachineFunction(MachineFunction &Fn) { LI.computeNumbering(); + LI.dump(); + return true; }