Remove unused function.

[oota-llvm.git] / tools / bugpoint / CrashDebugger.cpp

diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp
index 66b6511067377d7b4e7e2512087c70bf7b09893e..7dcbfe3c4a68a9a7a8e9e74ebfcd684eaaf46c7f 100644 (file)
--- a/tools/bugpoint/CrashDebugger.cpp
+++ b/tools/bugpoint/CrashDebugger.cpp
@@ -2,8 +2,8 @@
 //
 //                     The LLVM Compiler Infrastructure
 //
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
@@ -14,15 +14,14 @@
 #include "BugDriver.h"
 #include "ToolRunner.h"
 #include "ListReducer.h"
-#include "llvm/Constant.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/PassManager.h"
-#include "llvm/SymbolTable.h"
+#include "llvm/ValueSymbolTable.h"
 #include "llvm/Analysis/Verifier.h"
-#include "llvm/Bytecode/Writer.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Cloning.h"
@@ -71,7 +70,7 @@ ReducePassList::doTest(std::vector<const PassInfo*> &Prefix,
 
     BD.Program = ParseInputFile(PrefixOutput.toString());
     if (BD.Program == 0) {
-      std::cerr << BD.getToolName() << ": Error reading bytecode file '"
+      std::cerr << BD.getToolName() << ": Error reading bitcode file '"
                 << PrefixOutput << "'!\n";
       exit(1);
     }
@@ -126,13 +125,14 @@ bool
 ReduceCrashingGlobalVariables::TestGlobalVariables(
                               std::vector<GlobalVariable*>& GVs) {
   // Clone the program to try hacking it apart...
-  Module *M = CloneModule(BD.getProgram());
+  DenseMap<const Value*, Value*> ValueMap;
+  Module *M = CloneModule(BD.getProgram(), ValueMap);
 
   // Convert list to set for fast lookup...
   std::set<GlobalVariable*> GVSet;
 
   for (unsigned i = 0, e = GVs.size(); i != e; ++i) {
-    GlobalVariable* CMGV = M->getNamedGlobal(GVs[i]->getName());
+    GlobalVariable* CMGV = cast<GlobalVariable>(ValueMap[GVs[i]]);
     assert(CMGV && "Global Variable not in module?!");
     GVSet.insert(CMGV);
   }
@@ -194,7 +194,7 @@ bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) {
 
   //if main isn't present, claim there is no problem
   if (KeepMain && find(Funcs.begin(), Funcs.end(),
-                       BD.getProgram()->getMainFunction()) == Funcs.end())
+                       BD.getProgram()->getFunction("main")) == Funcs.end())
     return false;
 
   // Clone the program to try hacking it apart...
@@ -206,9 +206,9 @@ bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) {
     // FIXME: bugpoint should add names to all stripped symbols.
     assert(!Funcs[i]->getName().empty() &&
            "Bugpoint doesn't work on stripped modules yet PR718!");
-    Function *CMF = M->getFunction(Funcs[i]->getName(),
-                                   Funcs[i]->getFunctionType());
+    Function *CMF = M->getFunction(Funcs[i]->getName());
     assert(CMF && "Function not in module?!");
+    assert(CMF->getFunctionType() == Funcs[i]->getFunctionType() && "wrong ty");
     Functions.insert(CMF);
   }
 
@@ -271,8 +271,9 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) {
   for (unsigned i = 0, e = BBs.size(); i != e; ++i) {
     // Convert the basic block from the original module to the new module...
     const Function *F = BBs[i]->getParent();
-    Function *CMF = M->getFunction(F->getName(), F->getFunctionType());
+    Function *CMF = M->getFunction(F->getName());
     assert(CMF && "Function not in module?!");
+    assert(CMF->getFunctionType() == F->getFunctionType() && "wrong type?");
 
     // Get the mapped basic block...
     Function::iterator CBI = CMF->begin();
@@ -299,17 +300,16 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) {
         for (succ_iterator SI = succ_begin(BB), E = succ_end(BB); SI != E; ++SI)
           (*SI)->removePredecessor(BB);
 
-        if (BB->getTerminator()->getType() != Type::VoidTy)
-          BB->getTerminator()->replaceAllUsesWith(
-                      Constant::getNullValue(BB->getTerminator()->getType()));
+        TerminatorInst *BBTerm = BB->getTerminator();
+        
+        if (isa<StructType>(BBTerm->getType()))
+           BBTerm->replaceAllUsesWith(UndefValue::get(BBTerm->getType()));
+        else if (BB->getTerminator()->getType() != Type::VoidTy)
+          BBTerm->replaceAllUsesWith(Constant::getNullValue(BBTerm->getType()));
 
-        // Delete the old terminator instruction...
+        // Replace the old terminator instruction.
         BB->getInstList().pop_back();
-
-        // Add a new return instruction of the appropriate type...
-        const Type *RetTy = BB->getParent()->getReturnType();
-        new ReturnInst(RetTy == Type::VoidTy ? 0 :
-                       Constant::getNullValue(RetTy), BB);
+        new UnreachableInst(BB);
       }
 
   // The CFG Simplifier pass may delete one of the basic blocks we are
@@ -337,10 +337,10 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<const BasicBlock*> &BBs) {
     // module, and that they don't include any deleted blocks.
     BBs.clear();
     for (unsigned i = 0, e = BlockInfo.size(); i != e; ++i) {
-      SymbolTable &ST = BlockInfo[i].first->getValueSymbolTable();
-      SymbolTable::plane_iterator PI = ST.find(Type::LabelTy);
-      if (PI != ST.plane_end() && PI->second.count(BlockInfo[i].second))
-        BBs.push_back(cast<BasicBlock>(PI->second[BlockInfo[i].second]));
+      ValueSymbolTable &ST = BlockInfo[i].first->getValueSymbolTable();
+      Value* V = ST.lookup(BlockInfo[i].second);
+      if (V && V->getType() == Type::LabelTy)
+        BBs.push_back(cast<BasicBlock>(V));
     }
     return true;
   }
@@ -396,7 +396,7 @@ static bool DebugACrash(BugDriver &BD,  bool (*TestFn)(BugDriver &, Module *)) {
           ReduceCrashingGlobalVariables(BD, TestFn).reduceList(GVs);
 
           if (GVs.size() < OldSize)
-            BD.EmitProgressBytecode("reduced-global-variables");
+            BD.EmitProgressBitcode("reduced-global-variables");
         }
       }
     }
@@ -417,7 +417,7 @@ static bool DebugACrash(BugDriver &BD,  bool (*TestFn)(BugDriver &, Module *)) {
     ReduceCrashingFunctions(BD, TestFn).reduceList(Functions);
 
     if (Functions.size() < OldSize)
-      BD.EmitProgressBytecode("reduced-function");
+      BD.EmitProgressBitcode("reduced-function");
   }
 
   // Attempt to delete entire basic blocks at a time to speed up
@@ -508,7 +508,7 @@ ExitLoops:
     }
   }
 
-  BD.EmitProgressBytecode("reduced-simplified");
+  BD.EmitProgressBitcode("reduced-simplified");
 
   return false;
 }
@@ -532,7 +532,7 @@ bool BugDriver::debugOptimizerCrash(const std::string &ID) {
             << (PassesToRun.size() == 1 ? ": " : "es: ")
             << getPassesString(PassesToRun) << '\n';
 
-  EmitProgressBytecode(ID);
+  EmitProgressBitcode(ID);
 
   return DebugACrash(*this, TestForOptimizerCrash);
 }