/// overlaps - Return true if the live interval overlaps a range specified
/// by [Start, End).
-bool LiveInterval::overlaps(LiveIndex Start, MachineInstrIndex End) const {
+bool LiveInterval::overlaps(LiveIndex Start, LiveIndex End) const {
assert(Start < End && "Invalid range");
const_iterator I = begin();
const_iterator E = end();
/// isInOneLiveRange - Return true if the range specified is entirely in
/// a single LiveRange of the live interval.
-bool LiveInterval::isInOneLiveRange(LiveIndex Start, MachineInstrIndex End) {
+bool LiveInterval::isInOneLiveRange(LiveIndex Start, LiveIndex End) {
Ranges::iterator I = std::upper_bound(ranges.begin(), ranges.end(), Start);
if (I == ranges.begin())
return false;
/// removeRange - Remove the specified range from this interval. Note that
/// the range must be in a single LiveRange in its entirety.
-void LiveInterval::removeRange(LiveIndex Start, MachineInstrIndex End,
+void LiveInterval::removeRange(LiveIndex Start, LiveIndex End,
bool RemoveDeadValNo) {
// Find the LiveRange containing this span.
Ranges::iterator I = std::upper_bound(ranges.begin(), ranges.end(), Start);
// Number MachineInstrs and MachineBasicBlocks.
// Initialize MBB indexes to a sentinal.
MBB2IdxMap.resize(mf_->getNumBlockIDs(),
- std::make_pair(LiveIndex(),MachineInstrIndex()));
+ std::make_pair(LiveIndex(),LiveIndex()));
LiveIndex MIIndex;
for (MachineFunction::iterator MBB = mf_->begin(), E = mf_->end();
(idx == index ? offset : LiveIndex::LOAD));
else
LI->end =
- LiveIndex(MachineInstrIndex::NUM * i2miMap_.size());
+ LiveIndex(LiveIndex::NUM * i2miMap_.size());
}
}
Idx2MBBMap.clear();
for (MachineFunction::iterator MBB = mf_->begin(), MBBE = mf_->end();
MBB != MBBE; ++MBB) {
- std::pair<LiveIndex, MachineInstrIndex> &mbbIndices = MBB2IdxMap[MBB->getNumber()];
+ std::pair<LiveIndex, LiveIndex> &mbbIndices = MBB2IdxMap[MBB->getNumber()];
mbbIndices.first = mbbIndices.first.scale(factor);
mbbIndices.second = mbbIndices.second.scale(factor);
Idx2MBBMap.push_back(std::make_pair(mbbIndices.first, MBB));
}
bool LiveIntervals::findLiveInMBBs(
- LiveIndex Start, MachineInstrIndex End,
+ LiveIndex Start, LiveIndex End,
SmallVectorImpl<MachineBasicBlock*> &MBBs) const {
std::vector<IdxMBBPair>::const_iterator I =
std::lower_bound(Idx2MBBMap.begin(), Idx2MBBMap.end(), Start);
}
bool LiveIntervals::findReachableMBBs(
- LiveIndex Start, MachineInstrIndex End,
+ LiveIndex Start, LiveIndex End,
SmallVectorImpl<MachineBasicBlock*> &MBBs) const {
std::vector<IdxMBBPair>::const_iterator I =
std::lower_bound(Idx2MBBMap.begin(), Idx2MBBMap.end(), Start);
/// for addIntervalsForSpills to rewrite uses / defs for the given live range.
bool LiveIntervals::
rewriteInstructionForSpills(const LiveInterval &li, const VNInfo *VNI,
- bool TrySplit, LiveIndex index, MachineInstrIndex end,
+ bool TrySplit, LiveIndex index, LiveIndex end,
MachineInstr *MI,
MachineInstr *ReMatOrigDefMI, MachineInstr *ReMatDefMI,
unsigned Slot, int LdSlot,
MachineInstr* startInst) {
LiveInterval& Interval = getOrCreateInterval(reg);
VNInfo* VN = Interval.getNextValue(
- LiveIndex(getInstructionIndex(startInst), MachineInstrIndex::DEF),
+ LiveIndex(getInstructionIndex(startInst), LiveIndex::DEF),
startInst, true, getVNInfoAllocator());
VN->setHasPHIKill(true);
VN->kills.push_back(terminatorGaps[startInst->getParent()]);
LiveRange LR(
- LiveIndex(getInstructionIndex(startInst), MachineInstrIndex::DEF),
+ LiveIndex(getInstructionIndex(startInst), LiveIndex::DEF),
getNextSlot(getMBBEndIdx(startInst->getParent())), VN);
Interval.addRange(LR);
DenseMap<unsigned, int> IntervalSSMap;
// Def2SpillMap - A map from a def instruction index to spill index.
- DenseMap<LiveIndex, MachineInstrIndex> Def2SpillMap;
+ DenseMap<LiveIndex, LiveIndex> Def2SpillMap;
public:
static char ID;
int CreateSpillStackSlot(unsigned, const TargetRegisterClass *);
bool IsAvailableInStack(MachineBasicBlock*, unsigned,
- LiveIndex, MachineInstrIndex,
+ LiveIndex, LiveIndex,
LiveIndex&, int&) const;
- void UpdateSpillSlotInterval(VNInfo*, LiveIndex, MachineInstrIndex);
+ void UpdateSpillSlotInterval(VNInfo*, LiveIndex, LiveIndex);
bool SplitRegLiveInterval(LiveInterval*);
DenseMap<unsigned, int>::iterator I = IntervalSSMap.find(Reg);
if (I == IntervalSSMap.end())
return false;
- DenseMap<LiveIndex, MachineInstrIndex>::iterator
+ DenseMap<LiveIndex, LiveIndex>::iterator
II = Def2SpillMap.find(DefIndex);
if (II == Def2SpillMap.end())
return false;
bool BHasPHIKill = BValNo->hasPHIKill();
SmallVector<VNInfo*, 4> BDeadValNos;
VNInfo::KillSet BKills;
- std::map<LiveIndex, MachineInstrIndex> BExtend;
+ std::map<LiveIndex, LiveIndex> BExtend;
// If ALR and BLR overlaps and end of BLR extends beyond end of ALR, e.g.
// A = or A, B
AI != AE; ++AI) {
if (AI->valno != AValNo) continue;
LiveIndex End = AI->end;
- std::map<LiveIndex, MachineInstrIndex>::iterator
+ std::map<LiveIndex, LiveIndex>::iterator
EI = BExtend.find(End);
if (EI != BExtend.end())
End = EI->second;
/// from a physical register live interval as well as from the live intervals
/// of its sub-registers.
static void removeRange(LiveInterval &li,
- LiveIndex Start, MachineInstrIndex End,
+ LiveIndex Start, LiveIndex End,
LiveIntervals *li_, const TargetRegisterInfo *tri_) {
li.removeRange(Start, End, true);
if (TargetRegisterInfo::isPhysicalRegister(li.reg)) {
vrm->assignVirt2StackSlot(li->reg, ss);
MachineInstr *mi = 0;
- LiveIndex storeIdx = MachineInstrIndex();
+ LiveIndex storeIdx = LiveIndex();
if (valno->isDefAccurate()) {
// If we have an accurate def we can just grab an iterator to the instr
}
MachineBasicBlock *defBlock = mi->getParent();
- LiveIndex loadIdx = MachineInstrIndex();
+ LiveIndex loadIdx = LiveIndex();
// Now we need to find the load...
MachineBasicBlock::iterator useItr(mi);
LiveInterval& I = LI.getInterval(curr.second);
MachineBasicBlock::iterator term = MBB->getFirstTerminator();
- LiveIndex endIdx = MachineInstrIndex();
+ LiveIndex endIdx = LiveIndex();
if (term != MBB->end())
endIdx = LI.getInstructionIndex(term);
else