Print the top 20 most frequently executed blocks. Fix sort predicate problem

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

diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 263a2c9ba7a1d6357de9edab4a8532bdb3f581c5..acd579914d4e0da913bd1ed905fdd3e0d49aaf52 100644 (file)
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -1,4 +1,11 @@
 //===- BugDriver.h - Top-Level BugPoint class -------------------*- 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 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
@@ -11,6 +18,7 @@
 
 #include <vector>
 #include <string>
+
 class PassInfo;
 class Module;
 class Function;
@@ -21,21 +29,32 @@ class DebugCrashes;
 class ReduceMiscompilingPasses;
 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; }
 
@@ -45,6 +64,9 @@ public:
   bool addSources(const std::vector<std::string> &FileNames);
   template<class It>
   void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
+  void setPassesToRun(const std::vector<const PassInfo*> &PTR) {
+    PassesToRun = PTR;
+  }
 
   /// run - The top level method that is invoked after all of the instance
   /// variables are set up from command line arguments.
@@ -71,6 +93,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.
+  ///
+  std::string compileSharedObject(const std::string &BytecodeFile);
+
+  /// 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.
@@ -110,18 +146,9 @@ private:
     return runPasses(PassesToRun, Filename, DeleteOutput);
   }
 
-  /// runPass - Run only the specified pass on the program.
+  /// PrintFunctionList - prints out list of problematic functions
   ///
-  bool runPass(const PassInfo *P, bool DeleteOutput = true) const {
-    return runPasses(std::vector<const PassInfo*>(1, P), DeleteOutput);
-  }
-  
-  /// extractFunctionFromModule - This method is used to extract the specified
-  /// (non-external) function from the current program, slim down the module,
-  /// and then return it.  This does not modify Program at all, it modifies a
-  /// copy, which it returns.
-  ///
-  Module *extractFunctionFromModule(Function *F) const;
+  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
@@ -132,9 +159,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.
@@ -146,14 +174,26 @@ private:
   /// filename may be optionally specified.
   ///
   std::string executeProgram(std::string RequestedOutputFilename = "",
-                            std::string Bytecode = "");
+                             std::string Bytecode = "",
+                             const std::string &SharedObjects = "",
+                             AbstractInterpreter *AI = 0);
+
+  /// executeProgramWithCBE - Used to create reference output with the C
+  /// backend, if reference output is not provided.
+  ///
+  std::string executeProgramWithCBE(std::string OutputFile = "",
+                                    std::string BytecodeFile = "",
+                                    const std::string &SharedObj = "") {
+    return executeProgram(OutputFile, BytecodeFile, SharedObj,
+                          (AbstractInterpreter*)cbe);
+  }
 
   /// 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 &SharedObj = "",
                    bool RemoveBytecode = false);
 };