Move ToolRunner.(cpp|h) into the bugpoint directory

llvm-svn: 28699

6 files changed, 717 insertions, 4 deletions

diff --git a/llvm/tools/bugpoint/BugDriver.cpp b/llvm/tools/bugpoint/BugDriver.cpp
index 66608132112..8251ee4e3fa 100644
--- a/llvm/tools/bugpoint/BugDriver.cpp
+++ b/llvm/tools/bugpoint/BugDriver.cpp
@@ -14,12 +14,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
+#include "ToolRunner.h"
 #include "llvm/Linker.h"
 #include "llvm/Module.h"
 #include "llvm/Pass.h"
 #include "llvm/Assembly/Parser.h"
 #include "llvm/Bytecode/Reader.h"
-#include "llvm/Support/ToolRunner.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileUtilities.h"
 #include <iostream>
diff --git a/llvm/tools/bugpoint/CrashDebugger.cpp b/llvm/tools/bugpoint/CrashDebugger.cpp
index 53b15800aed..2e2ab20fa04 100644
--- a/llvm/tools/bugpoint/CrashDebugger.cpp
+++ b/llvm/tools/bugpoint/CrashDebugger.cpp
@@ -12,6 +12,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
+#include "ToolRunner.h"
 #include "ListReducer.h"
 #include "llvm/Constant.h"
 #include "llvm/Instructions.h"
@@ -23,7 +24,6 @@
 #include "llvm/Analysis/Verifier.h"
 #include "llvm/Bytecode/Writer.h"
 #include "llvm/Support/CFG.h"
-#include "llvm/Support/ToolRunner.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Cloning.h"
 #include "llvm/Support/FileUtilities.h"
