forked from OSchip/llvm-project
Cleanup and simplify manipulation of the program, eliminate the need for so
many 'friends' of bugdriver. llvm-svn: 11603
This commit is contained in:
parent
ead1dff00b
commit
327019b495
|
@ -38,6 +38,15 @@ namespace {
|
|||
"(for miscompilation detection)"));
|
||||
}
|
||||
|
||||
/// setNewProgram - If we reduce or update the program somehow, call this method
|
||||
/// to update bugdriver with it. This deletes the old module and sets the
|
||||
/// specified one as the current program.
|
||||
void BugDriver::setNewProgram(Module *M) {
|
||||
delete Program;
|
||||
Program = M;
|
||||
}
|
||||
|
||||
|
||||
/// getPassesString - Turn a list of passes into a string which indicates the
|
||||
/// command line options that must be passed to add the passes.
|
||||
///
|
||||
|
@ -174,7 +183,7 @@ bool BugDriver::run() {
|
|||
return debugMiscompilation();
|
||||
}
|
||||
} catch (ToolExecutionError &TEE) {
|
||||
std::cerr << TEE.getMessage() << "*** Debugging code generator crash!\n";
|
||||
std::cerr << TEE.getMessage();
|
||||
return debugCodeGeneratorCrash();
|
||||
}
|
||||
|
||||
|
|
|
@ -48,12 +48,10 @@ class BugDriver {
|
|||
GCC *gcc;
|
||||
|
||||
// FIXME: sort out public/private distinctions...
|
||||
friend class DebugCrashes;
|
||||
friend class ReducePassList;
|
||||
friend class ReduceMiscompilingPasses;
|
||||
friend class ReduceMiscompilingFunctions;
|
||||
friend class ReduceMisCodegenFunctions;
|
||||
friend class ReduceCrashingFunctions;
|
||||
friend class ReduceCrashingBlocks;
|
||||
|
||||
public:
|
||||
BugDriver(const char *toolname);
|
||||
|
@ -114,6 +112,23 @@ public:
|
|||
///
|
||||
bool isExecutingJIT();
|
||||
|
||||
/// runPasses - Run all of the passes in the "PassesToRun" list, discard the
|
||||
/// output, and return true if any of the passes crashed.
|
||||
bool runPasses(Module *M = 0) {
|
||||
if (M == 0) M = Program;
|
||||
std::swap(M, Program);
|
||||
bool Result = runPasses(PassesToRun);
|
||||
std::swap(M, Program);
|
||||
return Result;
|
||||
}
|
||||
|
||||
const Module *getProgram() const { return Program; }
|
||||
|
||||
/// setNewProgram - If we reduce or update the program somehow, call this
|
||||
/// method to update bugdriver with it. This deletes the old module and sets
|
||||
/// the specified one as the current program.
|
||||
void setNewProgram(Module *M);
|
||||
|
||||
private:
|
||||
/// ParseInputFile - Given a bytecode or assembly input filename, parse and
|
||||
/// return it, or return null if not possible.
|
||||
|
|
|
@ -31,10 +31,10 @@
|
|||
using namespace llvm;
|
||||
|
||||
namespace llvm {
|
||||
class DebugCrashes : public ListReducer<const PassInfo*> {
|
||||
class ReducePassList : public ListReducer<const PassInfo*> {
|
||||
BugDriver &BD;
|
||||
public:
|
||||
DebugCrashes(BugDriver &bd) : BD(bd) {}
|
||||
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"
|
||||
|
@ -45,9 +45,9 @@ namespace llvm {
|
|||
};
|
||||
}
|
||||
|
||||
DebugCrashes::TestResult
|
||||
DebugCrashes::doTest(std::vector<const PassInfo*> &Prefix,
|
||||
std::vector<const PassInfo*> &Suffix) {
|
||||
ReducePassList::TestResult
|
||||
ReducePassList::doTest(std::vector<const PassInfo*> &Prefix,
|
||||
std::vector<const PassInfo*> &Suffix) {
|
||||
std::string PrefixOutput;
|
||||
Module *OrigProgram = 0;
|
||||
if (!Prefix.empty()) {
|
||||
|
@ -104,7 +104,7 @@ namespace llvm {
|
|||
|
||||
bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) {
|
||||
// Clone the program to try hacking it apart...
|
||||
Module *M = CloneModule(BD.Program);
|
||||
Module *M = CloneModule(BD.getProgram());
|
||||
|
||||
// Convert list to set for fast lookup...
|
||||
std::set<Function*> Functions;
|
||||
|
@ -131,17 +131,15 @@ bool ReduceCrashingFunctions::TestFuncs(std::vector<Function*> &Funcs) {
|
|||
DeleteFunctionBody(I);
|
||||
|
||||
// Try running the hacked up program...
|
||||
std::swap(BD.Program, M);
|
||||
if (BD.runPasses(BD.PassesToRun)) {
|
||||
delete M; // It crashed, keep the trimmed version...
|
||||
if (BD.runPasses(M)) {
|
||||
BD.setNewProgram(M); // It crashed, keep the trimmed version...
|
||||
|
||||
// Make sure to use function pointers that point into the now-current
|
||||
// module.
|
||||
Funcs.assign(Functions.begin(), Functions.end());
|
||||
return true;
|
||||
}
|
||||
delete BD.Program; // It didn't crash, revert...
|
||||
BD.Program = M;
|
||||
delete M;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
@ -172,7 +170,7 @@ namespace llvm {
|
|||
|
||||
bool ReduceCrashingBlocks::TestBlocks(std::vector<BasicBlock*> &BBs) {
|
||||
// Clone the program to try hacking it apart...
|
||||
Module *M = CloneModule(BD.Program);
|
||||
Module *M = CloneModule(BD.getProgram());
|
||||
|
||||
// Convert list to set for fast lookup...
|
||||
std::set<BasicBlock*> Blocks;
|
||||
|
@ -237,9 +235,8 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<BasicBlock*> &BBs) {
|
|||
Passes.run(*M);
|
||||
|
||||
// Try running on the hacked up program...
|
||||
std::swap(BD.Program, M);
|
||||
if (BD.runPasses(BD.PassesToRun)) {
|
||||
delete M; // It crashed, keep the trimmed version...
|
||||
if (BD.runPasses(M)) {
|
||||
BD.setNewProgram(M); // It crashed, keep the trimmed version...
|
||||
|
||||
// Make sure to use basic block pointers that point into the now-current
|
||||
// module, and that they don't include any deleted blocks.
|
||||
|
@ -252,11 +249,15 @@ bool ReduceCrashingBlocks::TestBlocks(std::vector<BasicBlock*> &BBs) {
|
|||
}
|
||||
return true;
|
||||
}
|
||||
delete BD.Program; // It didn't crash, revert...
|
||||
BD.Program = M;
|
||||
delete M; // It didn't crash, try something else.
|
||||
return false;
|
||||
}
|
||||
|
||||
static bool TestForOptimizerCrash(BugDriver &BD) {
|
||||
return BD.runPasses();
|
||||
}
|
||||
|
||||
|
||||
/// debugOptimizerCrash - This method is called when some pass crashes on input.
|
||||
/// It attempts to prune down the testcase to something reasonable, and figure
|
||||
/// out exactly which pass is crashing.
|
||||
|
@ -267,7 +268,7 @@ bool BugDriver::debugOptimizerCrash() {
|
|||
|
||||
// Reduce the list of passes which causes the optimizer to crash...
|
||||
unsigned OldSize = PassesToRun.size();
|
||||
DebugCrashes(*this).reduceList(PassesToRun);
|
||||
ReducePassList(*this).reduceList(PassesToRun);
|
||||
|
||||
std::cout << "\n*** Found crashing pass"
|
||||
<< (PassesToRun.size() == 1 ? ": " : "es: ")
|
||||
|
@ -292,15 +293,13 @@ bool BugDriver::debugOptimizerCrash() {
|
|||
} else {
|
||||
// See if the program still causes a crash...
|
||||
std::cout << "\nChecking to see if we can delete global inits: ";
|
||||
std::swap(Program, M);
|
||||
if (runPasses(PassesToRun)) { // Still crashes?
|
||||
if (runPasses(M)) { // Still crashes?
|
||||
setNewProgram(M);
|
||||
AnyReduction = true;
|
||||
delete M;
|
||||
std::cout << "\n*** Able to remove all global initializers!\n";
|
||||
} else { // No longer crashes?
|
||||
delete Program; // Restore program.
|
||||
Program = M;
|
||||
std::cout << " - Removing all global inits hides problem!\n";
|
||||
delete M;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -365,23 +364,19 @@ bool BugDriver::debugOptimizerCrash() {
|
|||
I != E; ++I) {
|
||||
Module *M = deleteInstructionFromProgram(I, Simplification);
|
||||
|
||||
// Make the function the current program...
|
||||
std::swap(Program, M);
|
||||
|
||||
// Find out if the pass still crashes on this pass...
|
||||
std::cout << "Checking instruction '" << I->getName() << "': ";
|
||||
if (runPasses(PassesToRun)) {
|
||||
if (runPasses(M)) {
|
||||
// Yup, it does, we delete the old module, and continue trying to
|
||||
// reduce the testcase...
|
||||
delete M;
|
||||
setNewProgram(M);
|
||||
AnyReduction = true;
|
||||
goto TryAgain; // I wish I had a multi-level break here!
|
||||
}
|
||||
|
||||
// This pass didn't crash without this instruction, try the next
|
||||
// one.
|
||||
delete Program;
|
||||
Program = M;
|
||||
delete M;
|
||||
}
|
||||
}
|
||||
} while (Simplification);
|
||||
|
@ -390,16 +385,13 @@ bool BugDriver::debugOptimizerCrash() {
|
|||
std::cout << "\n*** Attempting to perform final cleanups: ";
|
||||
Module *M = CloneModule(Program);
|
||||
M = performFinalCleanups(M, true);
|
||||
std::swap(Program, M);
|
||||
|
||||
// Find out if the pass still crashes on the cleaned up program...
|
||||
if (runPasses(PassesToRun)) {
|
||||
// Yup, it does, keep the reduced version...
|
||||
delete M;
|
||||
if (runPasses(M)) {
|
||||
setNewProgram(M); // Yup, it does, keep the reduced version...
|
||||
AnyReduction = true;
|
||||
} else {
|
||||
delete Program; // Otherwise, restore the original module...
|
||||
Program = M;
|
||||
delete M;
|
||||
}
|
||||
|
||||
if (AnyReduction)
|
||||
|
@ -414,6 +406,7 @@ bool BugDriver::debugOptimizerCrash() {
|
|||
/// crashes on an input. It attempts to reduce the input as much as possible
|
||||
/// while still causing the code generator to crash.
|
||||
bool BugDriver::debugCodeGeneratorCrash() {
|
||||
std::cerr << "*** Debugging code generator crash!\n";
|
||||
|
||||
return false;
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue