2002-11-20 22:28:10 +00:00
|
|
|
//===- BugDriver.cpp - Top-Level BugPoint class implementation ------------===//
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:44:31 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
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.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "BugDriver.h"
|
2006-06-06 22:30:59 +00:00
|
|
|
#include "ToolRunner.h"
|
2004-11-14 23:00:08 +00:00
|
|
|
#include "llvm/Linker.h"
|
2002-11-20 22:28:10 +00:00
|
|
|
#include "llvm/Module.h"
|
2003-08-07 21:19:30 +00:00
|
|
|
#include "llvm/Pass.h"
|
2002-11-20 22:28:10 +00:00
|
|
|
#include "llvm/Assembly/Parser.h"
|
2007-05-06 05:47:06 +00:00
|
|
|
#include "llvm/Bitcode/ReaderWriter.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Support/FileUtilities.h"
|
2007-05-06 05:47:06 +00:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2009-07-02 22:46:18 +00:00
|
|
|
#include "llvm/Support/SourceMgr.h"
|
2009-01-02 07:01:27 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2004-07-04 12:20:55 +00:00
|
|
|
#include <iostream>
|
2002-11-20 22:28:10 +00:00
|
|
|
#include <memory>
|
2003-11-11 22:41:34 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
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
|
|
|
// Anonymous namespace to define command line options for debugging.
|
|
|
|
//
|
|
|
|
namespace {
|
|
|
|
// Output - The user can specify a file containing the expected output of the
|
|
|
|
// program. If this filename is set, it is used as the reference diff source,
|
|
|
|
// otherwise the raw input run through an interpreter is used as the reference
|
|
|
|
// source.
|
|
|
|
//
|
2005-04-22 00:00:37 +00:00
|
|
|
cl::opt<std::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
|
|
|
OutputFile("output", cl::desc("Specify a reference program output "
|
|
|
|
"(for miscompilation detection)"));
|
|
|
|
}
|
|
|
|
|
2004-02-18 21:24:48 +00:00
|
|
|
/// 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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.
|
|
|
|
///
|
2004-01-14 03:38:37 +00:00
|
|
|
std::string llvm::getPassesString(const std::vector<const PassInfo*> &Passes) {
|
2003-04-24 17:02:17 +00:00
|
|
|
std::string Result;
|
|
|
|
for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
|
|
|
|
if (i) Result += " ";
|
|
|
|
Result += "-";
|
|
|
|
Result += Passes[i]->getPassArgument();
|
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
2006-08-15 16:40:49 +00:00
|
|
|
BugDriver::BugDriver(const char *toolname, bool as_child, bool find_bugs,
|
2009-07-01 21:22:36 +00:00
|
|
|
unsigned timeout, unsigned memlimit,
|
2009-07-01 23:13:44 +00:00
|
|
|
LLVMContext& ctxt)
|
2009-07-01 16:58:40 +00:00
|
|
|
: Context(ctxt), ToolName(toolname), ReferenceOutputFile(OutputFile),
|
2008-12-08 04:02:47 +00:00
|
|
|
Program(0), Interpreter(0), SafeInterpreter(0), gcc(0),
|
2009-07-01 16:58:40 +00:00
|
|
|
run_as_child(as_child), run_find_bugs(find_bugs), Timeout(timeout),
|
|
|
|
MemoryLimit(memlimit) {}
|
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
|
|
|
|
|
|
|
|
2007-07-04 21:55:50 +00:00
|
|
|
/// ParseInputFile - Given a bitcode or assembly input filename, parse and
|
2002-11-20 22:28:10 +00:00
|
|
|
/// return it, or return null if not possible.
|
|
|
|
///
|
2009-07-01 21:22:36 +00:00
|
|
|
Module *llvm::ParseInputFile(const std::string &Filename,
|
2009-07-01 23:13:44 +00:00
|
|
|
LLVMContext& Ctxt) {
|
2007-05-06 23:45:49 +00:00
|
|
|
std::auto_ptr<MemoryBuffer> Buffer(MemoryBuffer::getFileOrSTDIN(Filename));
|
2007-05-06 09:32:02 +00:00
|
|
|
Module *Result = 0;
|
|
|
|
if (Buffer.get())
|
2009-07-01 16:58:40 +00:00
|
|
|
Result = ParseBitcodeFile(Buffer.get(), Ctxt);
|
2007-05-06 05:47:06 +00:00
|
|
|
|
2009-07-02 22:46:18 +00:00
|
|
|
SMDiagnostic Err;
|
2009-07-01 16:58:40 +00:00
|
|
|
if (!Result && !(Result = ParseAssemblyFile(Filename, Err, Ctxt))) {
|
2009-07-02 22:46:18 +00:00
|
|
|
Err.Print("bugpoint", errs());
|
2002-11-20 22:28:10 +00:00
|
|
|
Result = 0;
|
|
|
|
}
|
2007-05-06 23:45:49 +00:00
|
|
|
|
2002-11-20 22:28:10 +00:00
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This method takes the specified list of LLVM input files, attempts to load
|
2007-07-04 21:55:50 +00:00
|
|
|
// them, either as assembly or bitcode, then link them together. It returns
|
|
|
|
// true on failure (if, for example, an input bitcode file could not be
|
2003-05-23 05:34:32 +00:00
|
|
|
// parsed), and false on success.
|
2002-11-20 22:28:10 +00:00
|
|
|
//
|
|
|
|
bool BugDriver::addSources(const std::vector<std::string> &Filenames) {
|
|
|
|
assert(Program == 0 && "Cannot call addSources multiple times!");
|
|
|
|
assert(!Filenames.empty() && "Must specify at least on input filename!");
|
|
|
|
|
2006-05-14 19:15:56 +00:00
|
|
|
try {
|
|
|
|
// Load the first input file.
|
2009-07-01 16:58:40 +00:00
|
|
|
Program = ParseInputFile(Filenames[0], Context);
|
2006-05-14 19:15:56 +00:00
|
|
|
if (Program == 0) return true;
|
2007-05-06 23:45:49 +00:00
|
|
|
|
2005-12-22 20:02:55 +00:00
|
|
|
if (!run_as_child)
|
2006-05-14 19:15:56 +00:00
|
|
|
std::cout << "Read input file : '" << Filenames[0] << "'\n";
|
|
|
|
|
|
|
|
for (unsigned i = 1, e = Filenames.size(); i != e; ++i) {
|
2009-07-01 16:58:40 +00:00
|
|
|
std::auto_ptr<Module> M(ParseInputFile(Filenames[i], Context));
|
2006-05-14 19:15:56 +00:00
|
|
|
if (M.get() == 0) return true;
|
|
|
|
|
|
|
|
if (!run_as_child)
|
|
|
|
std::cout << "Linking in input file: '" << Filenames[i] << "'\n";
|
|
|
|
std::string ErrorMessage;
|
|
|
|
if (Linker::LinkModules(Program, M.get(), &ErrorMessage)) {
|
|
|
|
std::cerr << ToolName << ": error linking in '" << Filenames[i] << "': "
|
|
|
|
<< ErrorMessage << '\n';
|
|
|
|
return true;
|
|
|
|
}
|
2002-11-20 22:28:10 +00:00
|
|
|
}
|
2006-05-14 19:15:56 +00:00
|
|
|
} catch (const std::string &Error) {
|
|
|
|
std::cerr << ToolName << ": error reading input '" << Error << "'\n";
|
|
|
|
return true;
|
2002-11-20 22:28:10 +00:00
|
|
|
}
|
|
|
|
|
2005-12-22 20:02:55 +00:00
|
|
|
if (!run_as_child)
|
|
|
|
std::cout << "*** All input ok\n";
|
2002-11-20 22:28:10 +00:00
|
|
|
|
|
|
|
// All input files read successfully!
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// run - The top level method that is invoked after all of the instance
|
|
|
|
/// variables are set up from command line arguments.
|
|
|
|
///
|
|
|
|
bool BugDriver::run() {
|
2005-12-22 20:02:55 +00:00
|
|
|
// The first thing to do is determine if we're running as a child. If we are,
|
|
|
|
// then what to do is very narrow. This form of invocation is only called
|
|
|
|
// from the runPasses method to actually run those passes in a child process.
|
|
|
|
if (run_as_child) {
|
|
|
|
// Execute the passes
|
|
|
|
return runPassesAsChild(PassesToRun);
|
|
|
|
}
|
2006-08-15 16:40:49 +00:00
|
|
|
|
|
|
|
if (run_find_bugs) {
|
|
|
|
// Rearrange the passes and apply them to the program. Repeat this process
|
|
|
|
// until the user kills the program or we find a bug.
|
|
|
|
return runManyPasses(PassesToRun);
|
|
|
|
}
|
2005-12-22 20:02:55 +00:00
|
|
|
|
|
|
|
// If we're not running as a child, the first thing that we must do is
|
|
|
|
// determine what the problem is. Does the optimization series crash the
|
|
|
|
// compiler, or does it produce illegal code? We make the top-level
|
|
|
|
// decision by trying to run all of the passes on the the input program,
|
2007-07-04 21:55:50 +00:00
|
|
|
// which should generate a bitcode file. If it does generate a bitcode
|
2005-12-22 20:02:55 +00:00
|
|
|
// file, then we know the compiler didn't crash, so try to diagnose a
|
|
|
|
// miscompilation.
|
2003-10-13 21:04:26 +00:00
|
|
|
if (!PassesToRun.empty()) {
|
|
|
|
std::cout << "Running selected passes on program to test for crash: ";
|
|
|
|
if (runPasses(PassesToRun))
|
2004-02-18 21:02:04 +00:00
|
|
|
return debugOptimizerCrash();
|
2003-10-13 21:04:26 +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
|
|
|
|
2007-07-04 21:55:50 +00:00
|
|
|
// Set up the execution environment, selecting a method to run LLVM bitcode.
|
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 (initializeExecutionEnvironment()) return true;
|
|
|
|
|
2004-02-19 17:03:49 +00:00
|
|
|
// Test to see if we have a code generator crash.
|
|
|
|
std::cout << "Running the code generator to test for a crash: ";
|
|
|
|
try {
|
|
|
|
compileProgram(Program);
|
2004-07-23 01:30:49 +00:00
|
|
|
std::cout << '\n';
|
2004-02-19 17:03:49 +00:00
|
|
|
} catch (ToolExecutionError &TEE) {
|
|
|
|
std::cout << TEE.what();
|
|
|
|
return debugCodeGeneratorCrash();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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
|
|
|
// Run the raw input to see where we are coming from. If a reference output
|
|
|
|
// was specified, make sure that the raw output matches it. If not, it's a
|
|
|
|
// problem in the front-end or the code generator.
|
|
|
|
//
|
2003-08-22 18:57:43 +00:00
|
|
|
bool CreatedOutput = false;
|
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 (ReferenceOutputFile.empty()) {
|
2004-07-24 07:53:26 +00:00
|
|
|
std::cout << "Generating reference output from raw program: ";
|
2006-08-15 16:40:49 +00:00
|
|
|
if(!createReferenceFile(Program)){
|
2008-02-26 10:46:10 +00:00
|
|
|
return debugCodeGeneratorCrash();
|
2004-02-18 21:02:04 +00:00
|
|
|
}
|
2006-08-15 16:40:49 +00:00
|
|
|
CreatedOutput = true;
|
2003-10-14 20:52:55 +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
|
|
|
|
2003-10-14 20:52:55 +00:00
|
|
|
// Make sure the reference output file gets deleted on exit from this
|
|
|
|
// function, if appropriate.
|
2004-12-20 19:16:12 +00:00
|
|
|
sys::Path ROF(ReferenceOutputFile);
|
|
|
|
FileRemover RemoverInstance(ROF, CreatedOutput);
|
2003-10-14 20:52:55 +00:00
|
|
|
|
|
|
|
// Diff the output of the raw program against the reference output. If it
|
2006-08-15 16:40:49 +00:00
|
|
|
// matches, then we assume there is a miscompilation bug and try to
|
|
|
|
// diagnose it.
|
2003-10-14 20:52:55 +00:00
|
|
|
std::cout << "*** Checking the code generator...\n";
|
2004-02-18 21:02:04 +00:00
|
|
|
try {
|
|
|
|
if (!diffProgram()) {
|
2009-07-10 21:39:28 +00:00
|
|
|
std::cout << "\n*** Output matches: Debugging miscompilation!\n";
|
2004-02-18 21:02:04 +00:00
|
|
|
return debugMiscompilation();
|
|
|
|
}
|
|
|
|
} catch (ToolExecutionError &TEE) {
|
2004-02-19 07:39:26 +00:00
|
|
|
std::cerr << TEE.what();
|
2004-02-18 21:02:04 +00:00
|
|
|
return debugCodeGeneratorCrash();
|
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-10-14 20:52:55 +00:00
|
|
|
std::cout << "\n*** Input program does not match reference diff!\n";
|
|
|
|
std::cout << "Debugging code generator problem!\n";
|
2004-02-19 17:03:49 +00:00
|
|
|
try {
|
|
|
|
return debugCodeGenerator();
|
|
|
|
} catch (ToolExecutionError &TEE) {
|
|
|
|
std::cerr << TEE.what();
|
|
|
|
return debugCodeGeneratorCrash();
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2004-03-14 20:50:42 +00:00
|
|
|
void llvm::PrintFunctionList(const std::vector<Function*> &Funcs) {
|
|
|
|
unsigned NumPrint = Funcs.size();
|
|
|
|
if (NumPrint > 10) NumPrint = 10;
|
|
|
|
for (unsigned i = 0; i != NumPrint; ++i)
|
|
|
|
std::cout << " " << Funcs[i]->getName();
|
|
|
|
if (NumPrint < Funcs.size())
|
|
|
|
std::cout << "... <" << Funcs.size() << " total>";
|
2003-10-15 20:42:48 +00:00
|
|
|
std::cout << std::flush;
|
2002-11-20 22:28:10 +00:00
|
|
|
}
|
2006-10-25 18:36:14 +00:00
|
|
|
|
|
|
|
void llvm::PrintGlobalVariableList(const std::vector<GlobalVariable*> &GVs) {
|
|
|
|
unsigned NumPrint = GVs.size();
|
|
|
|
if (NumPrint > 10) NumPrint = 10;
|
|
|
|
for (unsigned i = 0; i != NumPrint; ++i)
|
|
|
|
std::cout << " " << GVs[i]->getName();
|
|
|
|
if (NumPrint < GVs.size())
|
|
|
|
std::cout << "... <" << GVs.size() << " total>";
|
|
|
|
std::cout << std::flush;
|
|
|
|
}
|