BugDriver.h revision 9c6cfe1bffd37f29a265457b7515839c445b3e6a
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> 14 15class PassInfo; 16class Module; 17class Function; 18class AbstractInterpreter; 19class Instruction; 20 21class DebugCrashes; 22class ReduceMiscompilingPasses; 23class ReduceMiscompilingFunctions; 24class ReduceCrashingFunctions; 25class ReduceCrashingBlocks; 26 27class CBE; 28class GCC; 29 30extern bool DisableSimplifyCFG; 31 32class BugDriver { 33 const std::string ToolName; // Name of bugpoint 34 std::string ReferenceOutputFile; // Name of `good' output file 35 Module *Program; // The raw program, linked together 36 std::vector<const PassInfo*> PassesToRun; 37 AbstractInterpreter *Interpreter; // How to run the program 38 CBE *cbe; 39 GCC *gcc; 40 41 // FIXME: sort out public/private distinctions... 42 friend class DebugCrashes; 43 friend class ReduceMiscompilingPasses; 44 friend class ReduceMiscompilingFunctions; 45 friend class ReduceMisCodegenFunctions; 46 friend class ReduceCrashingFunctions; 47 friend class ReduceCrashingBlocks; 48 49public: 50 BugDriver(const char *toolname); 51 52 const std::string &getToolName() const { return ToolName; } 53 54 // Set up methods... these methods are used to copy information about the 55 // command line arguments into instance variables of BugDriver. 56 // 57 bool addSources(const std::vector<std::string> &FileNames); 58 template<class It> 59 void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); } 60 void setPassesToRun(const std::vector<const PassInfo*> &PTR) { 61 PassesToRun = PTR; 62 } 63 64 /// run - The top level method that is invoked after all of the instance 65 /// variables are set up from command line arguments. 66 /// 67 bool run(); 68 69 /// debugCrash - This method is called when some pass crashes on input. It 70 /// attempts to prune down the testcase to something reasonable, and figure 71 /// out exactly which pass is crashing. 72 /// 73 bool debugCrash(); 74 75 /// debugMiscompilation - This method is used when the passes selected are not 76 /// crashing, but the generated output is semantically different from the 77 /// input. 78 bool debugMiscompilation(); 79 80 /// debugPassMiscompilation - This method is called when the specified pass 81 /// miscompiles Program as input. It tries to reduce the testcase to 82 /// something that smaller that still miscompiles the program. 83 /// ReferenceOutput contains the filename of the file containing the output we 84 /// are to match. 85 /// 86 bool debugPassMiscompilation(const PassInfo *ThePass, 87 const std::string &ReferenceOutput); 88 89 /// compileSharedObject - This method creates a SharedObject from a given 90 /// BytecodeFile for debugging a code generator. 91 /// 92 std::string compileSharedObject(const std::string &BytecodeFile); 93 94 /// debugCodeGenerator - This method narrows down a module to a function or 95 /// set of functions, using the CBE as a ``safe'' code generator for other 96 /// functions that are not under consideration. 97 bool debugCodeGenerator(); 98 99 /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT 100 /// 101 bool isExecutingJIT(); 102 103private: 104 /// ParseInputFile - Given a bytecode or assembly input filename, parse and 105 /// return it, or return null if not possible. 106 /// 107 Module *ParseInputFile(const std::string &InputFilename) const; 108 109 /// writeProgramToFile - This writes the current "Program" to the named 110 /// bytecode file. If an error occurs, true is returned. 111 /// 112 bool writeProgramToFile(const std::string &Filename, Module *M = 0) const; 113 114 115 /// EmitProgressBytecode - This function is used to output the current Program 116 /// to a file named "bugpoing-ID.bc". 117 /// 118 void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false); 119 120 /// runPasses - Run the specified passes on Program, outputting a bytecode 121 /// file and writting the filename into OutputFile if successful. If the 122 /// optimizations fail for some reason (optimizer crashes), return true, 123 /// otherwise return false. If DeleteOutput is set to true, the bytecode is 124 /// deleted on success, and the filename string is undefined. This prints to 125 /// cout a single line message indicating whether compilation was successful 126 /// or failed, unless Quiet is set. 127 /// 128 bool runPasses(const std::vector<const PassInfo*> &PassesToRun, 129 std::string &OutputFilename, bool DeleteOutput = false, 130 bool Quiet = false) const; 131 132 /// runPasses - Just like the method above, but this just returns true or 133 /// false indicating whether or not the optimizer crashed on the specified 134 /// input (true = crashed). 135 /// 136 bool runPasses(const std::vector<const PassInfo*> &PassesToRun, 137 bool DeleteOutput = true) const { 138 std::string Filename; 139 return runPasses(PassesToRun, Filename, DeleteOutput); 140 } 141 142 /// PrintFunctionList - prints out list of problematic functions 143 /// 144 static void PrintFunctionList(const std::vector<Function*> &Funcs); 145 146 /// deleteInstructionFromProgram - This method clones the current Program and 147 /// deletes the specified instruction from the cloned module. It then runs a 148 /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code 149 /// which depends on the value. The modified module is then returned. 150 /// 151 Module *deleteInstructionFromProgram(Instruction *I, unsigned Simp) const; 152 153 /// performFinalCleanups - This method clones the current Program and performs 154 /// a series of cleanups intended to get rid of extra cruft on the module 155 /// before handing it to the user... if the module parameter is specified, it 156 /// operates directly on the specified Module, modifying it in place. 157 /// 158 Module *performFinalCleanups(Module *M = 0) const; 159 160 /// initializeExecutionEnvironment - This method is used to set up the 161 /// environment for executing LLVM programs. 162 /// 163 bool initializeExecutionEnvironment(); 164 165 /// executeProgram - This method runs "Program", capturing the output of the 166 /// program to a file, returning the filename of the file. A recommended 167 /// filename may be optionally specified. 168 /// 169 std::string executeProgram(std::string RequestedOutputFilename = "", 170 std::string Bytecode = "", 171 const std::string &SharedObjects = "", 172 AbstractInterpreter *AI = 0); 173 174 /// executeProgramWithCBE - Used to create reference output with the C 175 /// backend, if reference output is not provided. 176 /// 177 std::string executeProgramWithCBE(std::string OutputFile = "", 178 std::string BytecodeFile = "", 179 const std::string &SharedObj = "") { 180 return executeProgram(OutputFile, BytecodeFile, SharedObj, 181 (AbstractInterpreter*)cbe); 182 } 183 184 /// diffProgram - This method executes the specified module and diffs the 185 /// output against the file specified by ReferenceOutputFile. If the output 186 /// is different, true is returned. 187 /// 188 bool diffProgram(const std::string &BytecodeFile = "", 189 const std::string &SharedObj = "", 190 bool RemoveBytecode = false); 191}; 192 193/// getPassesString - Turn a list of passes into a string which indicates the 194/// command line options that must be passed to add the passes. 195/// 196std::string getPassesString(const std::vector<const PassInfo*> &Passes); 197 198// DeleteFunctionBody - "Remove" the function by deleting all of it's basic 199// blocks, making it external. 200// 201void DeleteFunctionBody(Function *F); 202 203#endif 204