diff --git a/include/revng/BasicAnalyses/AdvancedValueInfo.h b/include/revng/BasicAnalyses/AdvancedValueInfo.h
index 3c0f590f7..33baea02a 100644
--- a/include/revng/BasicAnalyses/AdvancedValueInfo.h
+++ b/include/revng/BasicAnalyses/AdvancedValueInfo.h
@@ -946,7 +946,7 @@ AdvancedValueInfo<MemoryOracle>::explore(llvm::BasicBlock *BB, llvm::Value *V) {
     Instruction *I;
     ~DeleteValueOnReturn() {
       if (I->getParent() != nullptr)
-        I->eraseFromParent();
+        eraseFromParent(I);
       else
         I->deleteValue();
     }
diff --git a/include/revng/BasicAnalyses/ShrinkInstructionOperandsPass.h b/include/revng/BasicAnalyses/ShrinkInstructionOperandsPass.h
index 97effd0a9..b9aa4193c 100644
--- a/include/revng/BasicAnalyses/ShrinkInstructionOperandsPass.h
+++ b/include/revng/BasicAnalyses/ShrinkInstructionOperandsPass.h
@@ -152,7 +152,7 @@ ShrinkInstructionOperandsPass::run(llvm::Function &F,
           replaceAndResizeOperand(&I, 1, ActualOp1, OutputSize, DontCare);
           I.mutateType(ActualOutput->getType());
           ActualOutput->replaceAllUsesWith(&I);
-          ActualOutput->eraseFromParent();
+          eraseFromParent(ActualOutput);
         }
 
       } break;
diff --git a/include/revng/Support/IRHelpers.h b/include/revng/Support/IRHelpers.h
index 3f7eb8860..10280e837 100644
--- a/include/revng/Support/IRHelpers.h
+++ b/include/revng/Support/IRHelpers.h
@@ -29,6 +29,35 @@
 #include "revng/Support/Generator.h"
 #include "revng/Support/MetaAddress.h"
 
+extern void dumpUsers(llvm::Value *V) debug_function;
+
+/// Given \p V, checks if there are uses left and then calls eraseFromParent.
+/// In case of leftover uses, they are pretty printed.
+///
+/// \note The remaining use check is not performed on llvm::Functions since they
+/// might have internal blockaddress self-references.
+inline void eraseFromParent(llvm::Value *V) {
+  using namespace llvm;
+
+  if (not isa<Function>(V) and not V->use_empty()) {
+    dbg << "Can't erase a Value still having uses.\n";
+    dbg << "Value:\n  ";
+    V->dump();
+    dbg << "Users:\n";
+    dumpUsers(V);
+    revng_abort();
+  } else {
+    if (auto *I = dyn_cast<Instruction>(V))
+      I->eraseFromParent();
+    else if (auto *BB = dyn_cast<BasicBlock>(V))
+      BB->eraseFromParent();
+    else if (auto *G = dyn_cast<GlobalValue>(V))
+      G->eraseFromParent();
+    else
+      revng_abort();
+  }
+}
+
 template<typename T>
 inline bool contains(T Range, typename T::value_type V) {
   return std::find(std::begin(Range), std::end(Range), V) != std::end(Range);
@@ -52,12 +81,12 @@ inline void purgeBranch(llvm::BasicBlock::iterator I) {
     Successors.insert(DeadBranch->getSuccessor(C));
 
   // Destroy the dead branch
-  DeadBranch->eraseFromParent();
+  eraseFromParent(DeadBranch);
 
   // Check if someone else was jumping there and then destroy
   for (llvm::BasicBlock *BB : Successors)
     if (BB->empty() && llvm::pred_empty(BB))
-      BB->eraseFromParent();
+      eraseFromParent(BB);
 }
 
 inline llvm::ConstantInt *
diff --git a/include/revng/Support/OpaqueFunctionsPool.h b/include/revng/Support/OpaqueFunctionsPool.h
index 4dbcf3fdb..15b056059 100644
--- a/include/revng/Support/OpaqueFunctionsPool.h
+++ b/include/revng/Support/OpaqueFunctionsPool.h
@@ -14,6 +14,7 @@
 
 #include "revng/Support/Assert.h"
 #include "revng/Support/FunctionTags.h"
+#include "revng/Support/IRHelpers.h"
 
 template<typename KeyT>
 class OpaqueFunctionsPool {
@@ -33,7 +34,7 @@ public:
     if (PurgeOnDestruction) {
       for (auto &[Key, F] : Pool) {
         revng_assert(F->use_begin() == F->use_end());
-        F->eraseFromParent();
+        eraseFromParent(F);
       }
     }
   }
diff --git a/include/revng/Support/ProgramCounterHandler.h b/include/revng/Support/ProgramCounterHandler.h
index 486728604..8c0f0a8d7 100644
--- a/include/revng/Support/ProgramCounterHandler.h
+++ b/include/revng/Support/ProgramCounterHandler.h
@@ -153,12 +153,12 @@ public:
       auto *FakeLoad = Builder.CreateLoad(CSVAffectingPC);
       auto *FakeStore = Builder.CreateStore(FakeLoad, CSVAffectingPC);
       bool HasInjectedCode = handleStore(Builder, FakeStore);
-      FakeStore->eraseFromParent();
+      eraseFromParent(FakeStore);
 
       if (not HasInjectedCode) {
         // The store did not produce any effect, the load is useless too
         revng_assert(FakeLoad->use_begin() == FakeLoad->use_end());
-        FakeLoad->eraseFromParent();
+        eraseFromParent(FakeLoad);
       }
     }
   }
diff --git a/lib/FunctionCallIdentification/PruneRetSuccessors.cpp b/lib/FunctionCallIdentification/PruneRetSuccessors.cpp
index 65ebdd8e3..8d3fa29f5 100644
--- a/lib/FunctionCallIdentification/PruneRetSuccessors.cpp
+++ b/lib/FunctionCallIdentification/PruneRetSuccessors.cpp
@@ -39,7 +39,7 @@ bool PruneRetSuccessors::runOnModule(llvm::Module &M) {
       Instruction *OldTerminator = BB.getTerminator();
       auto *NewTerminator = BranchInst::Create(GCBI.anyPC(), &BB);
       NewTerminator->copyMetadata(*OldTerminator);
-      OldTerminator->eraseFromParent();
+      eraseFromParent(OldTerminator);
     }
   }
 
diff --git a/lib/FunctionIsolation/EnforceABI.cpp b/lib/FunctionIsolation/EnforceABI.cpp
index 6e4e01cb5..027b9f3d3 100644
--- a/lib/FunctionIsolation/EnforceABI.cpp
+++ b/lib/FunctionIsolation/EnforceABI.cpp
@@ -166,7 +166,7 @@ void EnforceABIImpl::run() {
 
   // Drop all the old functions, after we stole all of its blocks
   for (Function *OldFunction : OldFunctions)
-    OldFunction->eraseFromParent();
+    eraseFromParent(OldFunction);
 
   // Quick and dirty DCE
   for (auto [F, _] : FunctionsMap)
@@ -292,7 +292,7 @@ void EnforceABIImpl::createPrologue(Function *NewFunction,
         else
           Initializers.createReturn(Builder, ReturnValues);
 
-        Return->eraseFromParent();
+        eraseFromParent(Return);
       }
     }
   }
@@ -351,7 +351,7 @@ void EnforceABIImpl::handleRegularFunctionCall(CallInst *Call) {
   Builder.CreateStore(Builder.CreateCall(OpaquePC), GCBI.pcReg());
 
   // Drop the original call
-  Call->eraseFromParent();
+  eraseFromParent(Call);
 }
 
 static FunctionCallee
diff --git a/lib/FunctionIsolation/IsolateFunctions.cpp b/lib/FunctionIsolation/IsolateFunctions.cpp
index b009aa940..0c049b701 100644
--- a/lib/FunctionIsolation/IsolateFunctions.cpp
+++ b/lib/FunctionIsolation/IsolateFunctions.cpp
@@ -49,7 +49,7 @@ eraseBranch(Instruction *I, BasicBlock *ExpectedUniqueSuccessor = nullptr) {
   revng_assert(T->isUnconditional());
   if (ExpectedUniqueSuccessor != nullptr)
     revng_assert(T->getSuccessor(0) == ExpectedUniqueSuccessor);
-  T->eraseFromParent();
+  eraseFromParent(T);
 }
 
 class ConstantStringsPool {
@@ -580,7 +580,7 @@ bool IFI::handleIndirectBoundary(const std::vector<Boundary> &Boundaries,
     Builder.CreateBr(ClonedBlocks.unexpectedPCBlock());
   }
 
-  OldTerminator->eraseFromParent();
+  eraseFromParent(OldTerminator);
 
   return true;
 }
