void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) { assert(Old->HasValueHandle &&"Should only be called if ValueHandles present"); assert(Old != New && "Changing value into itself!"); // Get the linked list base, which is guaranteed to exist since the // HasValueHandle flag is set. LLVMContextImpl *pImpl = Old->getContext().pImpl; ValueHandleBase *Entry = pImpl->ValueHandles[Old]; assert(Entry && "Value bit set but no entries exist"); // We use a local ValueHandleBase as an iterator so that // ValueHandles can add and remove themselves from the list without // breaking our iteration. This is not really an AssertingVH; we // just have to give ValueHandleBase some kind. for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { Iterator.RemoveFromUseList(); Iterator.AddToExistingUseListAfter(Entry); assert(Entry->Next == &Iterator && "Loop invariant broken."); switch (Entry->getKind()) { case Assert: // Asserting handle does not follow RAUW implicitly. break; case Tracking: // Tracking goes to new value like a WeakVH. Note that this may make it // something incompatible with its templated type. We don't want to have a // virtual (or inline) interface to handle this though, so instead we make // the TrackingVH accessors guarantee that a client never sees this value. // FALLTHROUGH case Weak: // Weak goes to the new value, which will unlink it from Old's list. Entry->operator=(New); break; case Callback: // Forward to the subclass's implementation. static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New); break; } } #ifndef NDEBUG // If any new tracking or weak value handles were added while processing the // list, then complain about it now. if (Old->HasValueHandle) for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next) switch (Entry->getKind()) { case Tracking: case Weak: dbgs() << "After RAUW from " << *Old->getType() << " %" << Old->getNameStr() << " to " << *New->getType() << " %" << New->getNameStr() << "\n"; llvm_unreachable("A tracking or weak value handle still pointed to the" " old value!\n"); default: break; } #endif }
void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) { assert(Old->HasValueHandle &&"Should only be called if ValueHandles present"); assert(Old != New && "Changing value into itself!"); // Get the linked list base, which is guaranteed to exist since the // HasValueHandle flag is set. ValueHandleBase *Entry = (*ValueHandles)[Old]; assert(Entry && "Value bit set but no entries exist"); while (Entry) { // Advance pointer to avoid invalidation. ValueHandleBase *ThisNode = Entry; Entry = Entry->Next; switch (ThisNode->getKind()) { case Assert: // Asserting handle does not follow RAUW implicitly. break; case Weak: // Weak goes to the new value, which will unlink it from Old's list. ThisNode->operator=(New); break; case Callback: // Forward to the subclass's implementation. static_cast<CallbackVH*>(ThisNode)->allUsesReplacedWith(New); break; } } }
void ValueHandleBase::ValueIsDeleted(Value *V) { assert(V->HasValueHandle && "Should only be called if ValueHandles present"); // Get the linked list base, which is guaranteed to exist since the // HasValueHandle flag is set. ValueHandleBase *Entry = (*ValueHandles)[V]; assert(Entry && "Value bit set but no entries exist"); while (Entry) { // Advance pointer to avoid invalidation. ValueHandleBase *ThisNode = Entry; Entry = Entry->Next; switch (ThisNode->getKind()) { case Assert: #ifndef NDEBUG // Only in -g mode... cerr << "While deleting: " << *V->getType() << " %" << V->getNameStr() << "\n"; #endif cerr << "An asserting value handle still pointed to this value!\n"; abort(); case Weak: // Weak just goes to null, which will unlink it from the list. ThisNode->operator=(0); break; case Callback: // Forward to the subclass's implementation. static_cast<CallbackVH*>(ThisNode)->deleted(); break; } } // All callbacks and weak references should be dropped by now. assert(!V->HasValueHandle && "All references to V were not removed?"); }
void ValueHandleBase::ValueIsDeleted(Value *V) { assert(V->HasValueHandle && "Should only be called if ValueHandles present"); // Get the linked list base, which is guaranteed to exist since the // HasValueHandle flag is set. LLVMContextImpl *pImpl = V->getContext().pImpl; ValueHandleBase *Entry = pImpl->ValueHandles[V]; assert(Entry && "Value bit set but no entries exist"); // We use a local ValueHandleBase as an iterator so that ValueHandles can add // and remove themselves from the list without breaking our iteration. This // is not really an AssertingVH; we just have to give ValueHandleBase a kind. // Note that we deliberately do not the support the case when dropping a value // handle results in a new value handle being permanently added to the list // (as might occur in theory for CallbackVH's): the new value handle will not // be processed and the checking code will mete out righteous punishment if // the handle is still present once we have finished processing all the other // value handles (it is fine to momentarily add then remove a value handle). for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { Iterator.RemoveFromUseList(); Iterator.AddToExistingUseListAfter(Entry); assert(Entry->Next == &Iterator && "Loop invariant broken."); switch (Entry->getKind()) { case Assert: break; case Tracking: // Mark that this value has been deleted by setting it to an invalid Value // pointer. Entry->operator=(DenseMapInfo<Value *>::getTombstoneKey()); break; case Weak: // Weak just goes to null, which will unlink it from the list. Entry->operator=(nullptr); break; case Callback: // Forward to the subclass's implementation. static_cast<CallbackVH*>(Entry)->deleted(); break; } } // All callbacks, weak references, and assertingVHs should be dropped by now. if (V->HasValueHandle) { #ifndef NDEBUG // Only in +Asserts mode... dbgs() << "While deleting: " << *V->getType() << " %" << V->getName() << "\n"; if (pImpl->ValueHandles[V]->getKind() == Assert) llvm_unreachable("An asserting value handle still pointed to this" " value!"); #endif llvm_unreachable("All references to V were not removed?"); } }
void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) { assert(Old->HasValueHandle &&"Should only be called if ValueHandles present"); assert(Old != New && "Changing value into itself!"); assert(Old->getType() == New->getType() && "replaceAllUses of value with new value of different type!"); // Get the linked list base, which is guaranteed to exist since the // HasValueHandle flag is set. LLVMContextImpl *pImpl = Old->getContext().pImpl; ValueHandleBase *Entry = pImpl->ValueHandles[Old]; assert(Entry && "Value bit set but no entries exist"); // We use a local ValueHandleBase as an iterator so that // ValueHandles can add and remove themselves from the list without // breaking our iteration. This is not really an AssertingVH; we // just have to give ValueHandleBase some kind. for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { Iterator.RemoveFromUseList(); Iterator.AddToExistingUseListAfter(Entry); assert(Entry->Next == &Iterator && "Loop invariant broken."); switch (Entry->getKind()) { case Assert: case Weak: // Asserting and Weak handles do not follow RAUW implicitly. break; case WeakTracking: // Weak goes to the new value, which will unlink it from Old's list. Entry->operator=(New); break; case Callback: // Forward to the subclass's implementation. static_cast<CallbackVH*>(Entry)->allUsesReplacedWith(New); break; } } #ifndef NDEBUG // If any new weak value handles were added while processing the // list, then complain about it now. if (Old->HasValueHandle) for (Entry = pImpl->ValueHandles[Old]; Entry; Entry = Entry->Next) switch (Entry->getKind()) { case WeakTracking: dbgs() << "After RAUW from " << *Old->getType() << " %" << Old->getName() << " to " << *New->getType() << " %" << New->getName() << "\n"; llvm_unreachable( "A weak tracking value handle still pointed to the old value!\n"); default: break; } #endif }
void ValueHandleBase::ValueIsDeleted(Value *V) { assert(V->HasValueHandle && "Should only be called if ValueHandles present"); // Get the linked list base, which is guaranteed to exist since the // HasValueHandle flag is set. LLVMContextImpl *pImpl = V->getContext().pImpl; ValueHandleBase *Entry = pImpl->ValueHandles[V]; assert(Entry && "Value bit set but no entries exist"); // We use a local ValueHandleBase as an iterator so that // ValueHandles can add and remove themselves from the list without // breaking our iteration. This is not really an AssertingVH; we // just have to give ValueHandleBase some kind. for (ValueHandleBase Iterator(Assert, *Entry); Entry; Entry = Iterator.Next) { Iterator.RemoveFromUseList(); Iterator.AddToExistingUseListAfter(Entry); assert(Entry->Next == &Iterator && "Loop invariant broken."); switch (Entry->getKind()) { case Assert: break; case Tracking: // Mark that this value has been deleted by setting it to an invalid Value // pointer. Entry->operator=(DenseMapInfo<Value *>::getTombstoneKey()); break; case Weak: // Weak just goes to null, which will unlink it from the list. Entry->operator=(0); break; case Callback: // Forward to the subclass's implementation. static_cast<CallbackVH*>(Entry)->deleted(); break; } } // All callbacks, weak references, and assertingVHs should be dropped by now. if (V->HasValueHandle) { #ifndef NDEBUG // Only in +Asserts mode... dbgs() << "While deleting: " << *V->getType() << " %" << V->getNameStr() << "\n"; if (pImpl->ValueHandles[V]->getKind() == Assert) llvm_unreachable("An asserting value handle still pointed to this" " value!"); #endif llvm_unreachable("All references to V were not removed?"); } }