Lines Matching refs:Def
177 /// physical register and the existing subregister number of the def / use
445 if (BValNo->def != CopyIdx) return false;
456 MachineInstr *ACopyMI = LIS->getInstructionFromIndex(AValNo->def);
463 IntB.FindSegmentContaining(AValNo->def.getPrevSlot());
485 BValNo->def = FillerStart;
582 if (!BValNo || BValNo->def != CopyIdx)
590 MachineInstr *DefMI = LIS->getInstructionFromIndex(AValNo->def);
614 if (NewReg != IntB.reg || !IntB.Query(AValNo->def).isKill())
631 // If this use is tied to a def, we can't rewrite the register.
636 DEBUG(dbgs() << "\tremoveCopyByCommutingDef: " << AValNo->def << '\t'
704 assert(DVNI->def == DefIdx);
714 ValNo->def = AValNo->def;
747 MachineInstr *DefMI = LIS->getInstructionFromIndex(ValNo->def);
764 // Only support subregister destinations when the def is read-undef.
848 // Record small dead def live-ranges for all the subregisters
859 // ECX<def, dead> = remat ; CL<imp-def>
875 // rematerialized instruction. And update implicit def interval valnos.
949 /// physical register and the existing subregister number of the def / use
966 // the UseMI operands removes them from the SrcReg use-def chain, but when
986 // turn a full def into a read-modify-write sub-register def and vice
1235 // This means that two SSA values overlap if and only if the def of one value
1239 // The interference from an overlapping def can be resolved in these cases:
1254 // 3. Copy of external value. The overlapping def may be a copy of a value that
1265 // %dst:ssub0<def,read-undef> = FOO
1267 // %dst:ssub1<def> = COPY %src
1278 // 5. Clobbering dead lanes. A def may clobber a lane of a vector register that
1282 // %dst<def> = FOO
1284 // %dst:ssub1<def> = COPY %src
1329 // before and after this def.
1346 // Lanes written by this def, 0 for unanalyzed values.
1353 // Value in LI being redefined by this def.
1356 // Value in the other live range that overlaps this def, if any.
1453 MachineInstr *MI = Indexes->getInstructionFromIndex(VNI->def);
1460 LiveQueryResult LRQ = LIS->getInterval(Reg).Query(VNI->def);
1491 DefMI = Indexes->getInstructionFromIndex(VNI->def);
1502 // %src:ssub1<def> = FOO
1506 // %src:ssub1<def,read-undef> = FOO %src:ssub2
1508 // The <read-undef> flag on the def operand means that old lane values are
1511 V.RedefVNI = LI.Query(VNI->def).valueIn();
1527 // Find the value in Other that overlaps VNI->def, if any.
1528 LiveQueryResult OtherLRQ = Other.LI.Query(VNI->def);
1535 assert(SlotIndex::isSameInstr(VNI->def, OtherVNI->def) && "Broken LRQ");
1539 if (OtherVNI->def < VNI->def)
1541 else if (VNI->def < OtherVNI->def && OtherLRQ.valueIn()) {
1542 // This is an early-clobber def overlapping a live-in value in the other
1564 // No simultaneous def. Is Other live at the def?
1570 assert(!SlotIndex::isSameInstr(VNI->def, V.OtherVNI->def) && "Broken LRQ");
1585 DefMI->getParent() != Indexes->getMBBFromIndex(V.OtherVNI->def)) {
1586 DEBUG(dbgs() << "IMPLICIT_DEF defined at " << V.OtherVNI->def
1612 if (OtherLRQ.isKill() && OtherLRQ.endPoint() <= VNI->def)
1640 // overlapping, it must be because we're looking at an early clobber def:
1642 // %dst<def,early-clobber> = ASM %src<kill>
1645 // clobber def would clobber %src before it was read.
1647 // This case where the def doesn't overlap the kill is handled above.
1648 assert(VNI->def.isEarlyClobber() &&
1663 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def);
1696 << LI.getValNumInfo(ValNo)->def << " into "
1698 << V.OtherVNI->def << " --> @"
1699 << NewVNInfo[Assignments[ValNo]]->def << '\n');
1720 << '@' << LI.getValNumInfo(i)->def << '\n');
1746 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def);
1749 // Scan Other.LI from VNI.def to MBBEnd.
1750 LiveInterval::iterator OtherI = Other.LI.find(VNI->def);
1764 // A dead def is not a problem.
1769 // Check for another def in the MBB.
1773 // Lanes written by the new def are no longer tainted.
1807 << '@' << LI.getValNumInfo(i)->def << '\n');
1824 // Now look at the instructions from VNI->def to TaintExtent (inclusive).
1825 MachineBasicBlock *MBB = Indexes->getMBBFromIndex(VNI->def);
1828 MI = Indexes->getInstructionFromIndex(VNI->def);
1832 assert(!SlotIndex::isSameInstr(VNI->def, TaintExtent.front().first) &&
1833 "Interference ends on VNI->def. Should have been handled earlier");
1887 SlotIndex Def = LI.getValNumInfo(i)->def;
1893 LIS->pruneValue(&Other.LI, Def, &EndPoints);
1901 if (!Def.isBlock()) {
1902 // Remove <def,read-undef> flags. This def is now a partial redef.
1903 // Also remove <def,dead> flags since the joined live range will
1905 for (MIOperands MO(Indexes->getInstructionFromIndex(Def));
1912 // the live range also reaches the instruction at Def.
1914 EndPoints.push_back(Def);
1916 DEBUG(dbgs() << "\t\tpruned " << PrintReg(Other.LI.reg) << " at " << Def
1927 LIS->pruneValue(&LI, Def, &EndPoints);
1929 << Def << ": " << LI << '\n');
1942 // Get the def location before markUnused() below invalidates it.
1943 SlotIndex Def = LI.getValNumInfo(i)->def;
1956 DEBUG(dbgs() << "\t\tremoved " << i << '@' << Def << ": " << LI << '\n');
1960 MachineInstr *MI = Indexes->getInstructionFromIndex(Def);
1969 DEBUG(dbgs() << "\t\terased:\t" << Def << '\t' << *MI);
