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