return Result;
}
-BugDriver::BugDriver(const char *toolname, bool find_bugs,
+BugDriver::BugDriver(const char *toolname, bool as_child, bool find_bugs,
unsigned timeout, unsigned memlimit, bool use_valgrind,
LLVMContext& ctxt)
: Context(ctxt), ToolName(toolname), ReferenceOutputFile(OutputFile),
Program(0), Interpreter(0), SafeInterpreter(0), gcc(0),
- run_find_bugs(find_bugs), Timeout(timeout),
+ run_as_child(as_child), run_find_bugs(find_bugs), Timeout(timeout),
MemoryLimit(memlimit), UseValgrind(use_valgrind) {}
BugDriver::~BugDriver() {
Program = ParseInputFile(Filenames[0], Context);
if (Program == 0) return true;
- outs() << "Read input file : '" << Filenames[0] << "'\n";
+ if (!run_as_child)
+ outs() << "Read input file : '" << Filenames[0] << "'\n";
for (unsigned i = 1, e = Filenames.size(); i != e; ++i) {
std::auto_ptr<Module> M(ParseInputFile(Filenames[i], Context));
if (M.get() == 0) return true;
- outs() << "Linking in input file: '" << Filenames[i] << "'\n";
+ if (!run_as_child)
+ outs() << "Linking in input file: '" << Filenames[i] << "'\n";
std::string ErrorMessage;
if (Linker::LinkModules(Program, M.get(), &ErrorMessage)) {
errs() << ToolName << ": error linking in '" << Filenames[i] << "': "
}
}
- outs() << "*** All input ok\n";
+ if (!run_as_child)
+ outs() << "*** All input ok\n";
// All input files read successfully!
return false;
/// variables are set up from command line arguments.
///
bool BugDriver::run(std::string &ErrMsg) {
+ // 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);
+ }
+
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.
AbstractInterpreter *Interpreter; // How to run the program
AbstractInterpreter *SafeInterpreter; // To generate reference output, etc.
GCC *gcc;
+ bool run_as_child;
bool run_find_bugs;
unsigned Timeout;
unsigned MemoryLimit;
friend class ReduceMisCodegenFunctions;
public:
- BugDriver(const char *toolname, bool find_bugs,
+ BugDriver(const char *toolname, bool as_child, bool find_bugs,
unsigned timeout, unsigned memlimit, bool use_valgrind,
LLVMContext& ctxt);
~BugDriver();
return runPasses(M, PassesToRun, Filename, DeleteOutput);
}
+ /// runAsChild - The actual "runPasses" guts that runs in a child process.
+ int runPassesAsChild(const std::vector<const PassInfo*> &PassesToRun);
+
/// initializeExecutionEnvironment - This method is used to set up the
/// environment for executing LLVM programs.
///
#include "llvm/Target/TargetData.h"
#include "llvm/Support/FileUtilities.h"
#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/System/Path.h"
#include "llvm/System/Program.h"
outs() << getPassesString(PassesToRun) << "\n";
}
+int BugDriver::runPassesAsChild(const std::vector<const PassInfo*> &Passes) {
+ std::string ErrInfo;
+ raw_fd_ostream OutFile(ChildOutput.c_str(), ErrInfo,
+ raw_fd_ostream::F_Binary);
+ if (!ErrInfo.empty()) {
+ errs() << "Error opening bitcode file: " << ChildOutput << "\n";
+ return 1;
+ }
+
+ PassManager PM;
+ // Make sure that the appropriate target data is always used...
+ PM.add(new TargetData(Program));
+
+ for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
+ if (Passes[i]->getNormalCtor())
+ PM.add(Passes[i]->getNormalCtor()());
+ else
+ errs() << "Cannot create pass yet: " << Passes[i]->getPassName() << "\n";
+ }
+ // Check that the module is well formed on completion of optimization
+ PM.add(createVerifierPass());
+
+ // Write bitcode out to disk as the last step...
+ PM.add(createBitcodeWriterPass(OutFile));
+
+ // Run all queued passes.
+ PM.run(*Program);
+
+ return 0;
+}
+
cl::opt<bool> SilencePasses("silence-passes", cl::desc("Suppress output of running passes (both stdout and stderr)"));
/// runPasses - Run the specified passes on Program, outputting a bitcode file
// setup the child process' arguments
SmallVector<const char*, 8> Args;
- std::string Opt;
- llvm::StringRef TN(ToolName);
- if (TN.find('/') == llvm::StringRef::npos) {
- Opt = ToolName;
- } else {
- std::pair<llvm::StringRef, llvm::StringRef> P = TN.rsplit('/');
- Opt = P.first.str() + "/" + "opt";
- }
-
- sys::Path tool = sys::Program::FindProgramByName(Opt);
+ sys::Path tool = sys::Program::FindProgramByName(ToolName);
if (UseValgrind) {
Args.push_back("valgrind");
Args.push_back("--error-exitcode=1");
Args.push_back("-q");
Args.push_back(tool.c_str());
} else
- Args.push_back(Opt.c_str());
+ Args.push_back(ToolName);
- Args.push_back("-o");
+ Args.push_back("-as-child");
+ Args.push_back("-child-output");
Args.push_back(OutputFilename.c_str());
std::vector<std::string> pass_args;
for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) {
Args.push_back(*ExtraArgs);
Args.push_back(0);
- DEBUG(errs() << "\nAbout to run:\t";
- for (unsigned i = 0, e = Args.size()-1; i != e; ++i)
- errs() << " " << Args[i];
- errs() << "\n";
- );
-
sys::Path prog;
if (UseValgrind)
prog = sys::Program::FindProgramByName("valgrind");
#include "llvm/LinkAllVMCore.h"
using namespace llvm;
+// AsChild - Specifies that this invocation of bugpoint is being generated
+// from a parent process. It is not intended to be used by users so the
+// option is hidden.
+static cl::opt<bool>
+AsChild("as-child", cl::desc("Run bugpoint as child process"),
+ cl::ReallyHidden);
+
static cl::opt<bool>
FindBugs("find-bugs", cl::desc("Run many different optimization sequences "
"on program to find bugs"), cl::init(false));
MemoryLimit = 100;
}
- BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
+ BugDriver D(argv[0], AsChild, FindBugs, TimeoutValue, MemoryLimit,
UseValgrind, Context);
if (D.addSources(InputFilenames)) return 1;
projects / oota-llvm.git / commitdiff