diff --git a/llvm/tools/bugpoint/ExecutionDriver.cpp b/llvm/tools/bugpoint/ExecutionDriver.cpp
index 481d1d1fed4..72e564ec3c0 100644
--- a/llvm/tools/bugpoint/ExecutionDriver.cpp
+++ b/llvm/tools/bugpoint/ExecutionDriver.cpp
@@ -13,7 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
-#include "llvm/Support/ToolRunner.h"
+#include "ToolRunner.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileUtilities.h"
diff --git a/llvm/tools/bugpoint/ToolRunner.cpp b/llvm/tools/bugpoint/ToolRunner.cpp
new file mode 100644
index 00000000000..37f080ab9c1
--- /dev/null
+++ b/llvm/tools/bugpoint/ToolRunner.cpp
@@ -0,0 +1,514 @@
+//===-- ToolRunner.cpp ----------------------------------------------------===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the interfaces described in the ToolRunner.h file.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "toolrunner"
+#include "ToolRunner.h"
+#include "llvm/Config/config.h"   // for HAVE_LINK_R
+#include "llvm/System/Program.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/FileUtilities.h"
+#include <fstream>
+#include <sstream>
+#include <iostream>
+using namespace llvm;
+
+ToolExecutionError::~ToolExecutionError() throw() { }
+
+/// RunProgramWithTimeout - This function provides an alternate interface to the
+/// sys::Program::ExecuteAndWait interface.
+/// @see sys:Program::ExecuteAndWait
+static int RunProgramWithTimeout(const sys::Path &ProgramPath,
+                                 const char **Args,
+                                 const sys::Path &StdInFile,
+                                 const sys::Path &StdOutFile,
+                                 const sys::Path &StdErrFile,
+                                 unsigned NumSeconds = 0) {
+  const sys::Path* redirects[3];
+  redirects[0] = &StdInFile;
+  redirects[1] = &StdOutFile;
+  redirects[2] = &StdErrFile;
+
+  return
+    sys::Program::ExecuteAndWait(ProgramPath, Args, 0, redirects, NumSeconds);
+}
+
+
+
+static void ProcessFailure(sys::Path ProgPath, const char** Args) {
+  std::ostringstream OS;
+  OS << "\nError running tool:\n ";
+  for (const char **Arg = Args; *Arg; ++Arg)
+    OS << " " << *Arg;
+  OS << "\n";
+
+  // Rerun the compiler, capturing any error messages to print them.
+  sys::Path ErrorFilename("error_messages");
+  ErrorFilename.makeUnique();
+  RunProgramWithTimeout(ProgPath, Args, sys::Path(""), ErrorFilename,
+                        ErrorFilename);
+
+  // Print out the error messages generated by GCC if possible...
+  std::ifstream ErrorFile(ErrorFilename.c_str());
+  if (ErrorFile) {
+    std::copy(std::istreambuf_iterator<char>(ErrorFile),
+              std::istreambuf_iterator<char>(),
+              std::ostreambuf_iterator<char>(OS));
+    ErrorFile.close();
+  }
+
+  ErrorFilename.eraseFromDisk();
+  throw ToolExecutionError(OS.str());
+}
+
+//===---------------------------------------------------------------------===//
+// LLI Implementation of AbstractIntepreter interface
+//
+namespace {
+  class LLI : public AbstractInterpreter {
+    std::string LLIPath;          // The path to the LLI executable
+    std::vector<std::string> ToolArgs; // Args to pass to LLI
+  public:
+    LLI(const std::string &Path, const std::vector<std::string> *Args)
+      : LLIPath(Path) {
+      ToolArgs.clear ();
+      if (Args) { ToolArgs = *Args; }
+    }
+
+    virtual int ExecuteProgram(const std::string &Bytecode,
+                               const std::vector<std::string> &Args,
+                               const std::string &InputFile,
+                               const std::string &OutputFile,
+                               const std::vector<std::string> &GCCArgs,
+                               const std::vector<std::string> &SharedLibs =
+                               std::vector<std::string>(),
+                               unsigned Timeout = 0);
+  };
+}
+
+int LLI::ExecuteProgram(const std::string &Bytecode,
+                        const std::vector<std::string> &Args,
+                        const std::string &InputFile,
+                        const std::string &OutputFile,
+                        const std::vector<std::string> &GCCArgs,
+                        const std::vector<std::string> &SharedLibs,
+                        unsigned Timeout) {
+  if (!SharedLibs.empty())
+    throw ToolExecutionError("LLI currently does not support "
+                             "loading shared libraries.");
+
+  if (!GCCArgs.empty())
+    throw ToolExecutionError("LLI currently does not support "
+                             "GCC Arguments.");
+  std::vector<const char*> LLIArgs;
+  LLIArgs.push_back(LLIPath.c_str());
+  LLIArgs.push_back("-force-interpreter=true");
+
+  // Add any extra LLI args.
+  for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
+    LLIArgs.push_back(ToolArgs[i].c_str());
+
+  LLIArgs.push_back(Bytecode.c_str());
+  // Add optional parameters to the running program from Argv
+  for (unsigned i=0, e = Args.size(); i != e; ++i)
+    LLIArgs.push_back(Args[i].c_str());
+  LLIArgs.push_back(0);
+
+  std::cout << "<lli>" << std::flush;
+  DEBUG(std::cerr << "\nAbout to run:\t";
+        for (unsigned i=0, e = LLIArgs.size()-1; i != e; ++i)
+          std::cerr << " " << LLIArgs[i];
+        std::cerr << "\n";
+        );
+  return RunProgramWithTimeout(sys::Path(LLIPath), &LLIArgs[0],
+      sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+      Timeout);
+}
+
+// LLI create method - Try to find the LLI executable
+AbstractInterpreter *AbstractInterpreter::createLLI(const std::string &ProgPath,
+                                                    std::string &Message,
+                                     const std::vector<std::string> *ToolArgs) {
+  std::string LLIPath = FindExecutable("lli", ProgPath).toString();
+  if (!LLIPath.empty()) {
+    Message = "Found lli: " + LLIPath + "\n";
+    return new LLI(LLIPath, ToolArgs);
+  }
+
+  Message = "Cannot find `lli' in executable directory or PATH!\n";
+  return 0;
+}
+
+//===----------------------------------------------------------------------===//
+// LLC Implementation of AbstractIntepreter interface
+//
+void LLC::OutputAsm(const std::string &Bytecode, sys::Path &OutputAsmFile) {
+  sys::Path uniqueFile(Bytecode+".llc.s");
+  uniqueFile.makeUnique();
+  OutputAsmFile = uniqueFile;
+  std::vector<const char *> LLCArgs;
+  LLCArgs.push_back (LLCPath.c_str());
+
+  // Add any extra LLC args.
+  for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
+    LLCArgs.push_back(ToolArgs[i].c_str());
+
+  LLCArgs.push_back ("-o");
+  LLCArgs.push_back (OutputAsmFile.c_str()); // Output to the Asm file
+  LLCArgs.push_back ("-f");                  // Overwrite as necessary...
+  LLCArgs.push_back (Bytecode.c_str());      // This is the input bytecode
+  LLCArgs.push_back (0);
+
+  std::cout << "<llc>" << std::flush;
+  DEBUG(std::cerr << "\nAbout to run:\t";
+        for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
+          std::cerr << " " << LLCArgs[i];
+        std::cerr << "\n";
+        );
+  if (RunProgramWithTimeout(sys::Path(LLCPath), &LLCArgs[0],
+                            sys::Path(), sys::Path(), sys::Path()))
+    ProcessFailure(sys::Path(LLCPath), &LLCArgs[0]);
+}
+
+void LLC::compileProgram(const std::string &Bytecode) {
+  sys::Path OutputAsmFile;
+  OutputAsm(Bytecode, OutputAsmFile);
+  OutputAsmFile.eraseFromDisk();
+}
+
+int LLC::ExecuteProgram(const std::string &Bytecode,
+                        const std::vector<std::string> &Args,
+                        const std::string &InputFile,
+                        const std::string &OutputFile,
+                        const std::vector<std::string> &ArgsForGCC,
+                        const std::vector<std::string> &SharedLibs,
+                        unsigned Timeout) {
+
+  sys::Path OutputAsmFile;
+  OutputAsm(Bytecode, OutputAsmFile);
+  FileRemover OutFileRemover(OutputAsmFile);
+
+  std::vector<std::string> GCCArgs(ArgsForGCC);
+  GCCArgs.insert(GCCArgs.end(),SharedLibs.begin(),SharedLibs.end());
+
+  // Assuming LLC worked, compile the result with GCC and run it.
+  return gcc->ExecuteProgram(OutputAsmFile.toString(), Args, GCC::AsmFile,
+                             InputFile, OutputFile, GCCArgs, Timeout);
+}
+
+/// createLLC - Try to find the LLC executable
+///
+LLC *AbstractInterpreter::createLLC(const std::string &ProgramPath,
+                                    std::string &Message,
+                                    const std::vector<std::string> *Args) {
+  std::string LLCPath = FindExecutable("llc", ProgramPath).toString();
+  if (LLCPath.empty()) {
+    Message = "Cannot find `llc' in executable directory or PATH!\n";
+    return 0;
+  }
+
+  Message = "Found llc: " + LLCPath + "\n";
+  GCC *gcc = GCC::create(ProgramPath, Message);
+  if (!gcc) {
+    std::cerr << Message << "\n";
+    exit(1);
+  }
+  return new LLC(LLCPath, gcc, Args);
+}
+
+//===---------------------------------------------------------------------===//
+// JIT Implementation of AbstractIntepreter interface
+//
+namespace {
+  class JIT : public AbstractInterpreter {
+    std::string LLIPath;          // The path to the LLI executable
+    std::vector<std::string> ToolArgs; // Args to pass to LLI
+  public:
+    JIT(const std::string &Path, const std::vector<std::string> *Args)
+      : LLIPath(Path) {
+      ToolArgs.clear ();
+      if (Args) { ToolArgs = *Args; }
+    }
+
+    virtual int ExecuteProgram(const std::string &Bytecode,
+                               const std::vector<std::string> &Args,
+                               const std::string &InputFile,
+                               const std::string &OutputFile,
+                               const std::vector<std::string> &GCCArgs =
+                                 std::vector<std::string>(),
+                               const std::vector<std::string> &SharedLibs =
+                                 std::vector<std::string>(), 
+                               unsigned Timeout =0 );
+  };
+}
+
+int JIT::ExecuteProgram(const std::string &Bytecode,
+                        const std::vector<std::string> &Args,
+                        const std::string &InputFile,
+                        const std::string &OutputFile,
+                        const std::vector<std::string> &GCCArgs,
+                        const std::vector<std::string> &SharedLibs,
+                        unsigned Timeout) {
+  if (!GCCArgs.empty())
+    throw ToolExecutionError("JIT does not support GCC Arguments.");
+  // Construct a vector of parameters, incorporating those from the command-line
+  std::vector<const char*> JITArgs;
+  JITArgs.push_back(LLIPath.c_str());
+  JITArgs.push_back("-force-interpreter=false");
+
+  // Add any extra LLI args.
+  for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
+    JITArgs.push_back(ToolArgs[i].c_str());
+
+  for (unsigned i = 0, e = SharedLibs.size(); i != e; ++i) {
+    JITArgs.push_back("-load");
+    JITArgs.push_back(SharedLibs[i].c_str());
+  }
+  JITArgs.push_back(Bytecode.c_str());
+  // Add optional parameters to the running program from Argv
+  for (unsigned i=0, e = Args.size(); i != e; ++i)
+    JITArgs.push_back(Args[i].c_str());
+  JITArgs.push_back(0);
+
+  std::cout << "<jit>" << std::flush;
+  DEBUG(std::cerr << "\nAbout to run:\t";
+        for (unsigned i=0, e = JITArgs.size()-1; i != e; ++i)
+          std::cerr << " " << JITArgs[i];
+        std::cerr << "\n";
+        );
+  DEBUG(std::cerr << "\nSending output to " << OutputFile << "\n");
+  return RunProgramWithTimeout(sys::Path(LLIPath), &JITArgs[0],
+      sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+      Timeout);
+}
+
+/// createJIT - Try to find the LLI executable
+///
+AbstractInterpreter *AbstractInterpreter::createJIT(const std::string &ProgPath,
+                   std::string &Message, const std::vector<std::string> *Args) {
+  std::string LLIPath = FindExecutable("lli", ProgPath).toString();
+  if (!LLIPath.empty()) {
+    Message = "Found lli: " + LLIPath + "\n";
+    return new JIT(LLIPath, Args);
+  }
+
+  Message = "Cannot find `lli' in executable directory or PATH!\n";
+  return 0;
+}
+
+void CBE::OutputC(const std::string &Bytecode, sys::Path& OutputCFile) {
+  sys::Path uniqueFile(Bytecode+".cbe.c");
+  uniqueFile.makeUnique();
+  OutputCFile = uniqueFile;
+  std::vector<const char *> LLCArgs;
+  LLCArgs.push_back (LLCPath.c_str());
+
+  // Add any extra LLC args.
+  for (unsigned i = 0, e = ToolArgs.size(); i != e; ++i)
+    LLCArgs.push_back(ToolArgs[i].c_str());
+
+  LLCArgs.push_back ("-o");
+  LLCArgs.push_back (OutputCFile.c_str());   // Output to the C file
+  LLCArgs.push_back ("-march=c");            // Output C language
+  LLCArgs.push_back ("-f");                  // Overwrite as necessary...
+  LLCArgs.push_back (Bytecode.c_str());      // This is the input bytecode
+  LLCArgs.push_back (0);
+
+  std::cout << "<cbe>" << std::flush;
+  DEBUG(std::cerr << "\nAbout to run:\t";
+        for (unsigned i=0, e = LLCArgs.size()-1; i != e; ++i)
+          std::cerr << " " << LLCArgs[i];
+        std::cerr << "\n";
+        );
+  if (RunProgramWithTimeout(LLCPath, &LLCArgs[0], sys::Path(), sys::Path(),
+                            sys::Path()))
+    ProcessFailure(LLCPath, &LLCArgs[0]);
+}
+
+void CBE::compileProgram(const std::string &Bytecode) {
+  sys::Path OutputCFile;
+  OutputC(Bytecode, OutputCFile);
+  OutputCFile.eraseFromDisk();
+}
+
+int CBE::ExecuteProgram(const std::string &Bytecode,
+                        const std::vector<std::string> &Args,
+                        const std::string &InputFile,
+                        const std::string &OutputFile,
+                        const std::vector<std::string> &ArgsForGCC,
+                        const std::vector<std::string> &SharedLibs,
+                        unsigned Timeout) {
+  sys::Path OutputCFile;
+  OutputC(Bytecode, OutputCFile);
+
+  FileRemover CFileRemove(OutputCFile);
+
+  std::vector<std::string> GCCArgs(ArgsForGCC);
+  GCCArgs.insert(GCCArgs.end(),SharedLibs.begin(),SharedLibs.end());
+  return gcc->ExecuteProgram(OutputCFile.toString(), Args, GCC::CFile,
+                             InputFile, OutputFile, GCCArgs, Timeout);
+}
+
+/// createCBE - Try to find the 'llc' executable
+///
+CBE *AbstractInterpreter::createCBE(const std::string &ProgramPath,
+                                    std::string &Message,
+                                    const std::vector<std::string> *Args) {
+  sys::Path LLCPath = FindExecutable("llc", ProgramPath);
+  if (LLCPath.isEmpty()) {
+    Message =
+      "Cannot find `llc' in executable directory or PATH!\n";
+    return 0;
+  }
+
+  Message = "Found llc: " + LLCPath.toString() + "\n";
+  GCC *gcc = GCC::create(ProgramPath, Message);
+  if (!gcc) {
+    std::cerr << Message << "\n";
+    exit(1);
+  }
+  return new CBE(LLCPath, gcc, Args);
+}
+
+//===---------------------------------------------------------------------===//
+// GCC abstraction
+//
+int GCC::ExecuteProgram(const std::string &ProgramFile,
+                        const std::vector<std::string> &Args,
+                        FileType fileType,
+                        const std::string &InputFile,
+                        const std::string &OutputFile,
+                        const std::vector<std::string> &ArgsForGCC,
+                        unsigned Timeout ) {
+  std::vector<const char*> GCCArgs;
+
+  GCCArgs.push_back(GCCPath.c_str());
+
+  // Specify -x explicitly in case the extension is wonky
+  GCCArgs.push_back("-x");
+  if (fileType == CFile) {
+    GCCArgs.push_back("c");
+    GCCArgs.push_back("-fno-strict-aliasing");
+  } else {
+    GCCArgs.push_back("assembler");
+#ifdef __APPLE__
+    GCCArgs.push_back("-force_cpusubtype_ALL");
+#endif
+  }
+  GCCArgs.push_back(ProgramFile.c_str());  // Specify the input filename...
+  GCCArgs.push_back("-o");
+  sys::Path OutputBinary (ProgramFile+".gcc.exe");
+  OutputBinary.makeUnique();
+  GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
+
+  // Add any arguments intended for GCC. We locate them here because this is
+  // most likely -L and -l options that need to come before other libraries but
+  // after the source. Other options won't be sensitive to placement on the
+  // command line, so this should be safe.
+  for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i)
+    GCCArgs.push_back(ArgsForGCC[i].c_str());
+
+  GCCArgs.push_back("-lm");                // Hard-code the math library...
+  GCCArgs.push_back("-O2");                // Optimize the program a bit...
+#if defined (HAVE_LINK_R)
+  GCCArgs.push_back("-Wl,-R.");            // Search this dir for .so files
+#endif
+#ifdef __sparc__
+  GCCArgs.push_back("-mcpu=v9");
+#endif
+  GCCArgs.push_back(0);                    // NULL terminator
+
+  std::cout << "<gcc>" << std::flush;
+  if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], sys::Path(), sys::Path(),
+        sys::Path())) {
+    ProcessFailure(GCCPath, &GCCArgs[0]);
+    exit(1);
+  }
+
+  std::vector<const char*> ProgramArgs;
+
+  ProgramArgs.push_back(OutputBinary.c_str());
+  // Add optional parameters to the running program from Argv
+  for (unsigned i=0, e = Args.size(); i != e; ++i)
+    ProgramArgs.push_back(Args[i].c_str());
+  ProgramArgs.push_back(0);                // NULL terminator
+
+  // Now that we have a binary, run it!
+  std::cout << "<program>" << std::flush;
+  DEBUG(std::cerr << "\nAbout to run:\t";
+        for (unsigned i=0, e = ProgramArgs.size()-1; i != e; ++i)
+          std::cerr << " " << ProgramArgs[i];
+        std::cerr << "\n";
+        );
+
+  FileRemover OutputBinaryRemover(OutputBinary);
+  return RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
+      sys::Path(InputFile), sys::Path(OutputFile), sys::Path(OutputFile),
+      Timeout);
+}
+
+int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType,
+                          std::string &OutputFile) {
+  sys::Path uniqueFilename(InputFile+LTDL_SHLIB_EXT);
+  uniqueFilename.makeUnique();
+  OutputFile = uniqueFilename.toString();
+
+  // Compile the C/asm file into a shared object
+  const char* GCCArgs[] = {
+    GCCPath.c_str(),
+    "-x", (fileType == AsmFile) ? "assembler" : "c",
+    "-fno-strict-aliasing",
+    InputFile.c_str(),           // Specify the input filename...
+#if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
+    "-G",                        // Compile a shared library, `-G' for Sparc
+#elif defined(__APPLE__)
+    "-single_module",            // link all source files into a single module
+    "-dynamiclib",               // `-dynamiclib' for MacOS X/PowerPC
+    "-undefined",                // in data segment, rather than generating
+    "dynamic_lookup",            // blocks. dynamic_lookup requires that you set
+                                 // MACOSX_DEPLOYMENT_TARGET=10.3 in your env.
+#else
+    "-shared",                   // `-shared' for Linux/X86, maybe others
+#endif
+
+#if defined(__ia64__) || defined(__alpha__)
+    "-fPIC",                     // IA64 requires shared objs to contain PIC
+#endif
+#ifdef __sparc__
+    "-mcpu=v9",
+#endif
+    "-o", OutputFile.c_str(),    // Output to the right filename...
+    "-O2",                       // Optimize the program a bit...
+    0
+  };
+
+  std::cout << "<gcc>" << std::flush;
+  if (RunProgramWithTimeout(GCCPath, GCCArgs, sys::Path(), sys::Path(),
+                            sys::Path())) {
+    ProcessFailure(GCCPath, GCCArgs);
+    return 1;
+  }
+  return 0;
+}
+
+/// create - Try to find the `gcc' executable
+///
+GCC *GCC::create(const std::string &ProgramPath, std::string &Message) {
+  sys::Path GCCPath = FindExecutable("gcc", ProgramPath);
+  if (GCCPath.isEmpty()) {
+    Message = "Cannot find `gcc' in executable directory or PATH!\n";
+    return 0;
+  }
+
+  Message = "Found gcc: " + GCCPath.toString() + "\n";
+  return new GCC(GCCPath);
+}
diff --git a/llvm/tools/bugpoint/ToolRunner.h b/llvm/tools/bugpoint/ToolRunner.h
new file mode 100644
index 00000000000..9d2903cc643
--- /dev/null
+++ b/llvm/tools/bugpoint/ToolRunner.h
@@ -0,0 +1,199 @@
+//===-- tools/bugpoint/ToolRunner.h -----------------------------*- C++ -*-===//
+//
+//                     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.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file exposes an abstraction around a platform C compiler, used to
+// compile C and assembly code.  It also exposes an "AbstractIntepreter"
+// interface, which is used to execute code using one of the LLVM execution
+// engines.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef BUGPOINT_TOOLRUNNER_H
+#define BUGPOINT_TOOLRUNNER_H
+
+#include "llvm/Support/SystemUtils.h"
+#include <exception>
+#include <vector>
+
+namespace llvm {
+
+class CBE;
+class LLC;
+
+/// ToolExecutionError - An instance of this class is thrown by the
+/// AbstractInterpreter instances if there is an error running a tool (e.g., LLC
+/// crashes) which prevents execution of the program.
+///
+class ToolExecutionError : std::exception {
+  std::string Message;
+public:
+  explicit ToolExecutionError(const std::string &M) : Message(M) {}
+  virtual ~ToolExecutionError() throw();
+  virtual const char* what() const throw() { return Message.c_str(); }
+};
+
+
+//===---------------------------------------------------------------------===//
+// GCC abstraction
+//
+class GCC {
+  sys::Path GCCPath;          // The path to the gcc executable
+  GCC(const sys::Path &gccPath) : GCCPath(gccPath) { }
+public:
+  enum FileType { AsmFile, CFile };
+
+  static GCC* create(const std::string &ProgramPath, std::string &Message);
+
+  /// ExecuteProgram - Execute the program specified by "ProgramFile" (which is
+  /// either a .s file, or a .c file, specified by FileType), with the specified
+  /// arguments.  Standard input is specified with InputFile, and standard
+  /// Output is captured to the specified OutputFile location.  The SharedLibs
+  /// option specifies optional native shared objects that can be loaded into
+  /// the program for execution.
+  ///
+  int ExecuteProgram(const std::string &ProgramFile,
+                     const std::vector<std::string> &Args,
+                     FileType fileType,
+                     const std::string &InputFile,
+                     const std::string &OutputFile,
+                     const std::vector<std::string> &GCCArgs =
+                         std::vector<std::string>(), 
+                     unsigned Timeout = 0);
+
+  /// MakeSharedObject - This compiles the specified file (which is either a .c
+  /// file or a .s file) into a shared object.
+  ///
+  int MakeSharedObject(const std::string &InputFile, FileType fileType,
+                       std::string &OutputFile);
+};
+
+
+//===---------------------------------------------------------------------===//
+/// AbstractInterpreter Class - Subclasses of this class are used to execute
+/// LLVM bytecode in a variety of ways.  This abstract interface hides this
+/// complexity behind a simple interface.
+///
+class AbstractInterpreter {
+public:
+  static CBE *createCBE(const std::string &ProgramPath, std::string &Message,
+                        const std::vector<std::string> *Args = 0);
+  static LLC *createLLC(const std::string &ProgramPath, std::string &Message,
+                        const std::vector<std::string> *Args = 0);
+
+  static AbstractInterpreter* createLLI(const std::string &ProgramPath,
+                                        std::string &Message,
+                                        const std::vector<std::string> *Args=0);
+
+  static AbstractInterpreter* createJIT(const std::string &ProgramPath,
+                                        std::string &Message,
+                                        const std::vector<std::string> *Args=0);
+
+
+  virtual ~AbstractInterpreter() {}
+
+  /// compileProgram - Compile the specified program from bytecode to executable
+  /// code.  This does not produce any output, it is only used when debugging
+  /// the code generator.  If the code generator fails, an exception should be
+  /// thrown, otherwise, this function will just return.
+  virtual void compileProgram(const std::string &Bytecode) {}
+
+  /// ExecuteProgram - Run the specified bytecode file, emitting output to the
+  /// specified filename.  This returns the exit code of the program.
+  ///
+  virtual int ExecuteProgram(const std::string &Bytecode,
+                             const std::vector<std::string> &Args,
+                             const std::string &InputFile,
+                             const std::string &OutputFile,
+                             const std::vector<std::string> &GCCArgs =
+                               std::vector<std::string>(),
+                             const std::vector<std::string> &SharedLibs =
+                               std::vector<std::string>(),
+                             unsigned Timeout = 0) = 0;
+};
+
+//===---------------------------------------------------------------------===//
+// CBE Implementation of AbstractIntepreter interface
+//
+class CBE : public AbstractInterpreter {
+  sys::Path LLCPath;          // The path to the `llc' executable
+  std::vector<std::string> ToolArgs; // Extra args to pass to LLC
+  GCC *gcc;
+public:
+  CBE(const sys::Path &llcPath, GCC *Gcc,
+      const std::vector<std::string> *Args) : LLCPath(llcPath), gcc(Gcc) {
+    ToolArgs.clear ();
+    if (Args) { ToolArgs = *Args; }
+  }
+  ~CBE() { delete gcc; }
+
+  /// compileProgram - Compile the specified program from bytecode to executable
+  /// code.  This does not produce any output, it is only used when debugging
+  /// the code generator.  If the code generator fails, an exception should be
+  /// thrown, otherwise, this function will just return.
+  virtual void compileProgram(const std::string &Bytecode);
+
+  virtual int ExecuteProgram(const std::string &Bytecode,
+                             const std::vector<std::string> &Args,
+                             const std::string &InputFile,
+                             const std::string &OutputFile,
+                             const std::vector<std::string> &GCCArgs =
+                               std::vector<std::string>(),
+                             const std::vector<std::string> &SharedLibs =
+                               std::vector<std::string>(),
+                             unsigned Timeout = 0);
+
+  // Sometimes we just want to go half-way and only generate the .c file, not
+  // necessarily compile it with GCC and run the program.  This throws an
+  // exception if LLC crashes.
+  //
+  virtual void OutputC(const std::string &Bytecode, sys::Path& OutputCFile);
+};
+
+
+//===---------------------------------------------------------------------===//
+// LLC Implementation of AbstractIntepreter interface
+//
+class LLC : public AbstractInterpreter {
+  std::string LLCPath;          // The path to the LLC executable
+  std::vector<std::string> ToolArgs; // Extra args to pass to LLC
+  GCC *gcc;
+public:
+  LLC(const std::string &llcPath, GCC *Gcc,
+    const std::vector<std::string> *Args) : LLCPath(llcPath), gcc(Gcc) {
+    ToolArgs.clear ();
+    if (Args) { ToolArgs = *Args; }
+  }
+  ~LLC() { delete gcc; }
+
+  /// compileProgram - Compile the specified program from bytecode to executable
+  /// code.  This does not produce any output, it is only used when debugging
+  /// the code generator.  If the code generator fails, an exception should be
+  /// thrown, otherwise, this function will just return.
+  virtual void compileProgram(const std::string &Bytecode);
+
+  virtual int ExecuteProgram(const std::string &Bytecode,
+                             const std::vector<std::string> &Args,
+                             const std::string &InputFile,
+                             const std::string &OutputFile,
+                             const std::vector<std::string> &GCCArgs =
+                               std::vector<std::string>(),
+                             const std::vector<std::string> &SharedLibs =
+                                std::vector<std::string>(),
+                             unsigned Timeout = 0);
+
+  // Sometimes we just want to go half-way and only generate the .s file,
+  // not necessarily compile it all the way and run the program.  This throws
+  // an exception if execution of LLC fails.
+  //
+  void OutputAsm(const std::string &Bytecode, sys::Path &OutputAsmFile);
+};
+
+} // End llvm namespace
+
+#endif
diff --git a/llvm/tools/bugpoint/bugpoint.cpp b/llvm/tools/bugpoint/bugpoint.cpp
index 7991ab835e8..f30243dcc45 100644
--- a/llvm/tools/bugpoint/bugpoint.cpp
+++ b/llvm/tools/bugpoint/bugpoint.cpp
@@ -14,10 +14,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "BugDriver.h"
+#include "ToolRunner.h"
 #include "llvm/Analysis/LinkAllAnalyses.h"
 #include "llvm/Transforms/LinkAllPasses.h"
 #include "llvm/Support/PassNameParser.h"
-#include "llvm/Support/ToolRunner.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/System/Process.h"