1 //===- BugDriver.h - Top-Level BugPoint class -------------------*- C++ -*-===//
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.
7 //===----------------------------------------------------------------------===//
17 class AbstractInterpreter;
21 class ReduceMiscompilingPasses;
22 class ReduceMiscompilingFunctions;
23 class ReduceCrashingFunctions;
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
31 // FIXME: sort out public/private distinctions...
32 friend class DebugCrashes;
33 friend class ReduceMiscompilingPasses;
34 friend class ReduceMiscompilingFunctions;
35 friend class ReduceCrashingFunctions;
37 BugDriver(const char *toolname)
38 : ToolName(toolname), Program(0), Interpreter(0) {}
40 const std::string &getToolName() const { return ToolName; }
42 // Set up methods... these methods are used to copy information about the
43 // command line arguments into instance variables of BugDriver.
45 bool addSources(const std::vector<std::string> &FileNames);
47 void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); }
49 /// run - The top level method that is invoked after all of the instance
50 /// variables are set up from command line arguments.
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.
60 /// debugMiscompilation - This method is used when the passes selected are not
61 /// crashing, but the generated output is semantically different from the
63 bool debugMiscompilation();
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
71 bool debugPassMiscompilation(const PassInfo *ThePass,
72 const std::string &ReferenceOutput);
75 /// ParseInputFile - Given a bytecode or assembly input filename, parse and
76 /// return it, or return null if not possible.
78 Module *ParseInputFile(const std::string &InputFilename) const;
80 /// writeProgramToFile - This writes the current "Program" to the named
81 /// bytecode file. If an error occurs, true is returned.
83 bool writeProgramToFile(const std::string &Filename, Module *M = 0) const;
86 /// EmitProgressBytecode - This function is used to output the current Program
87 /// to a file named "bugpoing-ID.bc".
89 void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false);
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.
99 bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
100 std::string &OutputFilename, bool DeleteOutput = false,
101 bool Quiet = false) const;
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).
107 bool runPasses(const std::vector<const PassInfo*> &PassesToRun,
108 bool DeleteOutput = true) const {
109 std::string Filename;
110 return runPasses(PassesToRun, Filename, DeleteOutput);
113 /// runPass - Run only the specified pass on the program.
115 bool runPass(const PassInfo *P, bool DeleteOutput = true) const {
116 return runPasses(std::vector<const PassInfo*>(1, P), DeleteOutput);
119 /// extractFunctionFromModule - This method is used to extract the specified
120 /// (non-external) function from the current program, slim down the module,
121 /// and then return it. This does not modify Program at all, it modifies a
122 /// copy, which it returns.
124 Module *extractFunctionFromModule(Function *F) const;
126 /// deleteInstructionFromProgram - This method clones the current Program and
127 /// deletes the specified instruction from the cloned module. It then runs a
128 /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code
129 /// which depends on the value. The modified module is then returned.
131 Module *deleteInstructionFromProgram(Instruction *I, unsigned Simp) const;
133 /// performFinalCleanups - This method clones the current Program and performs
134 /// a series of cleanups intended to get rid of extra cruft on the module
135 /// before handing it to the user...
137 Module *performFinalCleanups() const;
139 /// initializeExecutionEnvironment - This method is used to set up the
140 /// environment for executing LLVM programs.
142 bool initializeExecutionEnvironment();
144 /// executeProgram - This method runs "Program", capturing the output of the
145 /// program to a file, returning the filename of the file. A recommended
146 /// filename may be optionally specified.
148 std::string executeProgram(std::string RequestedOutputFilename = "",
149 std::string Bytecode = "");
151 /// diffProgram - This method executes the specified module and diffs the
152 /// output against the file specified by ReferenceOutputFile. If the output
153 /// is different, true is returned.
155 bool diffProgram(const std::string &ReferenceOutputFile,
156 const std::string &BytecodeFile = "",
157 bool RemoveBytecode = false);
160 /// getPassesString - Turn a list of passes into a string which indicates the
161 /// command line options that must be passed to add the passes.
163 std::string getPassesString(const std::vector<const PassInfo*> &Passes);
165 // DeleteFunctionBody - "Remove" the function by deleting all of it's basic
166 // blocks, making it external.
168 void DeleteFunctionBody(Function *F);