2002-12-23 23:50:16 +00:00
|
|
|
//===- Miscompilation.cpp - Debug program miscompilations -----------------===//
|
|
|
|
//
|
|
|
|
// This file implements program miscompilation debugging support.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "BugDriver.h"
|
2003-04-24 20:16:29 +00:00
|
|
|
#include "ListReducer.h"
|
2002-12-23 23:50:16 +00:00
|
|
|
#include "llvm/Module.h"
|
2003-08-07 21:19:30 +00:00
|
|
|
#include "llvm/Pass.h"
|
2003-04-24 17:02:17 +00:00
|
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
|
|
|
#include "llvm/Transforms/Utils/Linker.h"
|
2003-08-07 21:19:30 +00:00
|
|
|
#include "Support/SystemUtils.h"
|
2002-12-23 23:50:16 +00:00
|
|
|
|
2003-04-24 17:02:17 +00:00
|
|
|
class ReduceMiscompilingPasses : public ListReducer<const PassInfo*> {
|
|
|
|
BugDriver &BD;
|
|
|
|
public:
|
|
|
|
ReduceMiscompilingPasses(BugDriver &bd) : BD(bd) {}
|
|
|
|
|
2003-04-24 22:24:22 +00:00
|
|
|
virtual TestResult doTest(std::vector<const PassInfo*> &Prefix,
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
std::vector<const PassInfo*> &Suffix);
|
2003-04-24 17:02:17 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
ReduceMiscompilingPasses::TestResult
|
2003-04-24 22:24:22 +00:00
|
|
|
ReduceMiscompilingPasses::doTest(std::vector<const PassInfo*> &Prefix,
|
2003-04-25 03:16:05 +00:00
|
|
|
std::vector<const PassInfo*> &Suffix) {
|
|
|
|
// First, run the program with just the Suffix passes. If it is still broken
|
2003-04-24 17:02:17 +00:00
|
|
|
// with JUST the kept passes, discard the prefix passes.
|
2003-04-25 03:16:05 +00:00
|
|
|
std::cout << "Checking to see if '" << getPassesString(Suffix)
|
2003-04-24 17:02:17 +00:00
|
|
|
<< "' compile correctly: ";
|
|
|
|
|
|
|
|
std::string BytecodeResult;
|
2003-04-25 03:16:05 +00:00
|
|
|
if (BD.runPasses(Suffix, BytecodeResult, false/*delete*/, true/*quiet*/)) {
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cerr << BD.getToolName() << ": Error running this sequence of passes"
|
|
|
|
<< " on the input program!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Check to see if the finished program matches the reference output...
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
if (BD.diffProgram(BytecodeResult, "", true /*delete bytecode*/)) {
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cout << "nope.\n";
|
|
|
|
return KeepSuffix; // Miscompilation detected!
|
|
|
|
}
|
|
|
|
std::cout << "yup.\n"; // No miscompilation!
|
|
|
|
|
|
|
|
if (Prefix.empty()) return NoFailure;
|
|
|
|
|
2003-04-25 03:16:05 +00:00
|
|
|
// Next, see if the program is broken if we run the "prefix" passes first,
|
2003-07-14 17:20:40 +00:00
|
|
|
// then separately run the "kept" passes.
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cout << "Checking to see if '" << getPassesString(Prefix)
|
|
|
|
<< "' compile correctly: ";
|
|
|
|
|
|
|
|
// If it is not broken with the kept passes, it's possible that the prefix
|
|
|
|
// passes must be run before the kept passes to break it. If the program
|
|
|
|
// WORKS after the prefix passes, but then fails if running the prefix AND
|
|
|
|
// kept passes, we can update our bytecode file to include the result of the
|
|
|
|
// prefix passes, then discard the prefix passes.
|
|
|
|
//
|
|
|
|
if (BD.runPasses(Prefix, BytecodeResult, false/*delete*/, true/*quiet*/)) {
|
|
|
|
std::cerr << BD.getToolName() << ": Error running this sequence of passes"
|
|
|
|
<< " on the input program!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the prefix maintains the predicate by itself, only keep the prefix!
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
if (BD.diffProgram(BytecodeResult)) {
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cout << "nope.\n";
|
|
|
|
removeFile(BytecodeResult);
|
|
|
|
return KeepPrefix;
|
|
|
|
}
|
|
|
|
std::cout << "yup.\n"; // No miscompilation!
|
|
|
|
|
|
|
|
// Ok, so now we know that the prefix passes work, try running the suffix
|
|
|
|
// passes on the result of the prefix passes.
|
|
|
|
//
|
|
|
|
Module *PrefixOutput = BD.ParseInputFile(BytecodeResult);
|
|
|
|
if (PrefixOutput == 0) {
|
|
|
|
std::cerr << BD.getToolName() << ": Error reading bytecode file '"
|
|
|
|
<< BytecodeResult << "'!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
removeFile(BytecodeResult); // No longer need the file on disk
|
|
|
|
|
2003-04-25 03:16:05 +00:00
|
|
|
std::cout << "Checking to see if '" << getPassesString(Suffix)
|
2003-04-24 17:02:17 +00:00
|
|
|
<< "' passes compile correctly after the '"
|
|
|
|
<< getPassesString(Prefix) << "' passes: ";
|
|
|
|
|
|
|
|
Module *OriginalInput = BD.Program;
|
|
|
|
BD.Program = PrefixOutput;
|
2003-04-25 03:16:05 +00:00
|
|
|
if (BD.runPasses(Suffix, BytecodeResult, false/*delete*/, true/*quiet*/)) {
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cerr << BD.getToolName() << ": Error running this sequence of passes"
|
|
|
|
<< " on the input program!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Run the result...
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
if (BD.diffProgram(BytecodeResult, "", true/*delete bytecode*/)) {
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cout << "nope.\n";
|
|
|
|
delete OriginalInput; // We pruned down the original input...
|
2003-04-25 03:16:05 +00:00
|
|
|
return KeepSuffix;
|
2003-04-24 17:02:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we must not be running the bad pass anymore.
|
|
|
|
std::cout << "yup.\n"; // No miscompilation!
|
|
|
|
BD.Program = OriginalInput; // Restore original program
|
|
|
|
delete PrefixOutput; // Free experiment
|
|
|
|
return NoFailure;
|
|
|
|
}
|
|
|
|
|
|
|
|
class ReduceMiscompilingFunctions : public ListReducer<Function*> {
|
|
|
|
BugDriver &BD;
|
|
|
|
public:
|
|
|
|
ReduceMiscompilingFunctions(BugDriver &bd) : BD(bd) {}
|
|
|
|
|
2003-04-24 22:24:22 +00:00
|
|
|
virtual TestResult doTest(std::vector<Function*> &Prefix,
|
2003-04-25 03:16:05 +00:00
|
|
|
std::vector<Function*> &Suffix) {
|
2003-08-04 19:03:42 +00:00
|
|
|
if (!Suffix.empty() && TestFuncs(Suffix, false))
|
2003-04-24 17:02:17 +00:00
|
|
|
return KeepSuffix;
|
2003-04-24 19:32:42 +00:00
|
|
|
if (!Prefix.empty() && TestFuncs(Prefix, false))
|
2003-04-24 17:02:17 +00:00
|
|
|
return KeepPrefix;
|
|
|
|
return NoFailure;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool TestFuncs(const std::vector<Function*> &Prefix, bool EmitBytecode);
|
|
|
|
};
|
|
|
|
|
|
|
|
bool ReduceMiscompilingFunctions::TestFuncs(const std::vector<Function*> &Funcs,
|
|
|
|
bool EmitBytecode) {
|
|
|
|
// Test to see if the function is misoptimized if we ONLY run it on the
|
|
|
|
// functions listed in Funcs.
|
|
|
|
if (!EmitBytecode) {
|
|
|
|
std::cout << "Checking to see if the program is misoptimized when these "
|
|
|
|
<< "functions are run\nthrough the passes: ";
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
BD.PrintFunctionList(Funcs);
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cout << "\n";
|
|
|
|
} else {
|
|
|
|
std::cout <<"Outputting reduced bytecode files which expose the problem:\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
// First step: clone the module for the two halves of the program we want.
|
|
|
|
Module *ToOptimize = CloneModule(BD.Program);
|
|
|
|
|
|
|
|
// Second step: Make sure functions & globals are all external so that linkage
|
|
|
|
// between the two modules will work.
|
|
|
|
for (Module::iterator I = ToOptimize->begin(), E = ToOptimize->end();I!=E;++I)
|
|
|
|
I->setLinkage(GlobalValue::ExternalLinkage);
|
|
|
|
for (Module::giterator I = ToOptimize->gbegin(), E = ToOptimize->gend();
|
|
|
|
I != E; ++I)
|
|
|
|
I->setLinkage(GlobalValue::ExternalLinkage);
|
|
|
|
|
|
|
|
// Third step: make a clone of the externalized program for the non-optimized
|
|
|
|
// part.
|
|
|
|
Module *ToNotOptimize = CloneModule(ToOptimize);
|
|
|
|
|
|
|
|
// Fourth step: Remove the test functions from the ToNotOptimize module, and
|
|
|
|
// all of the global variables.
|
|
|
|
for (unsigned i = 0, e = Funcs.size(); i != e; ++i) {
|
|
|
|
Function *TNOF = ToNotOptimize->getFunction(Funcs[i]->getName(),
|
|
|
|
Funcs[i]->getFunctionType());
|
|
|
|
assert(TNOF && "Function doesn't exist in module!");
|
|
|
|
DeleteFunctionBody(TNOF); // Function is now external in this module!
|
|
|
|
}
|
|
|
|
for (Module::giterator I = ToNotOptimize->gbegin(), E = ToNotOptimize->gend();
|
|
|
|
I != E; ++I)
|
|
|
|
I->setInitializer(0); // Delete the initializer to make it external
|
|
|
|
|
|
|
|
if (EmitBytecode) {
|
|
|
|
std::cout << " Non-optimized portion: ";
|
|
|
|
std::swap(BD.Program, ToNotOptimize);
|
|
|
|
BD.EmitProgressBytecode("tonotoptimize", true);
|
|
|
|
std::swap(BD.Program, ToNotOptimize);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Fifth step: Remove all functions from the ToOptimize module EXCEPT for the
|
|
|
|
// ones specified in Funcs. We know which ones these are because they are
|
|
|
|
// non-external in ToOptimize, but external in ToNotOptimize.
|
|
|
|
//
|
|
|
|
for (Module::iterator I = ToOptimize->begin(), E = ToOptimize->end();I!=E;++I)
|
|
|
|
if (!I->isExternal()) {
|
|
|
|
Function *TNOF = ToNotOptimize->getFunction(I->getName(),
|
|
|
|
I->getFunctionType());
|
|
|
|
assert(TNOF && "Function doesn't exist in ToNotOptimize module??");
|
|
|
|
if (!TNOF->isExternal())
|
|
|
|
DeleteFunctionBody(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (EmitBytecode) {
|
|
|
|
std::cout << " Portion that is input to optimizer: ";
|
|
|
|
std::swap(BD.Program, ToOptimize);
|
|
|
|
BD.EmitProgressBytecode("tooptimize");
|
|
|
|
std::swap(BD.Program, ToOptimize);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Sixth step: Run the optimization passes on ToOptimize, producing a
|
|
|
|
// transformed version of the functions being tested.
|
|
|
|
Module *OldProgram = BD.Program;
|
|
|
|
BD.Program = ToOptimize;
|
|
|
|
|
|
|
|
if (!EmitBytecode)
|
|
|
|
std::cout << " Optimizing functions being tested: ";
|
|
|
|
std::string BytecodeResult;
|
|
|
|
if (BD.runPasses(BD.PassesToRun, BytecodeResult, false/*delete*/,
|
|
|
|
true/*quiet*/)) {
|
|
|
|
std::cerr << BD.getToolName() << ": Error running this sequence of passes"
|
|
|
|
<< " on the input program!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!EmitBytecode)
|
|
|
|
std::cout << "done.\n";
|
|
|
|
|
|
|
|
delete BD.Program; // Delete the old "ToOptimize" module
|
|
|
|
BD.Program = BD.ParseInputFile(BytecodeResult);
|
|
|
|
|
|
|
|
if (EmitBytecode) {
|
|
|
|
std::cout << " 'tooptimize' after being optimized: ";
|
|
|
|
BD.EmitProgressBytecode("optimized", true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (BD.Program == 0) {
|
|
|
|
std::cerr << BD.getToolName() << ": Error reading bytecode file '"
|
|
|
|
<< BytecodeResult << "'!\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
removeFile(BytecodeResult); // No longer need the file on disk
|
|
|
|
|
|
|
|
// Seventh step: Link the optimized part of the program back to the
|
|
|
|
// unoptimized part of the program.
|
|
|
|
//
|
|
|
|
if (LinkModules(BD.Program, ToNotOptimize, &BytecodeResult)) {
|
|
|
|
std::cerr << BD.getToolName() << ": Error linking modules together:"
|
|
|
|
<< BytecodeResult << "\n";
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
delete ToNotOptimize; // We are done with this module...
|
|
|
|
|
|
|
|
if (EmitBytecode) {
|
|
|
|
std::cout << " Program as tested: ";
|
|
|
|
BD.EmitProgressBytecode("linked", true);
|
|
|
|
delete BD.Program;
|
|
|
|
BD.Program = OldProgram;
|
|
|
|
return false; // We don't need to actually execute the program here.
|
|
|
|
}
|
|
|
|
|
|
|
|
std::cout << " Checking to see if the merged program executes correctly: ";
|
|
|
|
|
|
|
|
// Eighth step: Execute the program. If it does not match the expected
|
|
|
|
// output, then 'Funcs' are being misoptimized!
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
bool Broken = BD.diffProgram();
|
2003-04-24 17:02:17 +00:00
|
|
|
|
|
|
|
delete BD.Program; // Delete the hacked up program
|
|
|
|
BD.Program = OldProgram; // Restore the original
|
|
|
|
|
|
|
|
std::cout << (Broken ? "nope.\n" : "yup.\n");
|
|
|
|
return Broken;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2002-12-23 23:50:16 +00:00
|
|
|
/// debugMiscompilation - This method is used when the passes selected are not
|
|
|
|
/// crashing, but the generated output is semantically different from the
|
|
|
|
/// input.
|
|
|
|
///
|
|
|
|
bool BugDriver::debugMiscompilation() {
|
|
|
|
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
if (diffProgram()) {
|
2002-12-23 23:50:16 +00:00
|
|
|
std::cout << "\n*** Input program does not match reference diff!\n"
|
Major addition to bugpoint: ability to debug code generators (LLC and LLI).
The C backend is assumed correct and is used to generate shared objects to be
loaded by the other two code generators.
LLC debugging should be functional now, LLI needs a few more additions to work,
the major one is renaming of external functions to call the JIT lazy function
resolver.
Bugpoint now has a command-line switch -mode with options 'compile' and
'codegen' to debug appropriate portions of tools.
ExecutionDriver.cpp: Added implementations of AbstractInterpreter for LLC and
GCC, broke out common code within other tools, and added ability to generate C
code with CBE individually, without executing the program, and the GCC tool can
generate executables shared objects or executables.
If no reference output is specified to Bugpoint, it will be generated with CBE,
because it is already assumed to be correct for the purposes of debugging using
this method. As a result, many functions now accept as an optional parameter a
shared object to be loaded in, if specified.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7293 91177308-0d34-0410-b5e6-96231b3b80d8
2003-07-24 18:17:43 +00:00
|
|
|
<< " Must be problem with input source!\n";
|
2002-12-23 23:50:16 +00:00
|
|
|
return false; // Problem found
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make sure something was miscompiled...
|
2003-07-30 20:15:56 +00:00
|
|
|
if (!ReduceMiscompilingPasses(*this).reduceList(PassesToRun)) {
|
2002-12-23 23:50:16 +00:00
|
|
|
std::cerr << "*** Optimized program matches reference output! No problem "
|
|
|
|
<< "detected...\nbugpoint can't help you with your problem!\n";
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2003-04-24 17:02:17 +00:00
|
|
|
std::cout << "\n*** Found miscompiling pass"
|
|
|
|
<< (PassesToRun.size() == 1 ? "" : "es") << ": "
|
|
|
|
<< getPassesString(PassesToRun) << "\n";
|
|
|
|
EmitProgressBytecode("passinput");
|
2002-12-23 23:50:16 +00:00
|
|
|
|
2003-04-24 17:02:17 +00:00
|
|
|
// Okay, now that we have reduced the list of passes which are causing the
|
|
|
|
// failure, see if we can pin down which functions are being
|
|
|
|
// miscompiled... first build a list of all of the non-external functions in
|
|
|
|
// the program.
|
|
|
|
std::vector<Function*> MiscompiledFunctions;
|
|
|
|
for (Module::iterator I = Program->begin(), E = Program->end(); I != E; ++I)
|
|
|
|
if (!I->isExternal())
|
|
|
|
MiscompiledFunctions.push_back(I);
|
2002-12-23 23:50:16 +00:00
|
|
|
|
2003-04-24 17:02:17 +00:00
|
|
|
// Do the reduction...
|
|
|
|
ReduceMiscompilingFunctions(*this).reduceList(MiscompiledFunctions);
|
|
|
|
|
|
|
|
std::cout << "\n*** The following functions are being miscompiled: ";
|
|
|
|
PrintFunctionList(MiscompiledFunctions);
|
|
|
|
std::cout << "\n";
|
2002-12-23 23:50:16 +00:00
|
|
|
|
2003-04-24 17:02:17 +00:00
|
|
|
// Output a bunch of bytecode files for the user...
|
|
|
|
ReduceMiscompilingFunctions(*this).TestFuncs(MiscompiledFunctions, true);
|
2002-12-23 23:50:16 +00:00
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|