@@ -824,7 +824,7 @@ void IFI::isolate(const model::Function &Function) {
         ToDrop.push_back(&I);
 
   for (Instruction *I : ToDrop)
-    I->eraseFromParent();
+    eraseFromParent(I);
 
   remapInstructionsInBlocks(ClonedBlocks.Blocks, OldToNew);
 
@@ -866,11 +866,11 @@ void IFI::isolate(const model::Function &Function) {
   auto *Call = cast<CallInst>(*UserIt);
   ++UserIt;
   revng_assert(UserIt == NewFunction->user_end());
-  Call->eraseFromParent();
+  eraseFromParent(Call);
 
   revng_assert(NewFunction->use_empty());
   revng_assert(NewFunction->getBasicBlockList().empty());
-  NewFunction->eraseFromParent();
+  eraseFromParent(NewFunction);
 }
 
 void IFI::createFunctionCall(IRBuilder<> &Builder,
diff --git a/lib/FunctionIsolation/PromoteCSVs.cpp b/lib/FunctionIsolation/PromoteCSVs.cpp
index 52881c9d1..6b5801664 100644
--- a/lib/FunctionIsolation/PromoteCSVs.cpp
+++ b/lib/FunctionIsolation/PromoteCSVs.cpp
@@ -285,7 +285,7 @@ void PromoteCSVs::wrap(CallInst *Call,
   }
 
   // Erase the old call
-  Call->eraseFromParent();
+  eraseFromParent(Call);
 }
 
 static Instruction *findFirstNonAlloca(BasicBlock *BB) {
@@ -360,7 +360,7 @@ void PromoteCSVs::promoteCSVs(Function *F) {
   }
 
   // Drop separators
-  Separator->eraseFromParent();
+  eraseFromParent(Separator);
 
 #ifndef NDEBUG
   auto It = findFirstNonAlloca(&Entry)->getIterator();
diff --git a/lib/FunctionIsolation/RemoveExceptionalCalls.cpp b/lib/FunctionIsolation/RemoveExceptionalCalls.cpp
index 02d4cf68c..d736b8348 100644
--- a/lib/FunctionIsolation/RemoveExceptionalCalls.cpp
+++ b/lib/FunctionIsolation/RemoveExceptionalCalls.cpp
@@ -42,7 +42,7 @@ bool RemoveExceptionalCalls::runOnModule(llvm::Module &M) {
     BB->splitBasicBlock(Call);
 
     // Drop terminator of the old basic block
-    BB->getTerminator()->eraseFromParent();
+    eraseFromParent(BB->getTerminator());
 
     // Terminate with an unreachable
     new UnreachableInst(C, BB);
@@ -50,7 +50,7 @@ bool RemoveExceptionalCalls::runOnModule(llvm::Module &M) {
     // Drop function call
     auto *Undef = UndefValue::get(Call->getType());
     Call->replaceAllUsesWith(Undef);
-    Call->eraseFromParent();
+    eraseFromParent(Call);
   }
 
   // Garbage collect dead blocks
diff --git a/lib/Support/IRHelpers.cpp b/lib/Support/IRHelpers.cpp
index 64b12964b..a2ce4ba93 100644
--- a/lib/Support/IRHelpers.cpp
+++ b/lib/Support/IRHelpers.cpp
@@ -206,3 +206,46 @@ Function *changeFunctionType(Function &OldFunction,
 
   return NewFunction;
 }
+
+void dumpUsers(llvm::Value *V) {
+  using namespace llvm;
+
+  struct InstructionUser {
+    Function *F;
+    BasicBlock *BB;
+    Instruction *I;
+    bool operator<(const InstructionUser &Other) const {
+      return std::tie(F, BB, I) < std::tie(Other.F, Other.BB, Other.I);
+    }
+  };
+  SmallVector<InstructionUser> InstructionUsers;
+  for (User *U : V->users()) {
+    if (auto *I = dyn_cast<Instruction>(U)) {
+      BasicBlock *BB = I->getParent();
+      Function *F = BB->getParent();
+      InstructionUsers.push_back({ F, BB, I });
+    } else {
+      dbg << "  ";
+      U->dump();
+    }
+  }
+
+  llvm::sort(InstructionUsers);
+
+  Function *LastF = nullptr;
+  BasicBlock *LastBB = nullptr;
+  for (InstructionUser &IU : InstructionUsers) {
+    if (IU.F != LastF) {
+      LastF = IU.F;
+      dbg << "  Function " << getName(LastF) << "\n";
+    }
+
+    if (IU.BB != LastBB) {
+      LastBB = IU.BB;
+      dbg << "    Block " << getName(LastBB) << "\n";
+    }
+
+    dbg << "    ";
+    IU.I->dump();
+  }
+}
diff --git a/lib/Support/ProgramCounterHandler.cpp b/lib/Support/ProgramCounterHandler.cpp
index 85628e8ff..ce37c97c6 100644
--- a/lib/Support/ProgramCounterHandler.cpp
+++ b/lib/Support/ProgramCounterHandler.cpp
@@ -211,7 +211,7 @@ protected:
 static void eraseIfNoUse(const WeakVH &V) {
   if (Instruction *I = dyn_cast_or_null<Instruction>(&*V))
     if (I->use_begin() == I->use_end())
-      I->eraseFromParent();
+      eraseFromParent(I);
 }
 
 static SwitchInst *getNextSwitch(SwitchInst::CaseHandle Case) {
@@ -578,19 +578,19 @@ public:
     WeakVH AddressVH(CurrentAddress);
 
     // Drop the epoch switch
-    Root->eraseFromParent();
+    eraseFromParent(Root);
 
     // Drop all the switches on address space
     for (BasicBlock *BB : AddressSpaceSwitchesBBs)
-      BB->eraseFromParent();
+      eraseFromParent(BB);
 
     // Drop all the switches on type
     for (BasicBlock *BB : TypeSwitchesBBs)
-      BB->eraseFromParent();
+      eraseFromParent(BB);
 
     // Drop all the switches on address
     for (BasicBlock *BB : AddressSwitchesBBs)
-      BB->eraseFromParent();
+      eraseFromParent(BB);
 
     eraseIfNoUse(EpochVH);
     eraseIfNoUse(AddressSpaceVH);
diff --git a/lib/TypeShrinking/TypeShrinking.cpp b/lib/TypeShrinking/TypeShrinking.cpp
index fe9ba32f8..4e23e7e5f 100644
--- a/lib/TypeShrinking/TypeShrinking.cpp
+++ b/lib/TypeShrinking/TypeShrinking.cpp
@@ -22,6 +22,7 @@
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 
+#include "revng/Support/IRHelpers.h"
 #include "revng/TypeShrinking/BitLiveness.h"
 #include "revng/TypeShrinking/DataFlowGraph.h"
 #include "revng/TypeShrinking/TypeShrinking.h"
@@ -122,7 +123,7 @@ runTypeShrinking(Function &F, const BitLivenessAnalysisResults &FixedPoints) {
           Use->set(I);
 
         // Drop the original instruction
-        Ins->eraseFromParent();
+        eraseFromParent(Ins);
       }
     }
   }
diff --git a/tools/revng-lift/AdvancedValueInfoPass.h b/tools/revng-lift/AdvancedValueInfoPass.h
index e45ea9c46..5504ce57c 100644
--- a/tools/revng-lift/AdvancedValueInfoPass.h
+++ b/tools/revng-lift/AdvancedValueInfoPass.h
@@ -94,7 +94,7 @@ AdvancedValueInfoPass::run(llvm::Function &F,
                                                  I->getOperand(1),
                                                  Twine(),
                                                  I));
-    I->eraseFromParent();
+    eraseFromParent(I);
   }
 
   Function *Marker = F.getParent()->getFunction(MarkerName);
