Lines Matching refs:def
266 /// isPartialRedef - Return true if the specified def at the specific index is
277 MachineInstr *DefMI = getInstructionFromIndex(OldLR->valno->def);
306 // <imp-def> of the full register.
382 "PHI def index points at actual instruction.");
394 // e.g. %reg1031:5<def>, %reg1031:6<def> = VLD1q16 %reg1024<kill>, ...
402 // def-and-use register operand.
405 // 80 %reg1041:6<def> = VSHRNv4i16 %reg1034<kill>, 12, pred:14, pred:%reg0
406 // 120 %reg1041:5<def> = VSHRNv4i16 %reg1039<kill>, 12, pred:14, pred:%reg0
421 SlotIndex DefIndex = OldValNo->def.getDefIndex();
432 OldValNo->def = RedefIndex;
435 // A re-def may be a copy. e.g. %reg1030:6<def> = VMOVD %reg1026, ...
445 // range covering the def slot.
501 // [defSlot(def), defSlot(def)+1)
512 // [defSlot(def), useSlot(kill)+1)
535 // [defSlot(def), defSlot(def)+1)
589 // Look for kills, if it reaches a def before it's killed, then it shouldn't
620 // [defSlot(def), defSlot(def)+1)
647 "PHI def index points at actual instruction.");
766 if (VNI->def == Idx) {
776 // Create a new live interval with only minimal live segments per def.
785 NewLI.addRange(LiveRange(VNI->def, VNI->def.getNextSlot(), VNI));
787 // A use tied to an early-clobber def ends at the load slot and isn't caught
790 if (VNI->def.isUse())
791 if (VNInfo *UVNI = li->getVNInfoAt(VNI->def.getLoadIndex()))
792 WorkList.push_back(std::make_pair(VNI->def.getLoadIndex(), UVNI));
811 if (!VNI->isPHIDef() || VNI->def != BlockStart || !UsedPHIs.insert(VNI))
847 LiveInterval::iterator LII = NewLI.FindLiveRangeContaining(VNI->def);
849 if (LII->end != VNI->def.getNextSlot())
855 DEBUG(dbgs() << "Dead PHI at " << VNI->def << " may separate interval\n");
858 // This is a dead def. Make sure the instruction knows.
859 MachineInstr *MI = getInstructionFromIndex(VNI->def);
863 DEBUG(dbgs() << "All defs dead: " << VNI->def << '\t' << *MI);
1021 // Is the def for the val# rematerializable?
1022 MachineInstr *ReMatDefMI = getInstructionFromIndex(VNI->def);
1073 // If it is an implicit def instruction, just delete it.
1128 // It's only legal to remat for a use, not a def.
1213 DEBUG(dbgs() << "\t\t\t\tErasing re-materializable def: "
1221 // If def for this use can't be rematerialized, then try folding.
1222 // If def is rematerializable and it's a load, also try folding.
1240 // Keep track of whether we replace a use and/or def so that we can
1318 // rematerializable but its def is not. It should be assigned a
1328 // def is a deleted remat def), do it now.
1354 // Extend the split live interval to this def / use.
1425 // First collect all the def / use in this live range that will be rewritten.
1463 // Must be defined by an implicit def. It should not be spilled. Note,
1465 // 8 %reg1024<def> = IMPLICIT_DEF
1466 // 12 %reg1024<def> = INSERT_SUBREG %reg1024<kill>, %reg1025, 2
1468 // it's defined by an implicit def. It will not conflicts with live
1484 // If MI def and/or use the same register multiple times, then there
1508 // def = ...
1522 // This ends the previous live interval. If all of its def / use
1552 // Keep track of the last def and first use in each MBB.
1574 // If there is an earlier def and this is a two-address
1585 // There is an earlier def that's not killed (must be two-address).
1602 // Use(s) following the last def, it's not safe to fold the spill.
1611 // Only need a reload if there isn't an earlier def / use.
1629 // If all of its def / use can be folded, give it a low spill weight.
1679 "Register def was not rewritten?");
1785 // first def can be rematerialized!
1818 // Is the def for the val# rematerializable?
1819 MachineInstr *ReMatDefMI = getInstructionFromIndex(VNI->def);
1822 // Remember how to remat the def of this val#.
1824 // Original def may be modified so we have to make a copy here.
1920 // Fold the store into the def if possible.
1939 // No need to spill a dead def.
1988 // If the rematerializable def is a load, also try to fold it.
