lib/CodeGen/LiveIntervals.cpp

985   SlotIndex NewIdx;
992            SlotIndex OldIdx, SlotIndex NewIdx, bool UpdateFlags)
993     : LIS(LIS), MRI(MRI), TRI(TRI), OldIdx(OldIdx), NewIdx(NewIdx),
1007   /// NewIdx.
1009     LLVM_DEBUG(dbgs() << "handleMove " << OldIdx << " -> " << NewIdx << ": "
1071   /// OldIdx to NewIdx.
1086     if (SlotIndex::isEarlierInstr(OldIdx, NewIdx))
1095   /// to NewIdx (OldIdx < NewIdx).
1108       // If the live-in value already extends to NewIdx, there is nothing to do.
1109       if (SlotIndex::isEarlierEqualInstr(NewIdx, OldIdxIn->end))
1119       // Is there a def before NewIdx which is not OldIdx?
1122           SlotIndex::isEarlierInstr(Next->start, NewIdx)) {
1124         // to ensure liveness extends to NewIdx.
1126           LR.advanceTo(Next, NewIdx.getBaseIndex());
1127         // Extend the segment before NewIdx if necessary.
1129             !SlotIndex::isEarlierInstr(NewIdxIn->start, NewIdx)) {
1131           Prev->end = NewIdx.getRegSlot();
1138       // Adjust OldIdxIn->end to reach NewIdx. This may temporarily make LR
1141       OldIdxIn->end = NewIdx.getRegSlot(OldIdxIn->end.isEarlyClobber());
1161     // If the defined value extends beyond NewIdx, just move the beginning
1162     // of the segment to NewIdx.
1163     SlotIndex NewIdxDef = NewIdx.getRegSlot(OldIdxOut->start.isEarlyClobber());
1171     // NewIdx.
1173     // Is there an existing Def at NewIdx?
1175       = LR.advanceTo(OldIdxOut, NewIdx.getRegSlot());
1201       // If NewIdx is behind the last segment, extend that and append a new one.
1225           // Case 1: NewIdx is inside a liverange. Split this liverange at
1234           // Case 2: NewIdx is in a lifetime hole. Keep AfterNewIdx as is and
1235           // turn Prev into a segment from NewIdx to AfterNewIdx->start.
1246       // There is an existing def at NewIdx. The def at OldIdx is coalesced into
1251       // There was no existing def at NewIdx. We need to create a dead def
1252       // at NewIdx. Shift segments over the old OldIdxOut segment, this frees
1268   /// to NewIdx (NewIdx < OldIdx).
1282       // OldIdx, moreover the value must be live at NewIdx so there is nothing
1289       // previous use or (dead-)def but no further than NewIdx.
1292                    NewIdx.getRegSlot(OldIdxIn->end.isEarlyClobber()));
1312     // Is there an existing def at NewIdx?
1313     SlotIndex NewIdxDef = NewIdx.getRegSlot(OldIdxOut->start.isEarlyClobber());
1314     LiveRange::iterator NewIdxOut = LR.find(NewIdx.getRegSlot());
1315     if (SlotIndex::isSameInstr(NewIdxOut->start, NewIdx)) {
1320         // Remove segment starting at NewIdx and move begin of OldIdxOut to
1321         // NewIdx so it can take its place.
1330       // Previously nothing was live after NewIdx, so all we have to do now is
1331       // move the begin of OldIdxOut to NewIdx.
1333         // Do we have any intermediate Defs between OldIdx and NewIdx?
1336           // OldIdx is not a dead def and NewIdx is before predecessor start.
1338           assert(NewIdxIn == LR.find(NewIdx.getBaseIndex()));
1345               SlotIndex::isEarlierInstr(NewIdx, Prev->end)) {
1347             // NewIdx, the moved instruction also reads and forwards that
1369           if (SlotIndex::isEarlierInstr(Next->start, NewIdx)) {
1386           if (OldIdxIn != E && SlotIndex::isEarlierInstr(NewIdx, OldIdxIn->end))
1390           && SlotIndex::isEarlierInstr(NewIdxOut->start, NewIdx)
1391           && SlotIndex::isEarlierInstr(NewIdx, NewIdxOut->end)) {
1394         // but the dead def is a write to a subreg that is dead at NewIdx.
1415         if (MachineInstr *KillMI = LIS.getInstructionFromIndex(NewIdx))
1441     *RI = NewIdx.getRegSlot();
1450   // Return the last use of reg between NewIdx and OldIdx.