BugDriver.cpp revision 92bcb426c3e4503c99324afd4ed0a73521711a56
1//===- BugDriver.cpp - Top-Level BugPoint class implementation ------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// 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#include "BugDriver.h" 17#include "ToolRunner.h" 18#include "llvm/Linker.h" 19#include "llvm/Module.h" 20#include "llvm/Pass.h" 21#include "llvm/Assembly/Parser.h" 22#include "llvm/Bitcode/ReaderWriter.h" 23#include "llvm/Support/CommandLine.h" 24#include "llvm/Support/FileUtilities.h" 25#include "llvm/Support/MemoryBuffer.h" 26#include "llvm/Support/SourceMgr.h" 27#include "llvm/Support/raw_ostream.h" 28#include <iostream> 29#include <memory> 30using namespace llvm; 31 32// Anonymous namespace to define command line options for debugging. 33// 34namespace { 35 // Output - The user can specify a file containing the expected output of the 36 // program. If this filename is set, it is used as the reference diff source, 37 // otherwise the raw input run through an interpreter is used as the reference 38 // source. 39 // 40 cl::opt<std::string> 41 OutputFile("output", cl::desc("Specify a reference program output " 42 "(for miscompilation detection)")); 43} 44 45/// setNewProgram - If we reduce or update the program somehow, call this method 46/// to update bugdriver with it. This deletes the old module and sets the 47/// specified one as the current program. 48void BugDriver::setNewProgram(Module *M) { 49 delete Program; 50 Program = M; 51} 52 53 54/// getPassesString - Turn a list of passes into a string which indicates the 55/// command line options that must be passed to add the passes. 56/// 57std::string llvm::getPassesString(const std::vector<const PassInfo*> &Passes) { 58 std::string Result; 59 for (unsigned i = 0, e = Passes.size(); i != e; ++i) { 60 if (i) Result += " "; 61 Result += "-"; 62 Result += Passes[i]->getPassArgument(); 63 } 64 return Result; 65} 66 67BugDriver::BugDriver(const char *toolname, bool as_child, bool find_bugs, 68 unsigned timeout, unsigned memlimit, 69 LLVMContext& ctxt) 70 : Context(ctxt), ToolName(toolname), ReferenceOutputFile(OutputFile), 71 Program(0), Interpreter(0), SafeInterpreter(0), gcc(0), 72 run_as_child(as_child), run_find_bugs(find_bugs), Timeout(timeout), 73 MemoryLimit(memlimit) {} 74 75 76/// ParseInputFile - Given a bitcode or assembly input filename, parse and 77/// return it, or return null if not possible. 78/// 79Module *llvm::ParseInputFile(const std::string &Filename, 80 LLVMContext& Ctxt) { 81 std::auto_ptr<MemoryBuffer> Buffer(MemoryBuffer::getFileOrSTDIN(Filename)); 82 Module *Result = 0; 83 if (Buffer.get()) 84 Result = ParseBitcodeFile(Buffer.get(), Ctxt); 85 86 SMDiagnostic Err; 87 if (!Result && !(Result = ParseAssemblyFile(Filename, Err, Ctxt))) { 88 Err.Print("bugpoint", errs()); 89 Result = 0; 90 } 91 92 return Result; 93} 94 95// This method takes the specified list of LLVM input files, attempts to load 96// them, either as assembly or bitcode, then link them together. It returns 97// true on failure (if, for example, an input bitcode file could not be 98// parsed), and false on success. 99// 100bool BugDriver::addSources(const std::vector<std::string> &Filenames) { 101 assert(Program == 0 && "Cannot call addSources multiple times!"); 102 assert(!Filenames.empty() && "Must specify at least on input filename!"); 103 104 try { 105 // Load the first input file. 106 Program = ParseInputFile(Filenames[0], Context); 107 if (Program == 0) return true; 108 109 if (!run_as_child) 110 std::cout << "Read input file : '" << Filenames[0] << "'\n"; 111 112 for (unsigned i = 1, e = Filenames.size(); i != e; ++i) { 113 std::auto_ptr<Module> M(ParseInputFile(Filenames[i], Context)); 114 if (M.get() == 0) return true; 115 116 if (!run_as_child) 117 std::cout << "Linking in input file: '" << Filenames[i] << "'\n"; 118 std::string ErrorMessage; 119 if (Linker::LinkModules(Program, M.get(), &ErrorMessage)) { 120 std::cerr << ToolName << ": error linking in '" << Filenames[i] << "': " 121 << ErrorMessage << '\n'; 122 return true; 123 } 124 } 125 } catch (const std::string &Error) { 126 std::cerr << ToolName << ": error reading input '" << Error << "'\n"; 127 return true; 128 } 129 130 if (!run_as_child) 131 std::cout << "*** All input ok\n"; 132 133 // All input files read successfully! 134 return false; 135} 136 137 138 139/// run - The top level method that is invoked after all of the instance 140/// variables are set up from command line arguments. 141/// 142bool BugDriver::run() { 143 // The first thing to do is determine if we're running as a child. If we are, 144 // then what to do is very narrow. This form of invocation is only called 145 // from the runPasses method to actually run those passes in a child process. 146 if (run_as_child) { 147 // Execute the passes 148 return runPassesAsChild(PassesToRun); 149 } 150 151 if (run_find_bugs) { 152 // Rearrange the passes and apply them to the program. Repeat this process 153 // until the user kills the program or we find a bug. 154 return runManyPasses(PassesToRun); 155 } 156 157 // If we're not running as a child, the first thing that we must do is 158 // determine what the problem is. Does the optimization series crash the 159 // compiler, or does it produce illegal code? We make the top-level 160 // decision by trying to run all of the passes on the the input program, 161 // which should generate a bitcode file. If it does generate a bitcode 162 // file, then we know the compiler didn't crash, so try to diagnose a 163 // miscompilation. 164 if (!PassesToRun.empty()) { 165 std::cout << "Running selected passes on program to test for crash: "; 166 if (runPasses(PassesToRun)) 167 return debugOptimizerCrash(); 168 } 169 170 // Set up the execution environment, selecting a method to run LLVM bitcode. 171 if (initializeExecutionEnvironment()) return true; 172 173 // Test to see if we have a code generator crash. 174 std::cout << "Running the code generator to test for a crash: "; 175 try { 176 compileProgram(Program); 177 std::cout << '\n'; 178 } catch (ToolExecutionError &TEE) { 179 std::cout << TEE.what(); 180 return debugCodeGeneratorCrash(); 181 } 182 183 184 // Run the raw input to see where we are coming from. If a reference output 185 // was specified, make sure that the raw output matches it. If not, it's a 186 // problem in the front-end or the code generator. 187 // 188 bool CreatedOutput = false; 189 if (ReferenceOutputFile.empty()) { 190 std::cout << "Generating reference output from raw program: "; 191 if(!createReferenceFile(Program)){ 192 return debugCodeGeneratorCrash(); 193 } 194 CreatedOutput = true; 195 } 196 197 // Make sure the reference output file gets deleted on exit from this 198 // function, if appropriate. 199 sys::Path ROF(ReferenceOutputFile); 200 FileRemover RemoverInstance(ROF, CreatedOutput); 201 202 // Diff the output of the raw program against the reference output. If it 203 // matches, then we assume there is a miscompilation bug and try to 204 // diagnose it. 205 std::cout << "*** Checking the code generator...\n"; 206 try { 207 if (!diffProgram()) { 208 std::cout << "\n*** Debugging miscompilation!\n"; 209 return debugMiscompilation(); 210 } 211 } catch (ToolExecutionError &TEE) { 212 std::cerr << TEE.what(); 213 return debugCodeGeneratorCrash(); 214 } 215 216 std::cout << "\n*** Input program does not match reference diff!\n"; 217 std::cout << "Debugging code generator problem!\n"; 218 try { 219 return debugCodeGenerator(); 220 } catch (ToolExecutionError &TEE) { 221 std::cerr << TEE.what(); 222 return debugCodeGeneratorCrash(); 223 } 224} 225 226void llvm::PrintFunctionList(const std::vector<Function*> &Funcs) { 227 unsigned NumPrint = Funcs.size(); 228 if (NumPrint > 10) NumPrint = 10; 229 for (unsigned i = 0; i != NumPrint; ++i) 230 std::cout << " " << Funcs[i]->getName(); 231 if (NumPrint < Funcs.size()) 232 std::cout << "... <" << Funcs.size() << " total>"; 233 std::cout << std::flush; 234} 235 236void llvm::PrintGlobalVariableList(const std::vector<GlobalVariable*> &GVs) { 237 unsigned NumPrint = GVs.size(); 238 if (NumPrint > 10) NumPrint = 10; 239 for (unsigned i = 0; i != NumPrint; ++i) 240 std::cout << " " << GVs[i]->getName(); 241 if (NumPrint < GVs.size()) 242 std::cout << "... <" << GVs.size() << " total>"; 243 std::cout << std::flush; 244} 245