Lines Matching defs:NewIdx

998   SlotIndex NewIdx;
1005            SlotIndex OldIdx, SlotIndex NewIdx, bool UpdateFlags)
1006     : LIS(LIS), MRI(MRI), TRI(TRI), OldIdx(OldIdx), NewIdx(NewIdx),
1020   /// NewIdx.
1022     LLVM_DEBUG(dbgs() << "handleMove " << OldIdx << " -> " << NewIdx << ": "
1088   /// OldIdx to NewIdx.
1103     if (SlotIndex::isEarlierInstr(OldIdx, NewIdx))
1112   /// to NewIdx (OldIdx < NewIdx).
1125       // If the live-in value already extends to NewIdx, there is nothing to do.
1126       if (SlotIndex::isEarlierEqualInstr(NewIdx, OldIdxIn->end))
1136       // Is there a def before NewIdx which is not OldIdx?
1139           SlotIndex::isEarlierInstr(Next->start, NewIdx)) {
1141         // to ensure liveness extends to NewIdx.
1143           LR.advanceTo(Next, NewIdx.getBaseIndex());
1144         // Extend the segment before NewIdx if necessary.
1146             !SlotIndex::isEarlierInstr(NewIdxIn->start, NewIdx)) {
1148           Prev->end = NewIdx.getRegSlot();
1155       // Adjust OldIdxIn->end to reach NewIdx. This may temporarily make LR
1158       OldIdxIn->end = NewIdx.getRegSlot(OldIdxIn->end.isEarlyClobber());
1178     // If the defined value extends beyond NewIdx, just move the beginning
1179     // of the segment to NewIdx.
1180     SlotIndex NewIdxDef = NewIdx.getRegSlot(OldIdxOut->start.isEarlyClobber());
1188     // NewIdx.
1190     // Is there an existing Def at NewIdx?
1192       = LR.advanceTo(OldIdxOut, NewIdx.getRegSlot());
1218       // If NewIdx is behind the last segment, extend that and append a new one.
1242           // Case 1: NewIdx is inside a liverange. Split this liverange at
1251           // Case 2: NewIdx is in a lifetime hole. Keep AfterNewIdx as is and
1252           // turn Prev into a segment from NewIdx to AfterNewIdx->start.
1263       // There is an existing def at NewIdx. The def at OldIdx is coalesced into
1268       // There was no existing def at NewIdx. We need to create a dead def
1269       // at NewIdx. Shift segments over the old OldIdxOut segment, this frees
1285   /// to NewIdx (NewIdx < OldIdx).
1299       // OldIdx, moreover the value must be live at NewIdx so there is nothing
1306       // previous use or (dead-)def but no further than NewIdx.
1309                    NewIdx.getRegSlot(OldIdxIn->end.isEarlyClobber()));
1329     // Is there an existing def at NewIdx?
1330     SlotIndex NewIdxDef = NewIdx.getRegSlot(OldIdxOut->start.isEarlyClobber());
1331     LiveRange::iterator NewIdxOut = LR.find(NewIdx.getRegSlot());
1332     if (SlotIndex::isSameInstr(NewIdxOut->start, NewIdx)) {
1337         // Remove segment starting at NewIdx and move begin of OldIdxOut to
1338         // NewIdx so it can take its place.
1347       // Previously nothing was live after NewIdx, so all we have to do now is
1348       // move the begin of OldIdxOut to NewIdx.
1350         // Do we have any intermediate Defs between OldIdx and NewIdx?
1353           // OldIdx is not a dead def and NewIdx is before predecessor start.
1355           assert(NewIdxIn == LR.find(NewIdx.getBaseIndex()));
1362               SlotIndex::isEarlierInstr(NewIdx, Prev->end)) {
1364             // NewIdx, the moved instruction also reads and forwards that
1386           if (SlotIndex::isEarlierInstr(Next->start, NewIdx)) {
1403           if (OldIdxIn != E && SlotIndex::isEarlierInstr(NewIdx, OldIdxIn->end))
1407           && SlotIndex::isEarlierInstr(NewIdxOut->start, NewIdx)
1408           && SlotIndex::isEarlierInstr(NewIdx, NewIdxOut->end)) {
1411         // but the dead def is a write to a subreg that is dead at NewIdx.
1432         if (MachineInstr *KillMI = LIS.getInstructionFromIndex(NewIdx))
1458     *RI = NewIdx.getRegSlot();
1467   // Return the last use of reg between NewIdx and OldIdx.