[Bugpoint redesign] Modified Functions pass to consider declarations

[diegotf]

Summary

This modification was put in place so the ReduceMetadata pass doesn't have to consider debug functions.

This diff also simplifies the ReduceFunctions pass by directly replacing the function users, instead of going over every instruction to remove ones with undef function calls.

[dblaikie]

Looks good!

llvm/trunk/test/Reduce/remove-funcs.ll

 
 ; CHECK-NOT: uninteresting2()
 define i32 @uninteresting2() {
 entry:
   ret i32 0
 }
 
 ; CHECK-NOT: uninteresting3()
-define i32 @uninteresting3() {
-entry:
-  ret i32 10
-}
+declare void @uninteresting3()

llvm/trunk/tools/llvm-reduce/deltas/ReduceFunctions.cpp

 /// Removes all the Defined Functions (as well as their calls)
 /// that aren't inside any of the desired Chunks.
 static void extractFunctionsFromModule(const std::vector<Chunk> &ChunksToKeep,
                                        Module *Program) {
   // Get functions inside desired chunks
   std::set<Function *> FuncsToKeep;
   unsigned I = 0, FunctionCount = 0;
   for (auto &F : *Program)
-    if (!F.isDeclaration() && I < ChunksToKeep.size()) {
+    if (I < ChunksToKeep.size()) {
       if (ChunksToKeep[I].contains(++FunctionCount))
         FuncsToKeep.insert(&F);
       if (FunctionCount == ChunksToKeep[I].end)
         ++I;
     }
 
   // Delete out-of-chunk functions, and replace their calls with undef
   std::vector<Function *> FuncsToRemove;
+  std::vector<CallInst *> CallsToRemove;
   for (auto &F : *Program)
-    if (!F.isDeclaration() && !FuncsToKeep.count(&F)) {
+    if (!FuncsToKeep.count(&F)) {
+      for (auto U : F.users())
+        if (auto *Call = dyn_cast<CallInst>(U)) {
+          Call->replaceAllUsesWith(UndefValue::get(Call->getType()));
+          CallsToRemove.push_back(Call);
+        }
       F.replaceAllUsesWith(UndefValue::get(F.getType()));
       FuncsToRemove.push_back(&F);
     }
 
+  for (auto *C : CallsToRemove)
+    C->eraseFromParent();
+
   for (auto *F : FuncsToRemove)
     F->eraseFromParent();
-
-  // Delete instructions with undef calls
-  std::vector<Instruction *> InstToRemove;
-  for (auto &F : *Program)
-    for (auto &BB : F)
-      for (auto &I : BB)
-        if (auto *Call = dyn_cast<CallInst>(&I))
-          if (!Call->getCalledFunction()) {
-            // Instruction might be stored / used somewhere else
-            I.replaceAllUsesWith(UndefValue::get(I.getType()));
-            InstToRemove.push_back(&I);
-          }
-
-  for (auto *I : InstToRemove)
-    I->eraseFromParent();
 }
 
 /// Counts the amount of non-declaration functions and prints their
 /// respective name & index
-static unsigned countDefinedFunctions(Module *Program) {
+static unsigned countFunctions(Module *Program) {
   // TODO: Silence index with --quiet flag
   outs() << "----------------------------\n";
   outs() << "Function Index Reference:\n";
   unsigned FunctionCount = 0;
   for (auto &F : *Program)
-    if (!F.isDeclaration())
-      outs() << "\t" << ++FunctionCount << ": " << F.getName() << "\n";
 
   outs() << "----------------------------\n";
   return FunctionCount;
 }
 
 void llvm::reduceFunctionsDeltaPass(TestRunner &Test) {
   outs() << "*** Reducing Functions...\n";
-  unsigned Functions = countDefinedFunctions(Test.getProgram());
+  unsigned Functions = countFunctions(Test.getProgram());
   runDeltaPass(Test, Functions, extractFunctionsFromModule);
   outs() << "----------------------------\n";
-}
+}
 No newline at end of file