diff --git a/tools/revng-lift/CPUStateAccessAnalysisPass.cpp b/tools/revng-lift/CPUStateAccessAnalysisPass.cpp
index 82ba42815..630fe6f71 100644
--- a/tools/revng-lift/CPUStateAccessAnalysisPass.cpp
+++ b/tools/revng-lift/CPUStateAccessAnalysisPass.cpp
@@ -2647,7 +2647,7 @@ void CPUStateAccessFixer::setupLoadInEnv(Instruction *LoadToFix,
       Clone->replaceAllUsesWith(Loaded);
       InstructionsToRemove.push_back(Clone);
     } else {
-      CaseBlock->eraseFromParent();
+      eraseFromParent(CaseBlock);
       CaseBlock = nullptr; // Prevent this from being used
     }
   } break;
@@ -2659,7 +2659,7 @@ void CPUStateAccessFixer::setupLoadInEnv(Instruction *LoadToFix,
       InstructionsToRemove.push_back(Clone);
       Switch->addCase(OffsetConstInt, CaseBlock);
     } else {
-      CaseBlock->eraseFromParent();
+      eraseFromParent(CaseBlock);
       CaseBlock = nullptr; // Prevent this from being used
     }
   } break;
@@ -2709,7 +2709,7 @@ void CPUStateAccessFixer::setupStoreInEnv(Instruction *StoreToFix,
     InstructionsToRemove.push_back(Clone);
     Switch->addCase(OffsetConstInt, CaseBlock);
   } else {
-    CaseBlock->eraseFromParent();
+    eraseFromParent(CaseBlock);
   }
 }
 
