Lines Matching refs:Interval
1 //===-- LiveIntervalAnalysis.cpp - Live Interval Analysis -----------------===//
60 "Live Interval Analysis", false, false)
69 "Live Interval Analysis", false, false)
267 /// partially re-defining the specified live interval. A common case of this is
270 LiveInterval &interval) {
276 interval.getLiveRangeContaining(RedefIndex.getUseIndex());
279 return DefMI->findRegisterDefOperandIdx(interval.reg) != -1;
289 LiveInterval &interval) {
290 DEBUG(dbgs() << "\t\tregister: " << PrintReg(interval.reg, tri_));
294 // done once for the vreg. We use an empty interval to detect the first
296 LiveVariables::VarInfo& vi = lv_->getVarInfo(interval.reg);
297 if (interval.empty()) {
312 mi->addRegisterDefined(interval.reg);
313 // Mark all defs of interval.reg on this instruction as reading <undef>.
316 if (MO2.isReg() && MO2.getReg() == interval.reg && MO2.getSubReg())
326 VNInfo *ValNo = interval.getNextValue(defIndex, CopyMI, VNInfoAllocator);
327 assert(ValNo->id == 0 && "First value in interval is not 0?");
347 interval.addRange(LR);
359 interval.addRange(NewLR);
361 bool PHIJoin = lv_->isPHIJoin(interval.reg);
372 // live interval.
377 interval.addRange(LR);
389 // Create interval with one of a NEW value number. Note that this value
394 ValNo = interval.getNextValue(Start, 0, VNInfoAllocator);
398 interval.addRange(LR);
418 bool PartReDef = isPartialRedef(MIIdx, MO, interval);
422 // are actually two values in the live interval. Because of this we
430 interval.getLiveRangeContaining(RedefIndex.getUseIndex());
436 interval.removeRange(DefIndex, RedefIndex);
440 VNInfo *ValNo = interval.createValueCopy(OldValNo, VNInfoAllocator);
450 // Add the new live interval which replaces the range for the input copy.
453 interval.addRange(LR);
458 interval.addRange(LiveRange(RedefIndex, RedefIndex.getStoreIndex(),
463 interval.print(dbgs(), tri_);
465 } else if (lv_->isPHIJoin(interval.reg)) {
478 ValNo = interval.getNextValue(defIndex, CopyMI, VNInfoAllocator);
482 interval.addRange(LR);
497 LiveInterval &interval,
501 DEBUG(dbgs() << "\t\tregister: " << PrintReg(interval.reg, tri_));
511 // the instruction defining it. Hence its interval is:
522 // subsequent instruction. Hence its interval is:
532 if (mi->killsRegister(interval.reg, tri_)) {
537 int DefIdx = mi->findRegisterDefOperandIdx(interval.reg,false,false,tri_);
545 // defines it. Hence its interval is:
564 assert(start < end && "did not find end of interval?");
566 // Already exists? Extend old live interval.
567 VNInfo *ValNo = interval.getVNInfoAt(start);
570 ValNo = interval.getNextValue(start, CopyMI, VNInfoAllocator);
574 interval.addRange(LR);
597 LiveInterval &interval, bool isAlias) {
598 DEBUG(dbgs() << "\t\tlivein register: " << PrintReg(interval.reg, tri_));
622 if (mi->killsRegister(interval.reg, tri_)) {
627 } else if (mi->definesRegister(interval.reg, tri_)) {
630 // it. Hence its interval is:
660 interval.getNextValue(defIdx, 0, VNInfoAllocator);
664 interval.addRange(LR);
670 /// live interval is an interval [i, j) where 1 <= i <= j < N for
742 /// dupInterval - Duplicate a live interval. The caller is responsible for
790 // Create a new live interval with only minimal live segments per def.
868 DEBUG(dbgs() << "Dead PHI at " << VNI->def << " may separate interval\n");
966 /// isValNoAvailableAt - Return true if the val# of the specified interval
975 /// val# of the specified interval is re-materializable.
1015 /// val# of the specified interval is re-materializable.
1023 /// val# of the specified interval is re-materializable.
1168 /// interval on to-be re-materialized operands of MI) with new register.
1254 // create the spill interval with the appropriate range.
1258 // Create a new virtual register for the spill interval.
1288 // spilled interval.
1340 // If this interval hasn't been assigned a stack slot (because earlier
1351 // Create a new register interval for this spill / remat.
1367 // Extend the split live interval to this def / use.
1387 dbgs() << "\t\t\t\tAdded new interval: ";
1480 // The live range [12, 14) are not part of the r1024 live interval since
1482 // interval of r1025. Now suppose both registers are spilled, you can
1506 // Re-matting an instruction with virtual register use. Prevent interval
1523 // It's better to start a new interval to avoid artificially
1524 // extend the new interval.
1535 // This ends the previous live interval. If all of its def / use
1557 // Update weight of spill interval.
1698 // interval. Create a new empty live interval for it.
1743 assert(li.isSpillable() && "attempt to spill already spilled interval!");
1746 dbgs() << "\t\t\t\tadding intervals for spills for interval: ";
1770 // Spilling a split live interval. It cannot be split any further. Also,
1771 // it's also guaranteed to be a single val# / range interval.
1796 // If this is a split live interval with multiple ranges, it means there
1860 // One stack slot per live interval.
2010 // interval as unspillable.
2079 /// specified interval that conflicts with the specified physical register.
2098 /// around all defs and uses of the specified interval. Return true if it
2099 /// was able to cut its interval.
2172 LiveInterval& Interval = getOrCreateInterval(reg);
2173 VNInfo* VN = Interval.getNextValue(
2180 Interval.addRange(LR);
