[NFC] Remove the instruction list from the arguments of llvm::ReplaceInstWithValue().

[vporpo]

Summary

This is part of a series of cleanup patches towards making BasicBlock::getInstList() private.

llvm/include/llvm/Transforms/Utils/BasicBlockUtils.h

 
 /// Try to remove redundant dbg.value instructions from given basic block.
 /// Returns true if at least one instruction was removed. Remove redundant
 /// pseudo ops when RemovePseudoOp is true.
 bool RemoveRedundantDbgInstrs(BasicBlock *BB);
 
 /// Replace all uses of an instruction (specified by BI) with a value, then
 /// remove and delete the original instruction.
-void ReplaceInstWithValue(BasicBlock::InstListType &BIL,
-                          BasicBlock::iterator &BI, Value *V);
+void ReplaceInstWithValue(BasicBlock::iterator &BI, Value *V);
 
 /// Replace the instruction specified by BI with the instruction specified by I.
 /// Copies DebugLoc from BI to I, if I doesn't already have a DebugLoc. The
 /// original instruction is deleted and BI is updated to point to the new
 /// instruction.
 void ReplaceInstWithInst(BasicBlock *BB, BasicBlock::iterator &BI,
                          Instruction *I);
 

llvm/lib/Transforms/Utils/BasicBlockUtils.cpp

bool llvm::RemoveRedundantDbgInstrs(BasicBlock *BB) {
   MadeChanges |= removeRedundantDbgInstrsUsingForwardScan(BB);
 
   if (MadeChanges)
     LLVM_DEBUG(dbgs() << "Removed redundant dbg instrs from: "
                       << BB->getName() << "\n");
   return MadeChanges;
 }
 
-void llvm::ReplaceInstWithValue(BasicBlock::InstListType &BIL,
-                                BasicBlock::iterator &BI, Value *V) {
+void llvm::ReplaceInstWithValue(BasicBlock::iterator &BI, Value *V) {
   Instruction &I = *BI;
   // Replaces all of the uses of the instruction with uses of the value
   I.replaceAllUsesWith(V);
 
   // Make sure to propagate a name if there is one already.
   if (I.hasName() && !V->hasName())
     V->takeName(&I);
 
   // Delete the unnecessary instruction now...
-  BI = BIL.erase(BI);
+  BI = BI->eraseFromParent();
 }
 
 void llvm::ReplaceInstWithInst(BasicBlock *BB, BasicBlock::iterator &BI,
                                Instruction *I) {
   assert(I->getParent() == nullptr &&
          "ReplaceInstWithInst: Instruction already inserted into basic block!");
 
   // Copy debug location to newly added instruction, if it wasn't already set
   // by the caller.
   if (!I->getDebugLoc())
     I->setDebugLoc(BI->getDebugLoc());
 
   // Insert the new instruction into the basic block...
   BasicBlock::iterator New = I->insertAt(BB, BI);
 
   // Replace all uses of the old instruction, and delete it.
-  ReplaceInstWithValue(BB->getInstList(), BI, I);
+  ReplaceInstWithValue(BI, I);
 
   // Move BI back to point to the newly inserted instruction
   BI = New;
 }
 
 bool llvm::IsBlockFollowedByDeoptOrUnreachable(const BasicBlock *BB) {
   // Remember visited blocks to avoid infinite loop
   SmallPtrSet<const BasicBlock *, 8> VisitedBlocks;