+
+ if (!OldI2MI.empty())
+ for (iterator OI = begin(), OE = end(); OI != OE; ++OI) {
+ for (LiveInterval::iterator LI = OI->second->begin(),
+ LE = OI->second->end(); LI != LE; ++LI) {
+
+ // Remap the start index of the live range to the corresponding new
+ // number, or our best guess at what it _should_ correspond to if the
+ // original instruction has been erased. This is either the following
+ // instruction or its predecessor.
+ unsigned index = LI->start / InstrSlots::NUM;
+ unsigned offset = LI->start % InstrSlots::NUM;
+ if (offset == InstrSlots::LOAD) {
+ std::vector<IdxMBBPair>::const_iterator I =
+ std::lower_bound(OldI2MBB.begin(), OldI2MBB.end(), LI->start);
+ // Take the pair containing the index
+ std::vector<IdxMBBPair>::const_iterator J =
+ (I == OldI2MBB.end() && OldI2MBB.size()>0) ? (I-1): I;
+
+ LI->start = getMBBStartIdx(J->second);
+ } else {
+ LI->start = mi2iMap_[OldI2MI[index]] + offset;
+ }
+
+ // Remap the ending index in the same way that we remapped the start,
+ // except for the final step where we always map to the immediately
+ // following instruction.
+ index = (LI->end - 1) / InstrSlots::NUM;
+ offset = LI->end % InstrSlots::NUM;
+ if (offset == InstrSlots::LOAD) {
+ // VReg dies at end of block.
+ std::vector<IdxMBBPair>::const_iterator I =
+ std::lower_bound(OldI2MBB.begin(), OldI2MBB.end(), LI->end);
+ --I;
+
+ LI->end = getMBBEndIdx(I->second) + 1;
+ } else {
+ unsigned idx = index;
+ while (index < OldI2MI.size() && !OldI2MI[index]) ++index;
+
+ if (index != OldI2MI.size())
+ LI->end = mi2iMap_[OldI2MI[index]] + (idx == index ? offset : 0);
+ else
+ LI->end = InstrSlots::NUM * i2miMap_.size();
+ }
+ }
+
+ for (LiveInterval::vni_iterator VNI = OI->second->vni_begin(),
+ VNE = OI->second->vni_end(); VNI != VNE; ++VNI) {
+ VNInfo* vni = *VNI;
+
+ // Remap the VNInfo def index, which works the same as the
+ // start indices above. VN's with special sentinel defs
+ // don't need to be remapped.
+ if (vni->def != ~0U && vni->def != ~1U) {
+ unsigned index = vni->def / InstrSlots::NUM;
+ unsigned offset = vni->def % InstrSlots::NUM;
+ if (offset == InstrSlots::LOAD) {
+ std::vector<IdxMBBPair>::const_iterator I =
+ std::lower_bound(OldI2MBB.begin(), OldI2MBB.end(), vni->def);
+ // Take the pair containing the index
+ std::vector<IdxMBBPair>::const_iterator J =
+ (I == OldI2MBB.end() && OldI2MBB.size()>0) ? (I-1): I;
+
+ vni->def = getMBBStartIdx(J->second);
+ } else {
+ vni->def = mi2iMap_[OldI2MI[index]] + offset;
+ }
+ }
+
+ // Remap the VNInfo kill indices, which works the same as
+ // the end indices above.
+ for (size_t i = 0; i < vni->kills.size(); ++i) {
+ // PHI kills don't need to be remapped.
+ if (!vni->kills[i]) continue;
+
+ unsigned index = (vni->kills[i]-1) / InstrSlots::NUM;
+ unsigned offset = vni->kills[i] % InstrSlots::NUM;
+ if (offset == InstrSlots::LOAD) {
+ std::vector<IdxMBBPair>::const_iterator I =
+ std::lower_bound(OldI2MBB.begin(), OldI2MBB.end(), vni->kills[i]);
+ --I;
+
+ vni->kills[i] = getMBBEndIdx(I->second);
+ } else {
+ unsigned idx = index;
+ while (index < OldI2MI.size() && !OldI2MI[index]) ++index;
+
+ if (index != OldI2MI.size())
+ vni->kills[i] = mi2iMap_[OldI2MI[index]] +
+ (idx == index ? offset : 0);
+ else
+ vni->kills[i] = InstrSlots::NUM * i2miMap_.size();
+ }
+ }
+ }
+ }
+}
+
+/// runOnMachineFunction - Register allocate the whole function
+///
+bool LiveIntervals::runOnMachineFunction(MachineFunction &fn) {
+ mf_ = &fn;
+ mri_ = &mf_->getRegInfo();
+ tm_ = &fn.getTarget();
+ tri_ = tm_->getRegisterInfo();
+ tii_ = tm_->getInstrInfo();
+ aa_ = &getAnalysis<AliasAnalysis>();
+ lv_ = &getAnalysis<LiveVariables>();
+ allocatableRegs_ = tri_->getAllocatableSet(fn);