@@ -3048,7 +3048,7 @@ bool CPUStateAccessFixer::run() {
 
   // Remove fixed accesses
   for (Instruction *Instr : InstructionsToRemove)
-    Instr->eraseFromParent();
+    eraseFromParent(Instr);
   InstructionsToRemove.clear();
 
   if (FixAccessLog.isEnabled()) {
diff --git a/tools/revng-lift/CodeGenerator.cpp b/tools/revng-lift/CodeGenerator.cpp
index 0ef68949b..4ed3ba33d 100644
--- a/tools/revng-lift/CodeGenerator.cpp
+++ b/tools/revng-lift/CodeGenerator.cpp
@@ -175,10 +175,10 @@ public:
     }
 
     for (CallInst *Call : ToErase)
-      Call->eraseFromParent();
+      eraseFromParent(Call);
 
     for (auto [T, F] : Map)
-      F->eraseFromParent();
+      eraseFromParent(F);
 
     Map.clear();
   }
@@ -511,7 +511,7 @@ bool CpuLoopFunctionPass::runOnModule(Module &M) {
   revng_assert(isa<BranchInst>(LastInstruction));
 
   // Remove the last instruction and replace it with a ret
-  LastInstruction->eraseFromParent();
+  eraseFromParent(LastInstruction);
   ReturnInst::Create(F.getParent()->getContext(), Footer);
 
   // Part 2: replace the call to cpu_*_exec with exception_index
@@ -545,7 +545,7 @@ bool CpuLoopFunctionPass::runOnModule(Module &M) {
                                                     TargetType);
   Value *ExceptionIndex = Builder.CreateLoad(ExceptionIndexPtr);
   Call->replaceAllUsesWith(ExceptionIndex);
-  Call->eraseFromParent();
+  eraseFromParent(Call);
 
   return true;
 }
