Lines Matching defs:OtherVNI
2495 /// Merge this value into OtherVNI and erase the defining instruction.
2500 /// Merge this value into OtherVNI but keep the defining instruction.
2501 /// This is for the special case where OtherVNI is defined by the same
2505 /// Keep this value, and have it replace OtherVNI where possible. This
2506 /// complicates value mapping since OtherVNI maps to two different values
2536 VNInfo *OtherVNI = nullptr;
2558 /// True if this value is determined to be identical to OtherVNI
2597 /// both OtherVNI and RedefVNI have been analyzed and mapped before returning.
2866 if (VNInfo *OtherVNI = OtherLRQ.valueDefined()) {
2867 assert(SlotIndex::isSameInstr(VNI->def, OtherVNI->def) && "Broken LRQ");
2871 if (OtherVNI->def < VNI->def)
2872 Other.computeAssignment(OtherVNI->id, *this);
2873 else if (VNI->def < OtherVNI->def && OtherLRQ.valueIn()) {
2876 V.OtherVNI = OtherLRQ.valueIn();
2879 V.OtherVNI = OtherVNI;
2880 Val &OtherV = Other.Vals[OtherVNI->id];
2881 // Keep this value, check for conflicts when analyzing OtherVNI. Avoid
2882 // revisiting OtherVNI->id in JoinVals::computeAssignment() below before it
2884 if (!OtherV.isAnalyzed() || Other.Assignments[OtherVNI->id] == -1)
2899 V.OtherVNI = OtherLRQ.valueIn();
2900 if (!V.OtherVNI)
2904 assert(!SlotIndex::isSameInstr(VNI->def, V.OtherVNI->def) && "Broken LRQ");
2908 Other.computeAssignment(V.OtherVNI->id, *this);
2909 Val &OtherV = Other.Vals[V.OtherVNI->id];
2924 Indexes->getInstructionFromIndex(V.OtherVNI->def);
2928 LLVM_DEBUG(dbgs() << "IMPLICIT_DEF defined at " << V.OtherVNI->def
2939 dbgs() << "IMPLICIT_DEF defined at " << V.OtherVNI->def
2958 // OtherVNI. We still want the copy erased and value numbers merged.
2960 // Some of the lanes copied from OtherVNI may be undef, making them undef
2971 // Handle the case where VNI and OtherVNI can be proven to be identical:
2977 valuesIdentical(VNI, V.OtherVNI, Other)) {
2988 // If the lanes written by this instruction were all undef in OtherVNI, it is
2990 // mapping, though - OtherVNI will map to multiple values:
2992 // 1 %dst:ssub0 = FOO <-- OtherVNI
2998 // Here OtherVNI will map to itself in [1;2), but to VNI in [2;5). CR_Replace
3017 // VNI is clobbering live lanes in OtherVNI, but there is still the
3019 // If we're clobbering all the lanes in OtherVNI, at least one must be read.
3026 // If OtherVNI does not have subranges, it means all the lanes of OtherVNI
3034 // If we are clobbering some active lanes of OtherVNI at VNI->def, it is
3036 // OtherVNI because of no real conflict.
3045 // VNI is clobbering some lanes of OtherVNI, they have real conflict.
3050 // VNI is NOT clobbering any lane of OtherVNI, just replace OtherVNI.
3062 // being read, for example OtherVNI may be only partially redefined in MBB,
3082 // Merge this ValNo into OtherVNI.
3083 assert(V.OtherVNI && "OtherVNI not assigned, can't merge.");
3084 assert(Other.Vals[V.OtherVNI->id].isAnalyzed() && "Missing recursion");
3085 Assignments[ValNo] = Other.Assignments[V.OtherVNI->id];
3088 << printReg(Other.Reg) << ':' << V.OtherVNI->id << '@'
3089 << V.OtherVNI->def << " --> @"
3095 assert(V.OtherVNI && "OtherVNI not assigned, can't prune");
3096 Val &OtherV = Other.Vals[V.OtherVNI->id];
3189 assert(V.OtherVNI && "Inconsistent conflict resolution.");
3191 const Val &OtherV = Other.Vals[V.OtherVNI->id];
3193 // VNI is known to clobber some lanes in OtherVNI. If we go ahead with the
3255 V.Pruned = Other.isPrunedValue(V.OtherVNI->id, *this);
3274 Val &OtherV = Other.Vals[Vals[i].OtherVNI->id];
3380 OtherDef = V.OtherVNI->def;
3403 // If V is identical to V.OtherVNI (and S was live at OtherDef),
3405 // with V.OtherVNI.