BugDriver.h revision 218e26ef3583cc3270f5f2a2b9cb1025e5b05ebe 
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;
18
19class BugDriver {
20  const std::string ToolName;  // Name of bugpoint
21  Module *Program;             // The raw program, linked together
22  std::vector<const PassInfo*> PassesToRun;
23  AbstractInterpreter *Interpreter;   // How to run the program
24public:
25  BugDriver(const char *toolname)
26    : ToolName(toolname), Program(0), Interpreter(0) {}
27
28  const std::string &getToolName() const { return ToolName; }
29
30  // Set up methods... these methods are used to copy information about the
31  // command line arguments into instance variables of BugDriver.
32  //
33  bool addSources(const std::vector<std::string> &FileNames);
34  template<class It>
35  void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
36
37  /// run - The top level method that is invoked after all of the instance
38  /// variables are set up from command line arguments.
39  ///
40  bool run();
41
42  /// debugCrash - This method is called when some pass crashes on input.  It
43  /// attempts to prune down the testcase to something reasonable, and figure
44  /// out exactly which pass is crashing.
45  ///
46  bool debugCrash();
47
48  /// debugPassCrash - This method is called when the specified pass crashes on
49  /// Program as input.  It tries to reduce the testcase to something that still
50  /// crashes, but it smaller.
51  ///
52  bool debugPassCrash(const PassInfo *PI);
53
54  /// debugMiscompilation - This method is used when the passes selected are not
55  /// crashing, but the generated output is semantically different from the
56  /// input.
57  bool debugMiscompilation();
58
59  /// debugPassMiscompilation - This method is called when the specified pass
60  /// miscompiles Program as input.  It tries to reduce the testcase to
61  /// something that smaller that still miscompiles the program.
62  /// ReferenceOutput contains the filename of the file containing the output we
63  /// are to match.
64  ///
65  bool debugPassMiscompilation(const PassInfo *ThePass,
66			       const std::string &ReferenceOutput);
67
68private:
69  /// ParseInputFile - Given a bytecode or assembly input filename, parse and
70  /// return it, or return null if not possible.
71  ///
72  Module *ParseInputFile(const std::string &InputFilename) const;
73
74  /// writeProgramToFile - This writes the current "Program" to the named
75  /// bytecode file.  If an error occurs, true is returned.
76  ///
77  bool writeProgramToFile(const std::string &Filename, Module *M = 0) const;
78
79
80  /// EmitProgressBytecode - This function is used to output the current Program
81  /// to a file named "bugpoing-ID.bc".
82  ///
83  void EmitProgressBytecode(const PassInfo *Pass, const std::string &ID);
84
85  /// runPasses - Run the specified passes on Program, outputting a bytecode
86  /// file and writting the filename into OutputFile if successful.  If the
87  /// optimizations fail for some reason (optimizer crashes), return true,
88  /// otherwise return false.  If DeleteOutput is set to true, the bytecode is
89  /// deleted on success, and the filename string is undefined.  This prints to
90  /// cout a single line message indicating whether compilation was successful
91  /// or failed, unless Quiet is set.
92  ///
93  bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
94                 std::string &OutputFilename, bool DeleteOutput = false,
95		 bool Quiet = false) const;
96
97  /// runPasses - Just like the method above, but this just returns true or
98  /// false indicating whether or not the optimizer crashed on the specified
99  /// input (true = crashed).
100  ///
101  bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
102                 bool DeleteOutput = true) const {
103    std::string Filename;
104    return runPasses(PassesToRun, Filename, DeleteOutput);
105  }
106
107  /// runPass - Run only the specified pass on the program.
108  ///
109  bool runPass(const PassInfo *P, bool DeleteOutput = true) const {
110    return runPasses(std::vector<const PassInfo*>(1, P), DeleteOutput);
111  }
112
113  /// extractFunctionFromModule - This method is used to extract the specified
114  /// (non-external) function from the current program, slim down the module,
115  /// and then return it.  This does not modify Program at all, it modifies a
116  /// copy, which it returns.
117  ///
118  Module *extractFunctionFromModule(Function *F) const;
119
120  /// initializeExecutionEnvironment - This method is used to set up the
121  /// environment for executing LLVM programs.
122  ///
123  bool initializeExecutionEnvironment();
124
125  /// executeProgram - This method runs "Program", capturing the output of the
126  /// program to a file, returning the filename of the file.  A recommended
127  /// filename may be optionally specified.
128  ///
129  std::string executeProgram(std::string RequestedOutputFilename = "",
130			     std::string Bytecode = "");
131
132  /// diffProgram - This method executes the specified module and diffs the
133  /// output against the file specified by ReferenceOutputFile.  If the output
134  /// is different, true is returned.
135  ///
136  bool diffProgram(const std::string &ReferenceOutputFile,
137		   const std::string &BytecodeFile = "");
138};
139
140#endif
141