[CodeGen] Reuse BlockUtils for -unreachableblockelim pass (NFC)

[modocache]

Summary

The logic in the -unreachableblockelim pass does the following:

1. It traverses the function it's given in depth-first order and creates a set of basic blocks that are unreachable from the function's entry node.
2. It iterates over each of those unreachable blocks and (1) removes any successors' references to the dead block, and (2) replaces any uses of instructions from the dead block with null.

The logic in (2) above is identical to what the llvm::DeleteDeadBlocks
function from BasicBlockUtils.h does. The only difference is that
llvm::DeleteDeadBlocks replaces uses of instructions from dead blocks
not with null, but with undef.

Replace the duplicate logic in the -unreachableblockelim pass with a
call to llvm::DeleteDeadBlocks. This results in less code but no
functional change (NFC).

[davide]

LGTM.

[modocache]

Thanks for the review!

llvm/trunk/lib/CodeGen/UnreachableBlockElim.cpp

 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Pass.h"
+#include "llvm/Transforms/Utils/BasicBlockUtils.h"
 using namespace llvm;
 
 static bool eliminateUnreachableBlock(Function &F) {
   df_iterator_default_set<BasicBlock*> Reachable;
 
   // Mark all reachable blocks.
   for (BasicBlock *BB : depth_first_ext(&F, Reachable))
     (void)BB/* Mark all reachable blocks */;
 
-  // Loop over all dead blocks, remembering them and deleting all instructions
-  // in them.
+  // Collect all dead blocks.
   std::vector<BasicBlock*> DeadBlocks;
   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
     if (!Reachable.count(&*I)) {
       BasicBlock *BB = &*I;
       DeadBlocks.push_back(BB);
-      while (PHINode *PN = dyn_cast<PHINode>(BB->begin())) {
-        PN->replaceAllUsesWith(Constant::getNullValue(PN->getType()));
-        BB->getInstList().pop_front();
-      }
-      for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
-        (*SI)->removePredecessor(BB);
-      BB->dropAllReferences();
     }
 
-  // Actually remove the blocks now.
-  for (unsigned i = 0, e = DeadBlocks.size(); i != e; ++i) {
-    DeadBlocks[i]->eraseFromParent();
-  }
+  // Delete the dead blocks.
+  DeleteDeadBlocks(DeadBlocks);
 
   return !DeadBlocks.empty();
 }
 
 namespace {
 class UnreachableBlockElimLegacyPass : public FunctionPass {
   bool runOnFunction(Function &F) override {
     return eliminateUnreachableBlock(F);