The preheader insertion pass only depends on the CFG. Mark it as such, which

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

diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 05d4108824af23ecf04e515601fa19b897e31909..eff11ec0de476974c25296f97d04cfd0c39b4bd3 100644 (file)
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -11,6 +11,7 @@
 
 #include <vector>
 #include <string>
+
 class PassInfo;
 class Module;
 class Function;
@@ -23,21 +24,30 @@ class ReduceMiscompilingFunctions;
 class ReduceCrashingFunctions;
 class ReduceCrashingBlocks;
 
+class CBE;
+class GCC;
+
+extern bool DisableSimplifyCFG;
+
 class BugDriver {
   const std::string ToolName;  // Name of bugpoint
+  std::string ReferenceOutputFile; // Name of `good' output file
   Module *Program;             // The raw program, linked together
   std::vector<const PassInfo*> PassesToRun;
   AbstractInterpreter *Interpreter;   // How to run the program
+  CBE *cbe;
+  GCC *gcc;
 
   // FIXME: sort out public/private distinctions...
   friend class DebugCrashes;
   friend class ReduceMiscompilingPasses;
   friend class ReduceMiscompilingFunctions;
+  friend class ReduceMisCodegenFunctions;
   friend class ReduceCrashingFunctions;
   friend class ReduceCrashingBlocks;
+
 public:
-  BugDriver(const char *toolname)
-    : ToolName(toolname), Program(0), Interpreter(0) {}
+  BugDriver(const char *toolname);
 
   const std::string &getToolName() const { return ToolName; }
 
@@ -73,6 +83,20 @@ public:
   bool debugPassMiscompilation(const PassInfo *ThePass,
                               const std::string &ReferenceOutput);
 
+  /// compileSharedObject - This method creates a SharedObject from a given
+  /// BytecodeFile for debugging a code generator.
+  int compileSharedObject(const std::string &BytecodeFile,
+                          std::string &SharedObject);
+
+  /// 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();
+
+  /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT
+  ///
+  bool isExecutingJIT();
+
 private:
   /// ParseInputFile - Given a bytecode or assembly input filename, parse and
   /// return it, or return null if not possible.
@@ -112,6 +136,10 @@ private:
     return runPasses(PassesToRun, Filename, DeleteOutput);
   }
 
+  /// PrintFunctionList - prints out list of problematic functions
+  ///
+  static void PrintFunctionList(const std::vector<Function*> &Funcs);
+
   /// 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
@@ -121,9 +149,10 @@ private:
 
   /// performFinalCleanups - This method clones the current Program and performs
   /// a series of cleanups intended to get rid of extra cruft on the module
-  /// before handing it to the user...
+  /// before handing it to the user... if the module parameter is specified, it
+  /// operates directly on the specified Module, modifying it in place.
   ///
-  Module *performFinalCleanups() const;
+  Module *performFinalCleanups(Module *M = 0) const;
 
   /// initializeExecutionEnvironment - This method is used to set up the
   /// environment for executing LLVM programs.
@@ -135,14 +164,22 @@ private:
   /// filename may be optionally specified.
   ///
   std::string executeProgram(std::string RequestedOutputFilename = "",
-                            std::string Bytecode = "");
+                             std::string Bytecode = "",
+                             std::string SharedObject = "",
+                             AbstractInterpreter *AI = 0);
+
+  /// executeProgramWithCBE - Used to create reference output with the C
+  /// backend, if reference output is not provided.
+  std::string executeProgramWithCBE(std::string RequestedOutputFilename = "",
+                                    std::string Bytecode = "",
+                                    std::string SharedObject = "");
 
   /// 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.
   ///
-  bool diffProgram(const std::string &ReferenceOutputFile,
-                  const std::string &BytecodeFile = "",
+  bool diffProgram(const std::string &BytecodeFile = "",
+                   const std::string &SharedObject = "",
                    bool RemoveBytecode = false);
 };