X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fbugpoint%2FCrashDebugger.cpp;h=7dcbfe3c4a68a9a7a8e9e74ebfcd684eaaf46c7f;hb=8d3f36f05cb97efb1cc24a5c64d6c792651cd897;hp=69837f9c2a8d8a0e4ce02c431b2f1410cef6eee0;hpb=47b14a4a6a455c7be169cfd312fcbe796f0ad426;p=oota-llvm.git diff --git a/tools/bugpoint/CrashDebugger.cpp b/tools/bugpoint/CrashDebugger.cpp index 69837f9c2a8..7dcbfe3c4a6 100644 --- a/tools/bugpoint/CrashDebugger.cpp +++ b/tools/bugpoint/CrashDebugger.cpp @@ -1,10 +1,10 @@ //===- CrashDebugger.cpp - Debug compilation crashes ----------------------===// -// +// // 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. +// //===----------------------------------------------------------------------===// // // This file defines the bugpoint internals that narrow down compilation crashes @@ -12,31 +12,38 @@ //===----------------------------------------------------------------------===// #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/Type.h" +#include "llvm/ValueSymbolTable.h" #include "llvm/Analysis/Verifier.h" -#include "llvm/Bytecode/Writer.h" #include "llvm/Support/CFG.h" -#include "llvm/Support/ToolRunner.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Utils/Cloning.h" -#include "Support/FileUtilities.h" +#include "llvm/Support/FileUtilities.h" +#include "llvm/Support/CommandLine.h" #include #include using namespace llvm; +namespace { + cl::opt + KeepMain("keep-main", + cl::desc("Force function reduction to keep main"), + cl::init(false)); +} + namespace llvm { class ReducePassList : public ListReducer { BugDriver &BD; public: ReducePassList(BugDriver &bd) : BD(bd) {} - + // doTest - Return true iff running the "removed" passes succeeds, and // running the "Kept" passes fail when run on the output of the "removed" // passes. If we return true, we update the current module of bugpoint. @@ -49,28 +56,30 @@ namespace llvm { ReducePassList::TestResult ReducePassList::doTest(std::vector &Prefix, std::vector &Suffix) { - std::string PrefixOutput; + sys::Path PrefixOutput; Module *OrigProgram = 0; if (!Prefix.empty()) { std::cout << "Checking to see if these passes crash: " << getPassesString(Prefix) << ": "; - if (BD.runPasses(Prefix, PrefixOutput)) + std::string PfxOutput; + if (BD.runPasses(Prefix, PfxOutput)) return KeepPrefix; + PrefixOutput.set(PfxOutput); OrigProgram = BD.Program; - BD.Program = ParseInputFile(PrefixOutput); + 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); } - removeFile(PrefixOutput); + PrefixOutput.eraseFromDisk(); } std::cout << "Checking to see if these passes crash: " << getPassesString(Suffix) << ": "; - + if (BD.runPasses(Suffix)) { delete OrigProgram; // The suffix crashes alone... return KeepSuffix; @@ -84,7 +93,82 @@ ReducePassList::doTest(std::vector &Prefix, return NoFailure; } +namespace { + /// ReduceCrashingGlobalVariables - This works by removing the global + /// variable's initializer and seeing if the program still crashes. If it + /// does, then we keep that program and try again. + /// + class ReduceCrashingGlobalVariables : public ListReducer { + BugDriver &BD; + bool (*TestFn)(BugDriver &, Module *); + public: + ReduceCrashingGlobalVariables(BugDriver &bd, + bool (*testFn)(BugDriver&, Module*)) + : BD(bd), TestFn(testFn) {} + + virtual TestResult doTest(std::vector& Prefix, + std::vector& Kept) { + if (!Kept.empty() && TestGlobalVariables(Kept)) + return KeepSuffix; + + if (!Prefix.empty() && TestGlobalVariables(Prefix)) + return KeepPrefix; + + return NoFailure; + } + + bool TestGlobalVariables(std::vector& GVs); + }; +} + +bool +ReduceCrashingGlobalVariables::TestGlobalVariables( + std::vector& GVs) { + // Clone the program to try hacking it apart... + DenseMap ValueMap; + Module *M = CloneModule(BD.getProgram(), ValueMap); + + // Convert list to set for fast lookup... + std::set GVSet; + + for (unsigned i = 0, e = GVs.size(); i != e; ++i) { + GlobalVariable* CMGV = cast(ValueMap[GVs[i]]); + assert(CMGV && "Global Variable not in module?!"); + GVSet.insert(CMGV); + } + + std::cout << "Checking for crash with only these global variables: "; + PrintGlobalVariableList(GVs); + std::cout << ": "; + + // Loop over and delete any global variables which we aren't supposed to be + // playing with... + for (Module::global_iterator I = M->global_begin(), E = M->global_end(); + I != E; ++I) + if (I->hasInitializer()) { + I->setInitializer(0); + I->setLinkage(GlobalValue::ExternalLinkage); + } + + // Try running the hacked up program... + if (TestFn(BD, M)) { + BD.setNewProgram(M); // It crashed, keep the trimmed version... + + // Make sure to use global variable pointers that point into the now-current + // module. + GVs.assign(GVSet.begin(), GVSet.end()); + return true; + } + + delete M; + return false; +} + namespace llvm { + /// ReduceCrashingFunctions reducer - This works by removing functions and + /// seeing if the program still crashes. If it does, then keep the newer, + /// smaller program. + /// class ReduceCrashingFunctions : public ListReducer { BugDriver &BD; bool (*TestFn)(BugDriver &, Module *); @@ -92,7 +176,7 @@ namespace llvm { ReduceCrashingFunctions(BugDriver &bd, bool (*testFn)(BugDriver &, Module *)) : BD(bd), TestFn(testFn) {} - + virtual TestResult doTest(std::vector &Prefix, std::vector &Kept) { if (!Kept.empty() && TestFuncs(Kept)) @@ -101,21 +185,30 @@ namespace llvm { return KeepPrefix; return NoFailure; } - + bool TestFuncs(std::vector &Prefix); }; } bool ReduceCrashingFunctions::TestFuncs(std::vector &Funcs) { + + //if main isn't present, claim there is no problem + if (KeepMain && find(Funcs.begin(), Funcs.end(), + BD.getProgram()->getFunction("main")) == Funcs.end()) + return false; + // Clone the program to try hacking it apart... Module *M = CloneModule(BD.getProgram()); - + // Convert list to set for fast lookup... std::set Functions; for (unsigned i = 0, e = Funcs.size(); i != e; ++i) { - Function *CMF = M->getFunction(Funcs[i]->getName(), - Funcs[i]->getFunctionType()); + // 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()); assert(CMF && "Function not in module?!"); + assert(CMF->getFunctionType() == Funcs[i]->getFunctionType() && "wrong ty"); Functions.insert(CMF); } @@ -126,7 +219,7 @@ bool ReduceCrashingFunctions::TestFuncs(std::vector &Funcs) { // Loop over and delete any functions which we aren't supposed to be playing // with... for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) - if (!I->isExternal() && !Functions.count(I)) + if (!I->isDeclaration() && !Functions.count(I)) DeleteFunctionBody(I); // Try running the hacked up program... @@ -155,7 +248,7 @@ namespace { public: ReduceCrashingBlocks(BugDriver &bd, bool (*testFn)(BugDriver &, Module *)) : BD(bd), TestFn(testFn) {} - + virtual TestResult doTest(std::vector &Prefix, std::vector &Kept) { if (!Kept.empty() && TestBlocks(Kept)) @@ -164,7 +257,7 @@ namespace { return KeepPrefix; return NoFailure; } - + bool TestBlocks(std::vector &Prefix); }; } @@ -172,14 +265,15 @@ namespace { bool ReduceCrashingBlocks::TestBlocks(std::vector &BBs) { // Clone the program to try hacking it apart... Module *M = CloneModule(BD.getProgram()); - + // Convert list to set for fast lookup... std::set Blocks; 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(); @@ -206,17 +300,16 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector &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(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 @@ -244,10 +337,10 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector &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->getSymbolTable(); - SymbolTable::plane_iterator PI = ST.find(Type::LabelTy); - if (PI != ST.plane_end() && PI->second.count(BlockInfo[i].second)) - BBs.push_back(cast(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(V)); } return true; } @@ -259,54 +352,72 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector &BBs) { /// on a program, try to destructively reduce the program while still keeping /// the predicate true. static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *)) { - bool AnyReduction = false; - - // See if we can get away with nuking all of the global variable initializers + // See if we can get away with nuking some of the global variable initializers // in the program... - if (BD.getProgram()->gbegin() != BD.getProgram()->gend()) { + if (BD.getProgram()->global_begin() != BD.getProgram()->global_end()) { + // Now try to reduce the number of global variable initializers in the + // module to something small. Module *M = CloneModule(BD.getProgram()); bool DeletedInit = false; - for (Module::giterator I = M->gbegin(), E = M->gend(); I != E; ++I) + + for (Module::global_iterator I = M->global_begin(), E = M->global_end(); + I != E; ++I) if (I->hasInitializer()) { I->setInitializer(0); I->setLinkage(GlobalValue::ExternalLinkage); DeletedInit = true; } - + if (!DeletedInit) { delete M; // No change made... } else { // See if the program still causes a crash... std::cout << "\nChecking to see if we can delete global inits: "; - if (TestFn(BD, M)) { // Still crashes? + + if (TestFn(BD, M)) { // Still crashes? BD.setNewProgram(M); - AnyReduction = true; std::cout << "\n*** Able to remove all global initializers!\n"; - } else { // No longer crashes? + } else { // No longer crashes? std::cout << " - Removing all global inits hides problem!\n"; delete M; + + std::vector GVs; + + for (Module::global_iterator I = BD.getProgram()->global_begin(), + E = BD.getProgram()->global_end(); I != E; ++I) + if (I->hasInitializer()) + GVs.push_back(I); + + if (GVs.size() > 1 && !BugpointIsInterrupted) { + std::cout << "\n*** Attempting to reduce the number of global " + << "variables in the testcase\n"; + + unsigned OldSize = GVs.size(); + ReduceCrashingGlobalVariables(BD, TestFn).reduceList(GVs); + + if (GVs.size() < OldSize) + BD.EmitProgressBitcode("reduced-global-variables"); + } } } } - + // Now try to reduce the number of functions in the module to something small. std::vector Functions; for (Module::iterator I = BD.getProgram()->begin(), E = BD.getProgram()->end(); I != E; ++I) - if (!I->isExternal()) + if (!I->isDeclaration()) Functions.push_back(I); - if (Functions.size() > 1) { + if (Functions.size() > 1 && !BugpointIsInterrupted) { std::cout << "\n*** Attempting to reduce the number of functions " "in the testcase\n"; unsigned OldSize = Functions.size(); ReduceCrashingFunctions(BD, TestFn).reduceList(Functions); - if (Functions.size() < OldSize) { - BD.EmitProgressBytecode("reduced-function"); - AnyReduction = true; - } + if (Functions.size() < OldSize) + BD.EmitProgressBitcode("reduced-function"); } // Attempt to delete entire basic blocks at a time to speed up @@ -314,7 +425,7 @@ static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *)) { // to a return instruction then running simplifycfg, which can potentially // shrinks the code dramatically quickly // - if (!DisableSimplifyCFG) { + if (!DisableSimplifyCFG && !BugpointIsInterrupted) { std::vector Blocks; for (Module::const_iterator I = BD.getProgram()->begin(), E = BD.getProgram()->end(); I != E; ++I) @@ -327,6 +438,7 @@ static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *)) { // larger chunks of instructions at a time! unsigned Simplification = 2; do { + if (BugpointIsInterrupted) break; --Simplification; std::cout << "\n*** Attempting to reduce testcase by deleting instruc" << "tions: Simplification Level #" << Simplification << '\n'; @@ -341,13 +453,13 @@ static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *)) { // unsigned InstructionsToSkipBeforeDeleting = 0; TryAgain: - + // Loop over all of the (non-terminator) instructions remaining in the // function, attempting to delete them. unsigned CurInstructionNum = 0; for (Module::const_iterator FI = BD.getProgram()->begin(), E = BD.getProgram()->end(); FI != E; ++FI) - if (!FI->isExternal()) + if (!FI->isDeclaration()) for (Function::const_iterator BI = FI->begin(), E = FI->end(); BI != E; ++BI) for (BasicBlock::const_iterator I = BI->begin(), E = --BI->end(); @@ -355,19 +467,20 @@ static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *)) { if (InstructionsToSkipBeforeDeleting) { --InstructionsToSkipBeforeDeleting; } else { + if (BugpointIsInterrupted) goto ExitLoops; + std::cout << "Checking instruction '" << I->getName() << "': "; Module *M = BD.deleteInstructionFromProgram(I, Simplification); - + // Find out if the pass still crashes on this pass... if (TestFn(BD, M)) { // Yup, it does, we delete the old module, and continue trying // to reduce the testcase... BD.setNewProgram(M); - AnyReduction = true; InstructionsToSkipBeforeDeleting = CurInstructionNum; goto TryAgain; // I wish I had a multi-level break here! } - + // This pass didn't crash without this instruction, try the next // one. delete M; @@ -377,26 +490,27 @@ static bool DebugACrash(BugDriver &BD, bool (*TestFn)(BugDriver &, Module *)) { InstructionsToSkipBeforeDeleting = 0; goto TryAgain; } - + } while (Simplification); +ExitLoops: // Try to clean up the testcase by running funcresolve and globaldce... - std::cout << "\n*** Attempting to perform final cleanups: "; - Module *M = CloneModule(BD.getProgram()); - M = BD.performFinalCleanups(M, true); - - // Find out if the pass still crashes on the cleaned up program... - if (TestFn(BD, M)) { - BD.setNewProgram(M); // Yup, it does, keep the reduced version... - AnyReduction = true; - } else { - delete M; + if (!BugpointIsInterrupted) { + std::cout << "\n*** Attempting to perform final cleanups: "; + Module *M = CloneModule(BD.getProgram()); + M = BD.performFinalCleanups(M, true); + + // Find out if the pass still crashes on the cleaned up program... + if (TestFn(BD, M)) { + BD.setNewProgram(M); // Yup, it does, keep the reduced version... + } else { + delete M; + } } - if (AnyReduction) - BD.EmitProgressBytecode("reduced-simplified"); + BD.EmitProgressBitcode("reduced-simplified"); - return false; + return false; } static bool TestForOptimizerCrash(BugDriver &BD, Module *M) { @@ -407,18 +521,18 @@ static bool TestForOptimizerCrash(BugDriver &BD, Module *M) { /// It attempts to prune down the testcase to something reasonable, and figure /// out exactly which pass is crashing. /// -bool BugDriver::debugOptimizerCrash() { +bool BugDriver::debugOptimizerCrash(const std::string &ID) { std::cout << "\n*** Debugging optimizer crash!\n"; // Reduce the list of passes which causes the optimizer to crash... - unsigned OldSize = PassesToRun.size(); - ReducePassList(*this).reduceList(PassesToRun); + if (!BugpointIsInterrupted) + ReducePassList(*this).reduceList(PassesToRun); std::cout << "\n*** Found crashing pass" << (PassesToRun.size() == 1 ? ": " : "es: ") << getPassesString(PassesToRun) << '\n'; - EmitProgressBytecode("passinput"); + EmitProgressBitcode(ID); return DebugACrash(*this, TestForOptimizerCrash); } @@ -429,7 +543,7 @@ static bool TestForCodeGenCrash(BugDriver &BD, Module *M) { BD.compileProgram(M); std::cerr << '\n'; return false; - } catch (ToolExecutionError &TEE) { + } catch (ToolExecutionError &) { std::cerr << "\n"; return true; // Tool is still crashing. }