Don't forget cmake!

[oota-llvm.git] / tools / bugpoint / ToolRunner.h

diff --git a/tools/bugpoint/ToolRunner.h b/tools/bugpoint/ToolRunner.h
index 0082c4463a57c8adf003b40a880f7f56c3f1f604..cba10f214a90c5ff4e8cbdf994e7ece46f01807c 100644 (file)
--- a/tools/bugpoint/ToolRunner.h
+++ b/tools/bugpoint/ToolRunner.h
@@ -17,31 +17,22 @@
 #ifndef BUGPOINT_TOOLRUNNER_H
 #define BUGPOINT_TOOLRUNNER_H
 
+#include "llvm/ADT/Triple.h"
 #include "llvm/Support/CommandLine.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SystemUtils.h"
+#include "llvm/System/Path.h"
 #include <exception>
 #include <vector>
 
 namespace llvm {
 
 extern cl::opt<bool> SaveTemps;
+extern Triple TargetTriple;
 
 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
 //
@@ -55,7 +46,7 @@ class GCC {
     if (GCCArgs) gccArgs = *GCCArgs;
   }
 public:
-  enum FileType { AsmFile, CFile };
+  enum FileType { AsmFile, ObjectFile, CFile };
 
   static GCC *create(std::string &Message,
                      const std::vector<std::string> *Args);
@@ -72,6 +63,7 @@ public:
                      FileType fileType,
                      const std::string &InputFile,
                      const std::string &OutputFile,
+                    std::string *Error = 0,
                      const std::vector<std::string> &GCCArgs =
                          std::vector<std::string>(), 
                      unsigned Timeout = 0,
@@ -82,7 +74,8 @@ public:
   ///
   int MakeSharedObject(const std::string &InputFile, FileType fileType,
                        std::string &OutputFile,
-                       const std::vector<std::string> &ArgsForGCC);
+                       const std::vector<std::string> &ArgsForGCC,
+                       std::string &Error);
 };
 
 
@@ -98,7 +91,8 @@ public:
                         const std::vector<std::string> *GCCArgs = 0);
   static LLC *createLLC(const char *Argv0, std::string &Message,
                         const std::vector<std::string> *Args = 0,
-                        const std::vector<std::string> *GCCArgs = 0);
+                        const std::vector<std::string> *GCCArgs = 0,
+                        bool UseIntegratedAssembler = false);
 
   static AbstractInterpreter* createLLI(const char *Argv0, std::string &Message,
                                         const std::vector<std::string> *Args=0);
@@ -114,26 +108,29 @@ public:
 
   /// compileProgram - Compile the specified program from bitcode 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 &Bitcode) {}
+  /// the code generator.  It returns false if the code generator fails.
+  virtual void compileProgram(const std::string &Bitcode, std::string *Error) {}
 
   /// OutputCode - Compile the specified program from bitcode to code
   /// understood by the GCC driver (either C or asm).  If the code generator
-  /// fails, an exception should be thrown, otherwise, this function returns the
-  /// type of code emitted.
+  /// fails, it sets Error, otherwise, this function returns the type of code
+  /// emitted.
   virtual GCC::FileType OutputCode(const std::string &Bitcode,
-                                   sys::Path &OutFile) {
-    throw std::string("OutputCode not supported by this AbstractInterpreter!");
+                                   sys::Path &OutFile, std::string &Error) {
+    Error = "OutputCode not supported by this AbstractInterpreter!";
+    return GCC::AsmFile;
   }
-  
+
   /// ExecuteProgram - Run the specified bitcode file, emitting output to the
-  /// specified filename.  This returns the exit code of the program.
+  /// specified filename.  This sets RetVal to the exit code of the program or
+  /// returns false if a problem was encountered that prevented execution of
+  /// the program.
   ///
   virtual int ExecuteProgram(const std::string &Bitcode,
                              const std::vector<std::string> &Args,
                              const std::string &InputFile,
                              const std::string &OutputFile,
+                             std::string *Error,
                              const std::vector<std::string> &GCCArgs =
                                std::vector<std::string>(),
                              const std::vector<std::string> &SharedLibs =
@@ -160,14 +157,14 @@ public:
 
   /// compileProgram - Compile the specified program from bitcode 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 &Bitcode);
+  /// the code generator.  Returns false if the code generator fails.
+  virtual void compileProgram(const std::string &Bitcode, std::string *Error);
 
   virtual int ExecuteProgram(const std::string &Bitcode,
                              const std::vector<std::string> &Args,
                              const std::string &InputFile,
                              const std::string &OutputFile,
+                             std::string *Error,
                              const std::vector<std::string> &GCCArgs =
                                std::vector<std::string>(),
                              const std::vector<std::string> &SharedLibs =
@@ -177,10 +174,10 @@ public:
 
   /// OutputCode - Compile the specified program from bitcode to code
   /// understood by the GCC driver (either C or asm).  If the code generator
-  /// fails, an exception should be thrown, otherwise, this function returns the
-  /// type of code emitted.
+  /// fails, it sets Error, otherwise, this function returns the type of code
+  /// emitted.
   virtual GCC::FileType OutputCode(const std::string &Bitcode,
-                                   sys::Path &OutFile);
+                                   sys::Path &OutFile, std::string &Error);
 };
 
 
@@ -192,11 +189,14 @@ class LLC : public AbstractInterpreter {
   std::vector<std::string> ToolArgs; // Extra args to pass to LLC.
   std::vector<std::string> gccArgs;  // Extra args to pass to GCC.
   GCC *gcc;
+  bool UseIntegratedAssembler;
 public:
   LLC(const std::string &llcPath, GCC *Gcc,
       const std::vector<std::string> *Args,
-      const std::vector<std::string> *GCCArgs)
-    : LLCPath(llcPath), gcc(Gcc) {
+      const std::vector<std::string> *GCCArgs,
+      bool useIntegratedAssembler)
+    : LLCPath(llcPath), gcc(Gcc),
+      UseIntegratedAssembler(useIntegratedAssembler) {
     ToolArgs.clear();
     if (Args) ToolArgs = *Args;
     if (GCCArgs) gccArgs = *GCCArgs;
@@ -205,14 +205,14 @@ public:
 
   /// compileProgram - Compile the specified program from bitcode 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 &Bitcode);
+  /// the code generator.  Returns false if the code generator fails.
+  virtual void compileProgram(const std::string &Bitcode, std::string *Error);
 
   virtual int ExecuteProgram(const std::string &Bitcode,
                              const std::vector<std::string> &Args,
                              const std::string &InputFile,
                              const std::string &OutputFile,
+                             std::string *Error,
                              const std::vector<std::string> &GCCArgs =
                                std::vector<std::string>(),
                              const std::vector<std::string> &SharedLibs =
@@ -220,9 +220,12 @@ public:
                              unsigned Timeout = 0,
                              unsigned MemoryLimit = 0);
 
+  /// OutputCode - Compile the specified program from bitcode to code
+  /// understood by the GCC driver (either C or asm).  If the code generator
+  /// fails, it sets Error, otherwise, this function returns the type of code
+  /// emitted.
   virtual GCC::FileType OutputCode(const std::string &Bitcode,
-                                   sys::Path &OutFile);
-  
+                                   sys::Path &OutFile, std::string &Error);
 };
 
 } // End llvm namespace