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