BugDriver.h revision 44be25716628941b4cccccf56a28ee0ba2606850 
1//===- BugDriver.h - Top-Level BugPoint class -------------------*- C++ -*-===//
2//
3// This class contains all of the shared state and information that is used by
4// the BugPoint tool to track down errors in optimizations.  This class is the
5// main driver class that invokes all sub-functionality.
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef BUGDRIVER_H
10#define BUGDRIVER_H
11
12#include <vector>
13#include <string>
14class PassInfo;
15class Module;
16class Function;
17class AbstractInterpreter;
18class Instruction;
19
20class DebugCrashes;
21class ReduceMiscompilingPasses;
22class ReduceMiscompilingFunctions;
23class ReduceCrashingFunctions;
24
25class BugDriver {
26  const std::string ToolName;  // Name of bugpoint
27  Module *Program;             // The raw program, linked together
28  std::vector<const PassInfo*> PassesToRun;
29  AbstractInterpreter *Interpreter;   // How to run the program
30
31  // FIXME: sort out public/private distinctions...
32  friend class DebugCrashes;
33  friend class ReduceMiscompilingPasses;
34  friend class ReduceMiscompilingFunctions;
35  friend class ReduceCrashingFunctions;
36public:
37  BugDriver(const char *toolname)
38    : ToolName(toolname), Program(0), Interpreter(0) {}
39
40  const std::string &getToolName() const { return ToolName; }
41
42  // Set up methods... these methods are used to copy information about the
43  // command line arguments into instance variables of BugDriver.
44  //
45  bool addSources(const std::vector<std::string> &FileNames);
46  template<class It>
47  void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
48
49  /// run - The top level method that is invoked after all of the instance
50  /// variables are set up from command line arguments.
51  ///
52  bool run();
53
54  /// debugCrash - This method is called when some pass crashes on input.  It
55  /// attempts to prune down the testcase to something reasonable, and figure
56  /// out exactly which pass is crashing.
57  ///
58  bool debugCrash();
59
60  /// debugMiscompilation - This method is used when the passes selected are not
61  /// crashing, but the generated output is semantically different from the
62  /// input.
63  bool debugMiscompilation();
64
65  /// debugPassMiscompilation - This method is called when the specified pass
66  /// miscompiles Program as input.  It tries to reduce the testcase to
67  /// something that smaller that still miscompiles the program.
68  /// ReferenceOutput contains the filename of the file containing the output we
69  /// are to match.
70  ///
71  bool debugPassMiscompilation(const PassInfo *ThePass,
72			       const std::string &ReferenceOutput);
73
74private:
75  /// ParseInputFile - Given a bytecode or assembly input filename, parse and
76  /// return it, or return null if not possible.
77  ///
78  Module *ParseInputFile(const std::string &InputFilename) const;
79
80  /// writeProgramToFile - This writes the current "Program" to the named
81  /// bytecode file.  If an error occurs, true is returned.
82  ///
83  bool writeProgramToFile(const std::string &Filename, Module *M = 0) const;
84
85
86  /// EmitProgressBytecode - This function is used to output the current Program
87  /// to a file named "bugpoing-ID.bc".
88  ///
89  void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false);
90
91  /// runPasses - Run the specified passes on Program, outputting a bytecode
92  /// file and writting the filename into OutputFile if successful.  If the
93  /// optimizations fail for some reason (optimizer crashes), return true,
94  /// otherwise return false.  If DeleteOutput is set to true, the bytecode is
95  /// deleted on success, and the filename string is undefined.  This prints to
96  /// cout a single line message indicating whether compilation was successful
97  /// or failed, unless Quiet is set.
98  ///
99  bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
100                 std::string &OutputFilename, bool DeleteOutput = false,
101		 bool Quiet = false) const;
102
103  /// runPasses - Just like the method above, but this just returns true or
104  /// false indicating whether or not the optimizer crashed on the specified
105  /// input (true = crashed).
106  ///
107  bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
108                 bool DeleteOutput = true) const {
109    std::string Filename;
110    return runPasses(PassesToRun, Filename, DeleteOutput);
111  }
112
113  /// deleteInstructionFromProgram - This method clones the current Program and
114  /// deletes the specified instruction from the cloned module.  It then runs a
115  /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code
116  /// which depends on the value.  The modified module is then returned.
117  ///
118  Module *deleteInstructionFromProgram(Instruction *I, unsigned Simp) const;
119
120  /// performFinalCleanups - This method clones the current Program and performs
121  /// a series of cleanups intended to get rid of extra cruft on the module
122  /// before handing it to the user...
123  ///
124  Module *performFinalCleanups() const;
125
126  /// initializeExecutionEnvironment - This method is used to set up the
127  /// environment for executing LLVM programs.
128  ///
129  bool initializeExecutionEnvironment();
130
131  /// executeProgram - This method runs "Program", capturing the output of the
132  /// program to a file, returning the filename of the file.  A recommended
133  /// filename may be optionally specified.
134  ///
135  std::string executeProgram(std::string RequestedOutputFilename = "",
136			     std::string Bytecode = "");
137
138  /// diffProgram - This method executes the specified module and diffs the
139  /// output against the file specified by ReferenceOutputFile.  If the output
140  /// is different, true is returned.
141  ///
142  bool diffProgram(const std::string &ReferenceOutputFile,
143		   const std::string &BytecodeFile = "",
144                   bool RemoveBytecode = false);
145};
146
147/// getPassesString - Turn a list of passes into a string which indicates the
148/// command line options that must be passed to add the passes.
149///
150std::string getPassesString(const std::vector<const PassInfo*> &Passes);
151
152// DeleteFunctionBody - "Remove" the function by deleting all of it's basic
153// blocks, making it external.
154//
155void DeleteFunctionBody(Function *F);
156
157#endif
158