@@ -664,12 +664,12 @@ bool CpuLoopExitPass::runOnModule(llvm::Module &M) {
     // Return immediately
     createRet(Call);
     auto *Unreach = cast<UnreachableInst>(&*++Call->getIterator());
-    Unreach->eraseFromParent();
+    eraseFromParent(Unreach);
 
     Function *Caller = Call->getParent()->getParent();
 
     // Remove the call to cpu_loop_exit
-    Call->eraseFromParent();
+    eraseFromParent(Call);
 
     if (FixedCallers.find(Caller) == FixedCallers.end()) {
       FixedCallers.insert(Caller);
@@ -710,7 +710,7 @@ bool CpuLoopExitPass::runOnModule(llvm::Module &M) {
                                                   NewBB);
           UnreachableInst *Temp = new UnreachableInst(Context, QuitBB);
           createRet(Temp);
-          Temp->eraseFromParent();
+          eraseFromParent(Temp);
 
           // Check value of cpu_loop_exiting
           auto *Branch = cast<BranchInst>(&*++(RecCall->getIterator()));
@@ -725,7 +725,7 @@ bool CpuLoopExitPass::runOnModule(llvm::Module &M) {
                                        ConstantInt::getTrue(BoolType));
 
           BranchInst::Create(QuitBB, NewBB, Compare, Branch);
-          Branch->eraseFromParent();
+          eraseFromParent(Branch);
 
           // Add to the work list only if it hasn't been fixed already
           if (FixedCallers.find(RecCaller) == FixedCallers.end()) {
@@ -761,7 +761,7 @@ void CodeGenerator::translate(Optional<uint64_t> RawVirtualAddress) {
   CpuLoopPM.run(*HelpersModule);
 
   // Drop the main
-  HelpersModule->getFunction("main")->eraseFromParent();
+  eraseFromParent(HelpersModule->getFunction("main"));
 
   // From syscall.c
   new GlobalVariable(*TheModule,
@@ -1222,7 +1222,7 @@ void CodeGenerator::translate(Optional<uint64_t> RawVirtualAddress) {
     // the last call to exit_tb
     auto *LastBlock = Builder.GetInsertBlock();
     if (LastBlock->empty())
-      LastBlock->eraseFromParent();
+      eraseFromParent(LastBlock);
     else if (!LastBlock->rbegin()->isTerminator()) {
       // Something went wrong, probably a mistranslation
       Builder.CreateUnreachable();
diff --git a/tools/revng-lift/DropHelperCallsPass.h b/tools/revng-lift/DropHelperCallsPass.h
index 51da09c8c..7d54e8b9a 100644
--- a/tools/revng-lift/DropHelperCallsPass.h
+++ b/tools/revng-lift/DropHelperCallsPass.h
@@ -54,7 +54,7 @@ public:
 
   void cleanup() {
     for (auto &P : TemporaryFunctions)
-      P.second->eraseFromParent();
+      eraseFromParent(P.second);
 
     TemporaryFunctions.clear();
   }
@@ -175,7 +175,7 @@ DropHelperCallsPass::run(llvm::Function &F, llvm::FunctionAnalysisManager &) {
   }
 
   for (CallInst *C : ToDelete)
-    C->eraseFromParent();
+    eraseFromParent(C);
 
   return PreservedAnalyses::none();
 }
diff --git a/tools/revng-lift/InstructionTranslator.cpp b/tools/revng-lift/InstructionTranslator.cpp
index 19f6ef43e..93f4d25b3 100644
--- a/tools/revng-lift/InstructionTranslator.cpp
+++ b/tools/revng-lift/InstructionTranslator.cpp
@@ -541,7 +541,7 @@ void IT::finalizeNewPCMarkers(std::string &CoveragePath) {
   }
 
   for (auto *Call : CallsToRemove)
-    Call->eraseFromParent();
+    eraseFromParent(Call);
 
   Output << std::dec;
 }
diff --git a/tools/revng-lift/JumpTargetManager.cpp b/tools/revng-lift/JumpTargetManager.cpp
index edaaf0670..6c89c6059 100644
--- a/tools/revng-lift/JumpTargetManager.cpp
+++ b/tools/revng-lift/JumpTargetManager.cpp
@@ -120,7 +120,7 @@ static void exitTBCleanup(Instruction *ExitTBCall) {
     if (auto DeadBranch = dyn_cast<BranchInst>(ToDelete))
       purgeBranch(BasicBlock::iterator(DeadBranch));
     else
-      ToDelete->eraseFromParent();
+      eraseFromParent(ToDelete);
 
     ToDelete = &*(--BB->end());
   }
@@ -230,7 +230,7 @@ void TDBP::pinConstantStoreInternal(MetaAddress Address, CallInst *ExitTBCall) {
   BasicBlock::iterator BlockEnd = ExitTBCall->getParent()->end();
   CallIt++;
   revng_assert(CallIt != BlockEnd and isa<UnreachableInst>(&*CallIt));
-  CallIt->eraseFromParent();
+  eraseFromParent(&*CallIt);
 
   // Cleanup of what's afterwards (only a unconditional jump is
   // allowed)
@@ -250,7 +250,7 @@ void TDBP::pinConstantStoreInternal(MetaAddress Address, CallInst *ExitTBCall) {
     BranchInst::Create(JTM->unexpectedPC(), ExitTBCall);
   }
 
-  ExitTBCall->eraseFromParent();
+  eraseFromParent(ExitTBCall);
 }
 
 bool TDBP::pinConstantStore(Function &F) {
@@ -775,13 +775,13 @@ void JumpTargetManager::translateIndirectJumps() {
           BranchInst::Create(AnyPC, Call);
         }
 
-        Call->eraseFromParent();
+        eraseFromParent(Call);
       }
     }
   }
 
   revng_assert(ExitTB->use_empty());
-  ExitTB->eraseFromParent();
+  eraseFromParent(ExitTB);
   ExitTB = nullptr;
 }
 
@@ -867,11 +867,11 @@ void JumpTargetManager::purgeTranslation(BasicBlock *Start) {
     while (pred_begin(BB) != pred_end(BB)) {
       BasicBlock *Predecessor = *pred_begin(BB);
       revng_assert(pred_empty(Predecessor));
-      Predecessor->eraseFromParent();
+      eraseFromParent(Predecessor);
     }
 
     revng_assert(BB->use_empty());
-    BB->eraseFromParent();
+    eraseFromParent(BB);
   }
 }
 
@@ -991,7 +991,7 @@ void JumpTargetManager::prepareDispatcher() {
 static void purge(BasicBlock *BB) {
   // Allow up to a single instruction in the basic block
   if (!BB->empty())
-    BB->begin()->eraseFromParent();
+    eraseFromParent(&*BB->begin());
   revng_assert(BB->empty());
 }
 
@@ -1216,7 +1216,7 @@ public:
     // Actually drop the calls
     //
     for (CallInst *Call : ToErase)
-      Call->eraseFromParent();
+      eraseFromParent(Call);
 
     return PreservedAnalyses::none();
   }
@@ -1560,7 +1560,7 @@ void JumpTargetManager::harvestWithAVI() {
         // Apply replacements
         for (auto &P : Replacements) {
           P.first->replaceAllUsesWith(P.second);
-          P.first->eraseFromParent();
+          eraseFromParent(P.first);
         }
       }
     }
