BugDriver.h revision c0431fe1ca52c5d159c604957f337aa3eb1ec3d3
1//===- BugDriver.h - Top-Level BugPoint class -------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This class contains all of the shared state and information that is used by 11// the BugPoint tool to track down errors in optimizations. This class is the 12// main driver class that invokes all sub-functionality. 13// 14//===----------------------------------------------------------------------===// 15 16#ifndef BUGDRIVER_H 17#define BUGDRIVER_H 18 19#include <vector> 20#include <string> 21 22namespace llvm { 23 24class PassInfo; 25class Module; 26class Function; 27class BasicBlock; 28class AbstractInterpreter; 29class Instruction; 30 31class DebugCrashes; 32 33class CBE; 34class GCC; 35 36extern bool DisableSimplifyCFG; 37 38/// BugpointIsInterrupted - Set to true when the user presses ctrl-c. 39/// 40extern bool BugpointIsInterrupted; 41 42class BugDriver { 43 const std::string ToolName; // Name of bugpoint 44 std::string ReferenceOutputFile; // Name of `good' output file 45 Module *Program; // The raw program, linked together 46 std::vector<const PassInfo*> PassesToRun; 47 AbstractInterpreter *Interpreter; // How to run the program 48 CBE *cbe; 49 GCC *gcc; 50 bool run_as_child; 51 bool run_find_bugs; 52 unsigned Timeout; 53 54 // FIXME: sort out public/private distinctions... 55 friend class ReducePassList; 56 friend class ReduceMisCodegenFunctions; 57 58public: 59 BugDriver(const char *toolname, bool as_child, bool find_bugs, 60 unsigned timeout); 61 62 const std::string &getToolName() const { return ToolName; } 63 64 // Set up methods... these methods are used to copy information about the 65 // command line arguments into instance variables of BugDriver. 66 // 67 bool addSources(const std::vector<std::string> &FileNames); 68 template<class It> 69 void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); } 70 void setPassesToRun(const std::vector<const PassInfo*> &PTR) { 71 PassesToRun = PTR; 72 } 73 const std::vector<const PassInfo*> &getPassesToRun() const { 74 return PassesToRun; 75 } 76 77 /// run - The top level method that is invoked after all of the instance 78 /// variables are set up from command line arguments. The \p as_child argument 79 /// indicates whether the driver is to run in parent mode or child mode. 80 /// 81 bool run(); 82 83 /// debugOptimizerCrash - This method is called when some optimizer pass 84 /// crashes on input. It attempts to prune down the testcase to something 85 /// reasonable, and figure out exactly which pass is crashing. 86 /// 87 bool debugOptimizerCrash(const std::string &ID = "passes"); 88 89 /// debugCodeGeneratorCrash - This method is called when the code generator 90 /// crashes on an input. It attempts to reduce the input as much as possible 91 /// while still causing the code generator to crash. 92 bool debugCodeGeneratorCrash(); 93 94 /// debugMiscompilation - This method is used when the passes selected are not 95 /// crashing, but the generated output is semantically different from the 96 /// input. 97 bool debugMiscompilation(); 98 99 /// debugPassMiscompilation - This method is called when the specified pass 100 /// miscompiles Program as input. It tries to reduce the testcase to 101 /// something that smaller that still miscompiles the program. 102 /// ReferenceOutput contains the filename of the file containing the output we 103 /// are to match. 104 /// 105 bool debugPassMiscompilation(const PassInfo *ThePass, 106 const std::string &ReferenceOutput); 107 108 /// compileSharedObject - This method creates a SharedObject from a given 109 /// BytecodeFile for debugging a code generator. 110 /// 111 std::string compileSharedObject(const std::string &BytecodeFile); 112 113 /// debugCodeGenerator - This method narrows down a module to a function or 114 /// set of functions, using the CBE as a ``safe'' code generator for other 115 /// functions that are not under consideration. 116 bool debugCodeGenerator(); 117 118 /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT 119 /// 120 bool isExecutingJIT(); 121 122 /// runPasses - Run all of the passes in the "PassesToRun" list, discard the 123 /// output, and return true if any of the passes crashed. 124 bool runPasses(Module *M = 0) { 125 if (M == 0) M = Program; 126 std::swap(M, Program); 127 bool Result = runPasses(PassesToRun); 128 std::swap(M, Program); 129 return Result; 130 } 131 132 Module *getProgram() const { return Program; } 133 134 /// swapProgramIn - Set the current module to the specified module, returning 135 /// the old one. 136 Module *swapProgramIn(Module *M) { 137 Module *OldProgram = Program; 138 Program = M; 139 return OldProgram; 140 } 141 142 AbstractInterpreter *switchToCBE() { 143 AbstractInterpreter *Old = Interpreter; 144 Interpreter = (AbstractInterpreter*)cbe; 145 return Old; 146 } 147 148 void switchToInterpreter(AbstractInterpreter *AI) { 149 Interpreter = AI; 150 } 151 152 /// setNewProgram - If we reduce or update the program somehow, call this 153 /// method to update bugdriver with it. This deletes the old module and sets 154 /// the specified one as the current program. 155 void setNewProgram(Module *M); 156 157 /// compileProgram - Try to compile the specified module, throwing an 158 /// exception if an error occurs, or returning normally if not. This is used 159 /// for code generation crash testing. 160 /// 161 void compileProgram(Module *M); 162 163 /// executeProgram - This method runs "Program", capturing the output of the 164 /// program to a file, returning the filename of the file. A recommended 165 /// filename may be optionally specified. If there is a problem with the code 166 /// generator (e.g., llc crashes), this will throw an exception. 167 /// 168 std::string executeProgram(std::string RequestedOutputFilename = "", 169 std::string Bytecode = "", 170 const std::string &SharedObjects = "", 171 AbstractInterpreter *AI = 0, 172 bool *ProgramExitedNonzero = 0); 173 174 /// executeProgramWithCBE - Used to create reference output with the C 175 /// backend, if reference output is not provided. If there is a problem with 176 /// the code generator (e.g., llc crashes), this will throw an exception. 177 /// 178 std::string executeProgramWithCBE(std::string OutputFile = ""); 179 180 /// createReferenceFile - calls compileProgram and then records the output 181 /// into ReferenceOutputFile. Returns true if reference file created, false 182 /// otherwise. Note: initializeExecutionEnvironment should be called BEFORE 183 /// this function. 184 /// 185 bool createReferenceFile(Module *M, const std::string &Filename 186 = "bugpoint.reference.out"); 187 188 /// diffProgram - This method executes the specified module and diffs the 189 /// output against the file specified by ReferenceOutputFile. If the output 190 /// is different, true is returned. If there is a problem with the code 191 /// generator (e.g., llc crashes), this will throw an exception. 192 /// 193 bool diffProgram(const std::string &BytecodeFile = "", 194 const std::string &SharedObj = "", 195 bool RemoveBytecode = false); 196 197 /// EmitProgressBytecode - This function is used to output the current Program 198 /// to a file named "bugpoint-ID.bc". 199 /// 200 void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false); 201 202 /// deleteInstructionFromProgram - This method clones the current Program and 203 /// deletes the specified instruction from the cloned module. It then runs a 204 /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code 205 /// which depends on the value. The modified module is then returned. 206 /// 207 Module *deleteInstructionFromProgram(const Instruction *I, unsigned Simp) 208 const; 209 210 /// performFinalCleanups - This method clones the current Program and performs 211 /// a series of cleanups intended to get rid of extra cruft on the module. If 212 /// the MayModifySemantics argument is true, then the cleanups is allowed to 213 /// modify how the code behaves. 214 /// 215 Module *performFinalCleanups(Module *M, bool MayModifySemantics = false); 216 217 /// ExtractLoop - Given a module, extract up to one loop from it into a new 218 /// function. This returns null if there are no extractable loops in the 219 /// program or if the loop extractor crashes. 220 Module *ExtractLoop(Module *M); 221 222 /// ExtractMappedBlocksFromModule - Extract all but the specified basic blocks 223 /// into their own functions. The only detail is that M is actually a module 224 /// cloned from the one the BBs are in, so some mapping needs to be performed. 225 /// If this operation fails for some reason (ie the implementation is buggy), 226 /// this function should return null, otherwise it returns a new Module. 227 Module *ExtractMappedBlocksFromModule(const std::vector<BasicBlock*> &BBs, 228 Module *M); 229 230 /// runPassesOn - Carefully run the specified set of pass on the specified 231 /// module, returning the transformed module on success, or a null pointer on 232 /// failure. If AutoDebugCrashes is set to true, then bugpoint will 233 /// automatically attempt to track down a crashing pass if one exists, and 234 /// this method will never return null. 235 Module *runPassesOn(Module *M, const std::vector<const PassInfo*> &Passes, 236 bool AutoDebugCrashes = false); 237 238 /// runPasses - Run the specified passes on Program, outputting a bytecode 239 /// file and writting the filename into OutputFile if successful. If the 240 /// optimizations fail for some reason (optimizer crashes), return true, 241 /// otherwise return false. If DeleteOutput is set to true, the bytecode is 242 /// deleted on success, and the filename string is undefined. This prints to 243 /// cout a single line message indicating whether compilation was successful 244 /// or failed, unless Quiet is set. 245 /// 246 bool runPasses(const std::vector<const PassInfo*> &PassesToRun, 247 std::string &OutputFilename, bool DeleteOutput = false, 248 bool Quiet = false) const; 249 250 /// runManyPasses - Take the specified pass list and create different 251 /// combinations of passes to compile the program with. Compile the program with 252 /// each set and mark test to see if it compiled correctly. If the passes 253 /// compiled correctly output nothing and rearrange the passes into a new order. 254 /// If the passes did not compile correctly, output the command required to 255 /// recreate the failure. This returns true if a compiler error is found. 256 /// 257 bool runManyPasses(const std::vector<const PassInfo*> &AllPasses); 258 259 /// writeProgramToFile - This writes the current "Program" to the named 260 /// bytecode file. If an error occurs, true is returned. 261 /// 262 bool writeProgramToFile(const std::string &Filename, Module *M = 0) const; 263 264private: 265 /// runPasses - Just like the method above, but this just returns true or 266 /// false indicating whether or not the optimizer crashed on the specified 267 /// input (true = crashed). 268 /// 269 bool runPasses(const std::vector<const PassInfo*> &PassesToRun, 270 bool DeleteOutput = true) const { 271 std::string Filename; 272 return runPasses(PassesToRun, Filename, DeleteOutput); 273 } 274 275 /// runAsChild - The actual "runPasses" guts that runs in a child process. 276 int runPassesAsChild(const std::vector<const PassInfo*> &PassesToRun); 277 278 /// initializeExecutionEnvironment - This method is used to set up the 279 /// environment for executing LLVM programs. 280 /// 281 bool initializeExecutionEnvironment(); 282}; 283 284/// ParseInputFile - Given a bytecode or assembly input filename, parse and 285/// return it, or return null if not possible. 286/// 287Module *ParseInputFile(const std::string &InputFilename); 288 289 290/// getPassesString - Turn a list of passes into a string which indicates the 291/// command line options that must be passed to add the passes. 292/// 293std::string getPassesString(const std::vector<const PassInfo*> &Passes); 294 295/// PrintFunctionList - prints out list of problematic functions 296/// 297void PrintFunctionList(const std::vector<Function*> &Funcs); 298 299// DeleteFunctionBody - "Remove" the function by deleting all of it's basic 300// blocks, making it external. 301// 302void DeleteFunctionBody(Function *F); 303 304/// SplitFunctionsOutOfModule - Given a module and a list of functions in the 305/// module, split the functions OUT of the specified module, and place them in 306/// the new module. 307Module *SplitFunctionsOutOfModule(Module *M, const std::vector<Function*> &F); 308 309} // End llvm namespace 310 311#endif 312