float weight; // weight of this interval
Ranges ranges; // the ranges in which this register is live
private:
- /// InstDefiningValue - This tracks the def index of the instruction that
- /// defines a particular value number in the interval. This may be ~0,
- /// which is treated as unknown, or ~1, which is a deleted value number.
- SmallVector<unsigned, 4> InstDefiningValue;
+ /// ValueNumberInfo - If this value number is not defined by a copy, this
+ /// holds ~0,x. If the value number is not in use, it contains ~1,x to
+ /// indicate that the value # is not used. If the val# is defined by a
+ /// copy, the first entry is the instruction # of the copy, and the second
+ /// is the register number copied from.
+ SmallVector<std::pair<unsigned,unsigned>, 4> ValueNumberInfo;
public:
LiveInterval(unsigned Reg, float Weight)
std::swap(reg, other.reg);
std::swap(weight, other.weight);
std::swap(ranges, other.ranges);
- std::swap(InstDefiningValue, other.InstDefiningValue);
+ std::swap(ValueNumberInfo, other.ValueNumberInfo);
}
- bool containsOneValue() const { return InstDefiningValue.size() == 1; }
+ bool containsOneValue() const { return ValueNumberInfo.size() == 1; }
- unsigned getNumValNums() const { return InstDefiningValue.size(); }
+ unsigned getNumValNums() const { return ValueNumberInfo.size(); }
/// getNextValue - Create a new value number and return it. MIIdx specifies
/// the instruction that defines the value number.
- unsigned getNextValue(unsigned MIIdx) {
- InstDefiningValue.push_back(MIIdx);
- return InstDefiningValue.size()-1;
+ unsigned getNextValue(unsigned MIIdx, unsigned SrcReg) {
+ ValueNumberInfo.push_back(std::make_pair(MIIdx, SrcReg));
+ return ValueNumberInfo.size()-1;
}
/// getInstForValNum - Return the machine instruction index that defines the
/// specified value number.
unsigned getInstForValNum(unsigned ValNo) const {
- assert(ValNo < InstDefiningValue.size());
- return InstDefiningValue[ValNo];
+ assert(ValNo < ValueNumberInfo.size());
+ return ValueNumberInfo[ValNo].first;
}
- /// setInstDefiningValNum - Change the instruction defining the specified
- /// value number to the specified instruction.
- void setInstDefiningValNum(unsigned ValNo, unsigned MIIdx) {
- InstDefiningValue[ValNo] = MIIdx;
+ unsigned getSrcRegForValNum(unsigned ValNo) const {
+ assert(ValNo < ValueNumberInfo.size());
+ if (ValueNumberInfo[ValNo].first < ~2U)
+ return ValueNumberInfo[ValNo].second;
+ return 0;
+ }
+
+ std::pair<unsigned, unsigned> getValNumInfo(unsigned ValNo) const {
+ assert(ValNo < ValueNumberInfo.size());
+ return ValueNumberInfo[ValNo];
+ }
+
+ /// setValueNumberInfo - Change the value number info for the specified
+ /// value number.
+ void setValueNumberInfo(unsigned ValNo,
+ const std::pair<unsigned, unsigned> &I){
+ ValueNumberInfo[ValNo] = I;
}
/// MergeValueNumberInto - This method is called when two value nubmers
/// the intervals are not joinable, this aborts.
void join(LiveInterval &Other, int *ValNoAssignments,
int *RHSValNoAssignments,
- SmallVector<unsigned, 16> &NewInstDefiningValue);
+ SmallVector<std::pair<unsigned,unsigned>,16> &NewValueNumberInfo);
/// removeRange - Remove the specified range from this interval. Note that
for (MachineFunction::livein_iterator I = fn.livein_begin(),
E = fn.livein_end(); I != E; ++I) {
handlePhysicalRegisterDef(Entry, Entry->begin(),
- getOrCreateInterval(I->first), true);
+ getOrCreateInterval(I->first), 0);
for (const unsigned* AS = mri_->getAliasSet(I->first); *AS; ++AS)
handlePhysicalRegisterDef(Entry, Entry->begin(),
- getOrCreateInterval(*AS), true);
+ getOrCreateInterval(*AS), 0);
}
}
// the spill weight is now infinity as it
// cannot be spilled again
nI.weight = float(HUGE_VAL);
- LiveRange LR(start, end, nI.getNextValue(~0U));
+ LiveRange LR(start, end, nI.getNextValue(~0U, 0));
DEBUG(std::cerr << " +" << LR);
nI.addRange(LR);
added.push_back(&nI);
// Get the Idx of the defining instructions.
unsigned defIndex = getDefIndex(getInstructionIndex(mi));
- unsigned ValNum = interval.getNextValue(defIndex);
+ unsigned ValNum;
+ unsigned SrcReg, DstReg;
+ if (!tii_->isMoveInstr(*mi, SrcReg, DstReg))
+ ValNum = interval.getNextValue(~0U, 0);
+ else
+ ValNum = interval.getNextValue(defIndex, SrcReg);
+
assert(ValNum == 0 && "First value in interval is not 0?");
ValNum = 0; // Clue in the optimizer.
// that at this point, there should be exactly one value number in it.
assert(interval.containsOneValue() && "Unexpected 2-addr liveint!");
- // The new value number is defined by the instruction we claimed defined
- // value #0.
- unsigned ValNo = interval.getNextValue(DefIndex);
+ // The new value number (#1) is defined by the instruction we claimed
+ // defined value #0.
+ unsigned ValNo = interval.getNextValue(0, 0);
+ interval.setValueNumberInfo(1, interval.getValNumInfo(0));
- // Value#1 is now defined by the 2-addr instruction.
- interval.setInstDefiningValNum(0, RedefIndex);
+ // Value#0 is now defined by the 2-addr instruction.
+ interval.setValueNumberInfo(0, std::make_pair(~0U, 0U));
// Add the new live interval which replaces the range for the input copy.
LiveRange LR(DefIndex, RedefIndex, ValNo);
// Replace the interval with one of a NEW value number. Note that this
// value number isn't actually defined by an instruction, weird huh? :)
- LiveRange LR(Start, End, interval.getNextValue(~0U));
+ LiveRange LR(Start, End, interval.getNextValue(~0U, 0));
DEBUG(std::cerr << " replace range with " << LR);
interval.addRange(LR);
DEBUG(std::cerr << "RESULT: "; interval.print(std::cerr, mri_));
// live until the end of the block. We've already taken care of the
// rest of the live range.
unsigned defIndex = getDefIndex(getInstructionIndex(mi));
+
+ unsigned ValNum;
+ unsigned SrcReg, DstReg;
+ if (!tii_->isMoveInstr(*mi, SrcReg, DstReg))
+ ValNum = interval.getNextValue(~0U, 0);
+ else
+ ValNum = interval.getNextValue(defIndex, SrcReg);
+
LiveRange LR(defIndex,
- getInstructionIndex(&mbb->back()) + InstrSlots::NUM,
- interval.getNextValue(defIndex));
+ getInstructionIndex(&mbb->back()) + InstrSlots::NUM, ValNum);
interval.addRange(LR);
DEBUG(std::cerr << " +" << LR);
}
void LiveIntervals::handlePhysicalRegisterDef(MachineBasicBlock *MBB,
MachineBasicBlock::iterator mi,
- LiveInterval& interval,
- bool isLiveIn) {
+ LiveInterval &interval,
+ unsigned SrcReg) {
// A physical register cannot be live across basic block, so its
// lifetime must end somewhere in its defining basic block.
DEBUG(std::cerr << "\t\tregister: "; printRegName(interval.reg));
// The only case we should have a dead physreg here without a killing or
// instruction where we know it's dead is if it is live-in to the function
// and never used.
- assert(isLiveIn && "physreg was not killed in defining block!");
+ assert(!SrcReg && "physreg was not killed in defining block!");
end = getDefIndex(start) + 1; // It's dead.
exit:
assert(start < end && "did not find end of interval?");
- LiveRange LR(start, end, interval.getNextValue(isLiveIn ? ~0U : start));
+ LiveRange LR(start, end, interval.getNextValue(SrcReg != 0 ? start : ~0U,
+ SrcReg));
interval.addRange(LR);
DEBUG(std::cerr << " +" << LR << '\n');
}
if (MRegisterInfo::isVirtualRegister(reg))
handleVirtualRegisterDef(MBB, MI, getOrCreateInterval(reg));
else if (allocatableRegs_[reg]) {
- handlePhysicalRegisterDef(MBB, MI, getOrCreateInterval(reg));
+ unsigned SrcReg, DstReg;
+ if (!tii_->isMoveInstr(*MI, SrcReg, DstReg))
+ SrcReg = 0;
+ handlePhysicalRegisterDef(MBB, MI, getOrCreateInterval(reg), SrcReg);
for (const unsigned* AS = mri_->getAliasSet(reg); *AS; ++AS)
- handlePhysicalRegisterDef(MBB, MI, getOrCreateInterval(*AS), true);
+ handlePhysicalRegisterDef(MBB, MI, getOrCreateInterval(*AS), 0);
}
}
// If AValNo is defined as a copy from IntB, we can potentially process this.
// Get the instruction that defines this value number.
- unsigned AValNoInstIdx = IntA.getInstForValNum(AValNo);
-
- // If it's unknown, ignore it.
- if (AValNoInstIdx == ~0U || AValNoInstIdx == ~1U) return false;
- // Otherwise, get the instruction for it.
- MachineInstr *AValNoInstMI = getInstructionFromIndex(AValNoInstIdx);
+ unsigned SrcReg = IntA.getSrcRegForValNum(AValNo);
+ if (!SrcReg) return false; // Not defined by a copy.
// If the value number is not defined by a copy instruction, ignore it.
- unsigned SrcReg, DstReg;
- if (!tii_->isMoveInstr(*AValNoInstMI, SrcReg, DstReg))
- return false;
// If the source register comes from an interval other than IntB, we can't
// handle this.
- assert(rep(DstReg) == IntA.reg && "Not defining a reg in IntA?");
if (rep(SrcReg) != IntB.reg) return false;
-
+
// Get the LiveRange in IntB that this value number starts with.
+ unsigned AValNoInstIdx = IntA.getInstForValNum(AValNo);
LiveInterval::iterator ValLR = IntB.FindLiveRangeContaining(AValNoInstIdx-1);
// Make sure that the end of the live range is inside the same block as
// We are about to delete CopyMI, so need to remove it as the 'instruction
// that defines this value #'.
- IntB.setInstDefiningValNum(BValNo, ~0U);
+ IntB.setValueNumberInfo(BValNo, std::make_pair(~0U, 0));
// Okay, we can merge them. We need to insert a new liverange:
// [ValLR.end, BLR.begin) of either value number, then we merge the
for (const unsigned *AS = mri_->getAliasSet(IntB.reg); *AS; ++AS) {
LiveInterval &AliasLI = getInterval(*AS);
AliasLI.addRange(LiveRange(FillerStart, FillerEnd,
- AliasLI.getNextValue(~0U)));
+ AliasLI.getNextValue(~0U, 0)));
}
}
/// contains the value number the copy is from.
///
static unsigned ComputeUltimateVN(unsigned VN,
- SmallVector<unsigned, 16> &InstDefiningValue,
+ SmallVector<std::pair<unsigned,
+ unsigned>, 16> &ValueNumberInfo,
SmallVector<int, 16> &ThisFromOther,
SmallVector<int, 16> &OtherFromThis,
SmallVector<int, 16> &ThisValNoAssignments,
// number in the destination.
int OtherValNo = ThisFromOther[VN];
if (OtherValNo == -1) {
- InstDefiningValue.push_back(ThisLI.getInstForValNum(VN));
- return ThisValNoAssignments[VN] = InstDefiningValue.size()-1;
+ ValueNumberInfo.push_back(ThisLI.getValNumInfo(VN));
+ return ThisValNoAssignments[VN] = ValueNumberInfo.size()-1;
}
// Otherwise, this *is* a copy from the RHS. Mark this value number as
// value is.
ThisValNoAssignments[VN] = -2;
unsigned UltimateVN =
- ComputeUltimateVN(OtherValNo, InstDefiningValue,
+ ComputeUltimateVN(OtherValNo, ValueNumberInfo,
OtherFromThis, ThisFromOther,
OtherValNoAssignments, ThisValNoAssignments,
OtherLI, ThisLI);
SmallVector<int, 16> LHSValsDefinedFromRHS;
LHSValsDefinedFromRHS.resize(LHS.getNumValNums(), -1);
for (unsigned VN = 0, e = LHS.getNumValNums(); VN != e; ++VN) {
- unsigned ValInst = LHS.getInstForValNum(VN);
- if (ValInst == ~0U || ValInst == ~1U)
- continue;
-
- // If the instruction defining the LHS's value is a copy.
- MachineInstr *ValInstMI = getInstructionFromIndex(ValInst);
-
- // If the value number is not defined by a copy instruction, ignore it.
- unsigned SrcReg, DstReg;
- if (!tii_->isMoveInstr(*ValInstMI, SrcReg, DstReg))
+ unsigned ValSrcReg = LHS.getSrcRegForValNum(VN);
+ if (ValSrcReg == 0) // Src not defined by a copy?
continue;
-
+
// DstReg is known to be a register in the LHS interval. If the src is from
// the RHS interval, we can use its value #.
- if (rep(SrcReg) != RHS.reg)
+ if (rep(ValSrcReg) != RHS.reg)
continue;
-
+
// Figure out the value # from the RHS.
+ unsigned ValInst = LHS.getInstForValNum(VN);
LHSValsDefinedFromRHS[VN] = RHS.getLiveRangeContaining(ValInst-1)->ValId;
}
SmallVector<int, 16> RHSValsDefinedFromLHS;
RHSValsDefinedFromLHS.resize(RHS.getNumValNums(), -1);
for (unsigned VN = 0, e = RHS.getNumValNums(); VN != e; ++VN) {
- unsigned ValInst = RHS.getInstForValNum(VN);
- if (ValInst == ~0U || ValInst == ~1U)
- continue;
-
- // If the instruction defining the RHS's value is a copy.
- MachineInstr *ValInstMI = getInstructionFromIndex(ValInst);
-
- // If the value number is not defined by a copy instruction, ignore it.
- unsigned SrcReg, DstReg;
- if (!tii_->isMoveInstr(*ValInstMI, SrcReg, DstReg))
+ unsigned ValSrcReg = RHS.getSrcRegForValNum(VN);
+ if (ValSrcReg == 0) // Src not defined by a copy?
continue;
// DstReg is known to be a register in the RHS interval. If the src is from
// the LHS interval, we can use its value #.
- if (rep(SrcReg) != LHS.reg)
+ if (rep(ValSrcReg) != LHS.reg)
continue;
// Figure out the value # from the LHS.
+ unsigned ValInst = RHS.getInstForValNum(VN);
RHSValsDefinedFromLHS[VN] = LHS.getLiveRangeContaining(ValInst-1)->ValId;
}
// assuming that the live ranges can be coallesced.
SmallVector<int, 16> LHSValNoAssignments;
SmallVector<int, 16> RHSValNoAssignments;
- SmallVector<unsigned, 16> InstDefiningValue;
+ SmallVector<std::pair<unsigned,unsigned>, 16> ValueNumberInfo;
LHSValNoAssignments.resize(LHS.getNumValNums(), -1);
RHSValNoAssignments.resize(RHS.getNumValNums(), -1);
// Compute ultimate value numbers for the LHS and RHS values.
for (unsigned VN = 0, e = LHS.getNumValNums(); VN != e; ++VN) {
if (LHS.getInstForValNum(VN) == ~2U) continue;
- ComputeUltimateVN(VN, InstDefiningValue,
+ ComputeUltimateVN(VN, ValueNumberInfo,
LHSValsDefinedFromRHS, RHSValsDefinedFromLHS,
LHSValNoAssignments, RHSValNoAssignments, LHS, RHS);
}
for (unsigned VN = 0, e = RHS.getNumValNums(); VN != e; ++VN) {
if (RHS.getInstForValNum(VN) == ~2U) continue;
- ComputeUltimateVN(VN, InstDefiningValue,
+ ComputeUltimateVN(VN, ValueNumberInfo,
RHSValsDefinedFromLHS, LHSValsDefinedFromRHS,
RHSValNoAssignments, LHSValNoAssignments, RHS, LHS);
}
// If we get here, we know that we can coallesce the live ranges. Ask the
// intervals to coallesce themselves now.
LHS.join(RHS, &LHSValNoAssignments[0], &RHSValNoAssignments[0],
- InstDefiningValue);
+ ValueNumberInfo);
return true;
}
projects / oota-llvm.git / commitdiff