@@ -1581,7 +1581,7 @@ void JumpTargetManager::harvestWithAVI() {
   }
 
   for (CallInst *Call : ToErase)
-    Call->eraseFromParent();
+    eraseFromParent(Call);
 
   //
   // Update alias analysis
@@ -1621,7 +1621,7 @@ void JumpTargetManager::harvestWithAVI() {
           ToDelete.push_back(&I);
 
     for (Instruction *I : ToDelete)
-      I->eraseFromParent();
+      eraseFromParent(I);
   }
 
   {
@@ -1800,7 +1800,7 @@ void JumpTargetManager::harvestWithAVI() {
   //
   // Drop the optimized function
   //
-  OptimizedFunction->eraseFromParent();
+  eraseFromParent(OptimizedFunction);
 
   // Drop temporary functions
   SCB.cleanup();
@@ -1833,7 +1833,7 @@ void JumpTargetManager::harvest() {
     for (BasicBlock *BB : Unreachable)
       BB->dropAllReferences();
     for (BasicBlock *BB : Unreachable)
-      BB->eraseFromParent();
+      eraseFromParent(BB);
 
     // TODO: move me to a commit function
 
diff --git a/tools/revng-lift/JumpTargetManager.h b/tools/revng-lift/JumpTargetManager.h
index f93966e60..c429bad23 100644
--- a/tools/revng-lift/JumpTargetManager.h
+++ b/tools/revng-lift/JumpTargetManager.h
@@ -540,7 +540,7 @@ private:
     MetaAddress PC = getPCFromNewPCCall(I);
     if (PC.isValid())
       OriginalInstructionAddresses.erase(PC);
-    I->eraseFromParent();
+    eraseFromParent(I);
   }
 
   /// \brief Drop \p Start and all the descendants, stopping when a JT is met
diff --git a/tools/revng-lift/VariableManager.cpp b/tools/revng-lift/VariableManager.cpp
index 7a5d2e7f1..950c01d34 100644
--- a/tools/revng-lift/VariableManager.cpp
+++ b/tools/revng-lift/VariableManager.cpp
@@ -411,7 +411,7 @@ bool VariableManager::memcpyAtEnvOffset(llvm::IRBuilder<> &Builder,
   }
 
   if (OnlyPointersAndPadding)
-    cast<Instruction>(OtherBasePtr)->eraseFromParent();
+    eraseFromParent(cast<Instruction>(OtherBasePtr));
 
   return Offset == TotalSize;
 }
@@ -582,7 +582,7 @@ VariableManager::getByCPUStateOffsetInternal(intptr_t Offset,
 
     if (it != CPUStateGlobals.end()) {
       it->second->replaceAllUsesWith(NewVariable);
-      it->second->eraseFromParent();
+      eraseFromParent(it->second);
     }
 
     CPUStateGlobals[Offset] = NewVariable;