Teach bugpoint to kill optimization passes that run over the timeout limit,

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

diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index b1cc3e830ba155f59e975f61e35316bd4b691c8c..ec687b3c7bc0efb343927e1ae27a02fa95e5c7a7 100644 (file)
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -1,10 +1,10 @@
 //===- 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
@@ -24,6 +24,7 @@ namespace llvm {
 class PassInfo;
 class Module;
 class Function;
+class BasicBlock;
 class AbstractInterpreter;
 class Instruction;
 
@@ -34,6 +35,10 @@ class GCC;
 
 extern bool DisableSimplifyCFG;
 
+/// BugpointIsInterrupted - Set to true when the user presses ctrl-c.
+///
+extern bool BugpointIsInterrupted;
+
 class BugDriver {
   const std::string ToolName;  // Name of bugpoint
   std::string ReferenceOutputFile; // Name of `good' output file
@@ -42,13 +47,15 @@ class BugDriver {
   AbstractInterpreter *Interpreter;   // How to run the program
   CBE *cbe;
   GCC *gcc;
+  bool run_as_child;
+  unsigned Timeout;
 
   // FIXME: sort out public/private distinctions...
   friend class ReducePassList;
   friend class ReduceMisCodegenFunctions;
 
 public:
-  BugDriver(const char *toolname);
+  BugDriver(const char *toolname, bool as_child, unsigned timeout);
 
   const std::string &getToolName() const { return ToolName; }
 
@@ -66,7 +73,8 @@ public:
   }
 
   /// run - The top level method that is invoked after all of the instance
-  /// variables are set up from command line arguments.
+  /// variables are set up from command line arguments. The \p as_child argument
+  /// indicates whether the driver is to run in parent mode or child mode.
   ///
   bool run();
 
@@ -75,7 +83,7 @@ public:
   /// reasonable, and figure out exactly which pass is crashing.
   ///
   bool debugOptimizerCrash();
-  
+
   /// debugCodeGeneratorCrash - This method is called when the code generator
   /// crashes on an input.  It attempts to reduce the input as much as possible
   /// while still causing the code generator to crash.
@@ -93,7 +101,7 @@ public:
   /// are to match.
   ///
   bool debugPassMiscompilation(const PassInfo *ThePass,
-                              const std::string &ReferenceOutput);
+                               const std::string &ReferenceOutput);
 
   /// compileSharedObject - This method creates a SharedObject from a given
   /// BytecodeFile for debugging a code generator.
@@ -129,6 +137,16 @@ public:
     return OldProgram;
   }
 
+  AbstractInterpreter *switchToCBE() {
+    AbstractInterpreter *Old = Interpreter;
+    Interpreter = (AbstractInterpreter*)cbe;
+    return Old;
+  }
+
+  void switchToInterpreter(AbstractInterpreter *AI) {
+    Interpreter = AI;
+  }
+
   /// setNewProgram - If we reduce or update the program somehow, call this
   /// method to update bugdriver with it.  This deletes the old module and sets
   /// the specified one as the current program.
@@ -190,10 +208,21 @@ public:
   /// program or if the loop extractor crashes.
   Module *ExtractLoop(Module *M);
 
+  /// ExtractMappedBlocksFromModule - Extract all but the specified basic blocks
+  /// into their own functions.  The only detail is that M is actually a module
+  /// cloned from the one the BBs are in, so some mapping needs to be performed.
+  /// If this operation fails for some reason (ie the implementation is buggy),
+  /// this function should return null, otherwise it returns a new Module.
+  Module *ExtractMappedBlocksFromModule(const std::vector<BasicBlock*> &BBs,
+                                        Module *M);
+
   /// runPassesOn - Carefully run the specified set of pass on the specified
   /// module, returning the transformed module on success, or a null pointer on
-  /// failure.
-  Module *runPassesOn(Module *M, const std::vector<const PassInfo*> &Passes);
+  /// failure.  If AutoDebugCrashes is set to true, then bugpoint will
+  /// automatically attempt to track down a crashing pass if one exists, and
+  /// this method will never return null.
+  Module *runPassesOn(Module *M, const std::vector<const PassInfo*> &Passes,
+                      bool AutoDebugCrashes = false);
 
   /// runPasses - Run the specified passes on Program, outputting a bytecode
   /// file and writting the filename into OutputFile if successful.  If the
@@ -205,13 +234,14 @@ public:
   ///
   bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
                  std::string &OutputFilename, bool DeleteOutput = false,
-                bool Quiet = false) const;
-private:
+                 bool Quiet = false) const;
+
   /// writeProgramToFile - This writes the current "Program" to the named
   /// bytecode file.  If an error occurs, true is returned.
   ///
   bool writeProgramToFile(const std::string &Filename, Module *M = 0) const;
 
+private:
   /// runPasses - Just like the method above, but this just returns true or
   /// false indicating whether or not the optimizer crashed on the specified
   /// input (true = crashed).
@@ -222,6 +252,9 @@ private:
     return runPasses(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.
   ///