2002-11-20 22:28:10 +00:00
|
|
|
//===- BugDriver.h - Top-Level BugPoint class -------------------*- C++ -*-===//
|
2003-10-20 17:47:21 +00:00
|
|
|
//
|
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2002-11-20 22:28:10 +00:00
|
|
|
//
|
|
|
|
// This class contains all of the shared state and information that is used by
|
|
|
|
// the BugPoint tool to track down errors in optimizations. This class is the
|
|
|
|
// main driver class that invokes all sub-functionality.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef BUGDRIVER_H
|
|
|
|
#define BUGDRIVER_H
|
|
|
|
|
|
|
|
#include <vector>
|
|
|
|
#include <string>
|
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
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
|
|
|
|
2002-11-20 22:28:10 +00:00
|
|
|
class PassInfo;
|
|
|
|
class Module;
|
|
|
|
class Function;
|
2002-12-23 23:49:59 +00:00
|
|
|
class AbstractInterpreter;
|
2003-01-23 02:48:33 +00:00
|
|
|
class Instruction;
|
2002-11-20 22:28:10 +00:00
|
|
|
|
2003-04-24 22:24:58 +00:00
|
|
|
class DebugCrashes;
|
2003-04-24 17:02:17 +00:00
|
|
|
class ReduceMiscompilingPasses;
|
|
|
|
class ReduceMiscompilingFunctions;
|
|
|
|
|
2003-07-24 21:59:10 +00:00
|
|
|
class CBE;
|
|
|
|
class GCC;
|
|
|
|
|
2003-08-05 15:51:05 +00:00
|
|
|
extern bool DisableSimplifyCFG;
|
|
|
|
|
2002-11-20 22:28:10 +00:00
|
|
|
class BugDriver {
|
|
|
|
const std::string ToolName; // Name of bugpoint
|
2003-07-24 21:59:10 +00:00
|
|
|
std::string ReferenceOutputFile; // Name of `good' output file
|
2002-11-20 22:28:10 +00:00
|
|
|
Module *Program; // The raw program, linked together
|
|
|
|
std::vector<const PassInfo*> PassesToRun;
|
2002-12-23 23:49:59 +00:00
|
|
|
AbstractInterpreter *Interpreter; // How to run the program
|
2003-07-24 21:59:10 +00:00
|
|
|
CBE *cbe;
|
|
|
|
GCC *gcc;
|
2003-04-24 17:02:17 +00:00
|
|
|
|
2003-04-24 22:24:58 +00:00
|
|
|
// FIXME: sort out public/private distinctions...
|
2004-02-18 21:24:48 +00:00
|
|
|
friend class ReducePassList;
|
2003-04-24 17:02:17 +00:00
|
|
|
friend class ReduceMiscompilingPasses;
|
|
|
|
friend class ReduceMiscompilingFunctions;
|
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
|
|
|
friend class ReduceMisCodegenFunctions;
|
|
|
|
|
2002-11-20 22:28:10 +00:00
|
|
|
public:
|
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
|
|
|
BugDriver(const char *toolname);
|
2002-12-23 23:49:59 +00:00
|
|
|
|
|
|
|
const std::string &getToolName() const { return ToolName; }
|
2002-11-20 22:28:10 +00:00
|
|
|
|
|
|
|
// Set up methods... these methods are used to copy information about the
|
|
|
|
// command line arguments into instance variables of BugDriver.
|
|
|
|
//
|
|
|
|
bool addSources(const std::vector<std::string> &FileNames);
|
|
|
|
template<class It>
|
|
|
|
void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
|
2003-10-17 23:03:16 +00:00
|
|
|
void setPassesToRun(const std::vector<const PassInfo*> &PTR) {
|
|
|
|
PassesToRun = PTR;
|
|
|
|
}
|
2002-11-20 22:28:10 +00:00
|
|
|
|
|
|
|
/// run - The top level method that is invoked after all of the instance
|
|
|
|
/// variables are set up from command line arguments.
|
|
|
|
///
|
|
|
|
bool run();
|
|
|
|
|
2004-02-18 21:02:04 +00:00
|
|
|
/// debugOptimizerCrash - This method is called when some optimizer pass
|
|
|
|
/// crashes on input. It attempts to prune down the testcase to something
|
|
|
|
/// reasonable, and figure out exactly which pass is crashing.
|
2002-11-20 22:28:10 +00:00
|
|
|
///
|
2004-02-18 21:02:04 +00:00
|
|
|
bool debugOptimizerCrash();
|
|
|
|
|
|
|
|
/// debugCodeGeneratorCrash - This method is called when the code generator
|
|
|
|
/// crashes on an input. It attempts to reduce the input as much as possible
|
|
|
|
/// while still causing the code generator to crash.
|
|
|
|
bool debugCodeGeneratorCrash();
|
2002-11-20 22:28:10 +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 debugMiscompilation();
|
|
|
|
|
2002-12-23 23:49:59 +00:00
|
|
|
/// debugPassMiscompilation - This method is called when the specified pass
|
|
|
|
/// miscompiles Program as input. It tries to reduce the testcase to
|
|
|
|
/// something that smaller that still miscompiles the program.
|
|
|
|
/// ReferenceOutput contains the filename of the file containing the output we
|
|
|
|
/// are to match.
|
|
|
|
///
|
|
|
|
bool debugPassMiscompilation(const PassInfo *ThePass,
|
|
|
|
const std::string &ReferenceOutput);
|
|
|
|
|
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
|
|
|
/// compileSharedObject - This method creates a SharedObject from a given
|
|
|
|
/// BytecodeFile for debugging a code generator.
|
2003-10-14 21:09:11 +00:00
|
|
|
///
|
|
|
|
std::string compileSharedObject(const std::string &BytecodeFile);
|
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
|
|
|
|
|
|
|
/// debugCodeGenerator - This method narrows down a module to a function or
|
|
|
|
/// set of functions, using the CBE as a ``safe'' code generator for other
|
|
|
|
/// functions that are not under consideration.
|
|
|
|
bool debugCodeGenerator();
|
|
|
|
|
2003-07-28 20:59:16 +00:00
|
|
|
/// isExecutingJIT - Returns true if bugpoint is currently testing the JIT
|
|
|
|
///
|
2003-07-28 19:16:14 +00:00
|
|
|
bool isExecutingJIT();
|
|
|
|
|
2004-02-18 21:24:48 +00:00
|
|
|
/// 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);
|
|
|
|
|
2004-02-18 23:25:22 +00:00
|
|
|
/// compileProgram - Try to compile the specified module, throwing an
|
|
|
|
/// exception if an error occurs, or returning normally if not. This is used
|
|
|
|
/// for code generation crash testing.
|
|
|
|
///
|
|
|
|
void compileProgram(Module *M);
|
|
|
|
|
2004-02-18 21:35:28 +00:00
|
|
|
/// executeProgram - This method runs "Program", capturing the output of the
|
|
|
|
/// program to a file, returning the filename of the file. A recommended
|
|
|
|
/// filename may be optionally specified. If there is a problem with the code
|
|
|
|
/// generator (e.g., llc crashes), this will throw an exception.
|
|
|
|
///
|
|
|
|
std::string executeProgram(std::string RequestedOutputFilename = "",
|
|
|
|
std::string Bytecode = "",
|
|
|
|
const std::string &SharedObjects = "",
|
|
|
|
AbstractInterpreter *AI = 0,
|
|
|
|
bool *ProgramExitedNonzero = 0);
|
|
|
|
|
|
|
|
/// executeProgramWithCBE - Used to create reference output with the C
|
|
|
|
/// backend, if reference output is not provided. If there is a problem with
|
|
|
|
/// the code generator (e.g., llc crashes), this will throw an exception.
|
|
|
|
///
|
|
|
|
std::string executeProgramWithCBE(std::string OutputFile = "");
|
|
|
|
|
|
|
|
/// diffProgram - This method executes the specified module and diffs the
|
|
|
|
/// output against the file specified by ReferenceOutputFile. If the output
|
|
|
|
/// is different, true is returned. If there is a problem with the code
|
|
|
|
/// generator (e.g., llc crashes), this will throw an exception.
|
|
|
|
///
|
|
|
|
bool diffProgram(const std::string &BytecodeFile = "",
|
|
|
|
const std::string &SharedObj = "",
|
|
|
|
bool RemoveBytecode = false);
|
2004-02-18 21:50:26 +00:00
|
|
|
/// EmitProgressBytecode - This function is used to output the current Program
|
|
|
|
/// to a file named "bugpoint-ID.bc".
|
|
|
|
///
|
|
|
|
void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false);
|
|
|
|
|
|
|
|
/// deleteInstructionFromProgram - This method clones the current Program and
|
|
|
|
/// deletes the specified instruction from the cloned module. It then runs a
|
|
|
|
/// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code
|
|
|
|
/// which depends on the value. The modified module is then returned.
|
|
|
|
///
|
|
|
|
Module *deleteInstructionFromProgram(const Instruction *I, unsigned Simp)
|
|
|
|
const;
|
|
|
|
|
|
|
|
/// performFinalCleanups - This method clones the current Program and performs
|
|
|
|
/// a series of cleanups intended to get rid of extra cruft on the module. If
|
|
|
|
/// the MayModifySemantics argument is true, then the cleanups is allowed to
|
|
|
|
/// modify how the code behaves.
|
|
|
|
///
|
|
|
|
Module *performFinalCleanups(Module *M, bool MayModifySemantics = false);
|
|
|
|
|
2002-11-20 22:28:10 +00:00
|
|
|
private:
|
|
|
|
/// ParseInputFile - Given a bytecode or assembly input filename, parse and
|
|
|
|
/// return it, or return null if not possible.
|
|
|
|
///
|
|
|
|
Module *ParseInputFile(const std::string &InputFilename) const;
|
|
|
|
|
|
|
|
/// writeProgramToFile - This writes the current "Program" to the named
|
|
|
|
/// bytecode file. If an error occurs, true is returned.
|
|
|
|
///
|
2002-12-23 23:49:59 +00:00
|
|
|
bool writeProgramToFile(const std::string &Filename, Module *M = 0) const;
|
2002-11-20 22:28:10 +00:00
|
|
|
|
|
|
|
/// runPasses - Run the specified passes on Program, outputting a bytecode
|
|
|
|
/// file and writting the filename into OutputFile if successful. If the
|
|
|
|
/// optimizations fail for some reason (optimizer crashes), return true,
|
|
|
|
/// otherwise return false. If DeleteOutput is set to true, the bytecode is
|
|
|
|
/// deleted on success, and the filename string is undefined. This prints to
|
|
|
|
/// cout a single line message indicating whether compilation was successful
|
2002-12-23 23:49:59 +00:00
|
|
|
/// or failed, unless Quiet is set.
|
2002-11-20 22:28:10 +00:00
|
|
|
///
|
|
|
|
bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
|
2002-12-23 23:49:59 +00:00
|
|
|
std::string &OutputFilename, bool DeleteOutput = false,
|
|
|
|
bool Quiet = false) const;
|
2002-11-20 22:28:10 +00:00
|
|
|
|
|
|
|
/// runPasses - Just like the method above, but this just returns true or
|
|
|
|
/// false indicating whether or not the optimizer crashed on the specified
|
|
|
|
/// input (true = crashed).
|
|
|
|
///
|
|
|
|
bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
|
|
|
|
bool DeleteOutput = true) const {
|
|
|
|
std::string Filename;
|
|
|
|
return runPasses(PassesToRun, Filename, DeleteOutput);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
/// PrintFunctionList - prints out list of problematic functions
|
2003-07-24 21:59:10 +00:00
|
|
|
///
|
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
|
|
|
static void PrintFunctionList(const std::vector<Function*> &Funcs);
|
|
|
|
|
2002-12-23 23:49:59 +00:00
|
|
|
/// initializeExecutionEnvironment - This method is used to set up the
|
|
|
|
/// environment for executing LLVM programs.
|
|
|
|
///
|
|
|
|
bool initializeExecutionEnvironment();
|
2002-11-20 22:28:10 +00:00
|
|
|
};
|
|
|
|
|
2003-04-24 17:02:17 +00:00
|
|
|
/// getPassesString - Turn a list of passes into a string which indicates the
|
|
|
|
/// command line options that must be passed to add the passes.
|
|
|
|
///
|
|
|
|
std::string getPassesString(const std::vector<const PassInfo*> &Passes);
|
|
|
|
|
2003-04-24 22:24:58 +00:00
|
|
|
// DeleteFunctionBody - "Remove" the function by deleting all of it's basic
|
|
|
|
// blocks, making it external.
|
|
|
|
//
|
|
|
|
void DeleteFunctionBody(Function *F);
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
2002-11-20 22:28:10 +00:00
|
|
|
#endif
|