[llvm-commits] [llvm] r52013 - /llvm/trunk/lib/CodeGen/StrongPHIElimination.cpp
Evan Cheng
evan.cheng at apple.com
Thu Jun 5 14:41:22 PDT 2008
Thanks Owen.
Evan
On Jun 5, 2008, at 10:22 AM, Owen Anderson wrote:
> Author: resistor
> Date: Thu Jun 5 12:22:53 2008
> New Revision: 52013
>
> URL: http://llvm.org/viewvc/llvm-project?rev=52013&view=rev
> Log:
> Use the newly created helper on LiveIntervals.
>
> Modified:
> llvm/trunk/lib/CodeGen/StrongPHIElimination.cpp
>
> Modified: llvm/trunk/lib/CodeGen/StrongPHIElimination.cpp
> URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/StrongPHIElimination.cpp?rev=52013&r1=52012&r2=52013&view=diff
>
> =
> =
> =
> =
> =
> =
> =
> =
> ======================================================================
> --- llvm/trunk/lib/CodeGen/StrongPHIElimination.cpp (original)
> +++ llvm/trunk/lib/CodeGen/StrongPHIElimination.cpp Thu Jun 5
> 12:22:53 2008
> @@ -52,8 +52,9 @@
> // used as operands to another another PHI node
> std::set<unsigned> 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<unsigned, std::map<unsigned, unsigned> > RenameSets;
>
> // PhiValueNumber holds the ID numbers of the VNs for each phi
> that we're
> @@ -466,15 +467,11 @@
> 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 @@
> // PHI, we don't create multiple overlapping live intervals.
> std::set<unsigned> RegHandled;
> for (SmallVector<std::pair<unsigned, MachineInstr*>, 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 @@
> 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<VNInfo*, 16>
> &NewVNInfo,
> - DenseMap<VNInfo*, VNInfo*>
> &ThisFromOther,
> - DenseMap<VNInfo*, VNInfo*>
> &OtherFromThis,
> - SmallVector<int, 16>
> &ThisValNoAssignments,
> - SmallVector<int, 16>
> &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<VNInfo*, VNInfo*>::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<LiveIntervals>();
> LiveInterval& LHS = LI.getOrCreateInterval(primary);
> LiveInterval& RHS = LI.getOrCreateInterval(secondary);
>
> - // Compute the final value assignment, assuming that the live
> ranges can be
> - // coalesced.
> - SmallVector<int, 16> LHSValNoAssignments;
> - SmallVector<int, 16> RHSValNoAssignments;
> - SmallVector<VNInfo*, 16> NewVNInfo;
> -
> - 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);
> + LI.computeNumbering();
>
> - // 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<LiveIntervals>();
>
> + LI.dump();
> +
> // Compute DFS numbers of each block
> computeDFS(Fn);
>
> @@ -909,7 +812,7 @@
> processBlock(I);
>
> // Insert copies
> - // FIXME: This process should probably preserve LiveVariables
> + // FIXME: This process should probably preserve LiveIntervals
> SmallPtrSet<MachineBasicBlock*, 16> visited;
> InsertCopies(Fn.begin(), visited);
>
> @@ -961,5 +864,7 @@
>
> LI.computeNumbering();
>
> + LI.dump();
> +
> return true;
> }
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
More information about the llvm-commits
mailing list