blob: 19f9685677c99eb60144bf84ddf0ab829c7f5f76 [file] [log] [blame]
Chris Lattner73a6bdd2002-11-20 22:28:10 +00001//===- BugDriver.cpp - Top-Level BugPoint class implementation ------------===//
Misha Brukman650ba8e2005-04-22 00:00:37 +00002//
John Criswell09344dc2003-10-20 17:47:21 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattner345353d2007-12-29 20:44:31 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukman650ba8e2005-04-22 00:00:37 +00007//
John Criswell09344dc2003-10-20 17:47:21 +00008//===----------------------------------------------------------------------===//
Chris Lattner73a6bdd2002-11-20 22:28:10 +00009//
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"
Chris Lattnerffac2862006-06-06 22:30:59 +000017#include "ToolRunner.h"
Reid Spencer16c3bb32004-11-14 23:00:08 +000018#include "llvm/Linker.h"
Chris Lattner73a6bdd2002-11-20 22:28:10 +000019#include "llvm/Module.h"
Chris Lattner73a6bdd2002-11-20 22:28:10 +000020#include "llvm/Pass.h"
Misha Brukman0c2305b2003-08-07 21:19:30 +000021#include "llvm/Assembly/Parser.h"
Chris Lattnerf6dd4d72007-05-06 05:47:06 +000022#include "llvm/Bitcode/ReaderWriter.h"
Reid Spencer7c16caa2004-09-01 22:55:40 +000023#include "llvm/Support/CommandLine.h"
24#include "llvm/Support/FileUtilities.h"
Chris Lattnerf6dd4d72007-05-06 05:47:06 +000025#include "llvm/Support/MemoryBuffer.h"
Reid Spencerf0ebb252004-07-04 12:20:55 +000026#include <iostream>
Chris Lattner73a6bdd2002-11-20 22:28:10 +000027#include <memory>
Brian Gaeke960707c2003-11-11 22:41:34 +000028using namespace llvm;
29
Misha Brukmand792c9b2003-07-24 18:17:43 +000030// Anonymous namespace to define command line options for debugging.
31//
32namespace {
33 // Output - The user can specify a file containing the expected output of the
34 // program. If this filename is set, it is used as the reference diff source,
35 // otherwise the raw input run through an interpreter is used as the reference
36 // source.
37 //
Misha Brukman650ba8e2005-04-22 00:00:37 +000038 cl::opt<std::string>
Misha Brukmand792c9b2003-07-24 18:17:43 +000039 OutputFile("output", cl::desc("Specify a reference program output "
40 "(for miscompilation detection)"));
Misha Brukmand792c9b2003-07-24 18:17:43 +000041}
42
Chris Lattner327019b2004-02-18 21:24:48 +000043/// setNewProgram - If we reduce or update the program somehow, call this method
44/// to update bugdriver with it. This deletes the old module and sets the
45/// specified one as the current program.
46void BugDriver::setNewProgram(Module *M) {
47 delete Program;
48 Program = M;
49}
50
51
Chris Lattner16a41312003-04-24 17:02:17 +000052/// getPassesString - Turn a list of passes into a string which indicates the
53/// command line options that must be passed to add the passes.
54///
Chris Lattner2f1aa112004-01-14 03:38:37 +000055std::string llvm::getPassesString(const std::vector<const PassInfo*> &Passes) {
Chris Lattner16a41312003-04-24 17:02:17 +000056 std::string Result;
57 for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
58 if (i) Result += " ";
59 Result += "-";
60 Result += Passes[i]->getPassArgument();
61 }
62 return Result;
63}
64
Patrick Jenkinsc46c0382006-08-15 16:40:49 +000065BugDriver::BugDriver(const char *toolname, bool as_child, bool find_bugs,
Anton Korobeynikovd01defe2007-02-16 19:11:07 +000066 unsigned timeout, unsigned memlimit)
Misha Brukmand792c9b2003-07-24 18:17:43 +000067 : ToolName(toolname), ReferenceOutputFile(OutputFile),
Dan Gohman414cf502008-12-08 04:02:47 +000068 Program(0), Interpreter(0), SafeInterpreter(0), gcc(0),
69 run_as_child(as_child),
Anton Korobeynikovd01defe2007-02-16 19:11:07 +000070 run_find_bugs(find_bugs), Timeout(timeout), MemoryLimit(memlimit) {}
Misha Brukmand792c9b2003-07-24 18:17:43 +000071
72
Gabor Greif0e535c3c2007-07-04 21:55:50 +000073/// ParseInputFile - Given a bitcode or assembly input filename, parse and
Chris Lattner73a6bdd2002-11-20 22:28:10 +000074/// return it, or return null if not possible.
75///
Chris Lattner9e9a34c2007-05-06 23:45:49 +000076Module *llvm::ParseInputFile(const std::string &Filename) {
77 std::auto_ptr<MemoryBuffer> Buffer(MemoryBuffer::getFileOrSTDIN(Filename));
Chris Lattnerf5599ef2007-05-06 09:32:02 +000078 Module *Result = 0;
79 if (Buffer.get())
80 Result = ParseBitcodeFile(Buffer.get());
Chris Lattnerf6dd4d72007-05-06 05:47:06 +000081
Chris Lattnerf5599ef2007-05-06 09:32:02 +000082 ParseError Err;
Chris Lattner9e9a34c2007-05-06 23:45:49 +000083 if (!Result && !(Result = ParseAssemblyFile(Filename, &Err))) {
Reid Spencer713eedc2006-08-18 08:43:06 +000084 std::cerr << "bugpoint: " << Err.getMessage() << "\n";
Chris Lattner73a6bdd2002-11-20 22:28:10 +000085 Result = 0;
86 }
Chris Lattner9e9a34c2007-05-06 23:45:49 +000087
Chris Lattner73a6bdd2002-11-20 22:28:10 +000088 return Result;
89}
90
91// This method takes the specified list of LLVM input files, attempts to load
Gabor Greif0e535c3c2007-07-04 21:55:50 +000092// them, either as assembly or bitcode, then link them together. It returns
93// true on failure (if, for example, an input bitcode file could not be
Brian Gaeke61a05da2003-05-23 05:34:32 +000094// parsed), and false on success.
Chris Lattner73a6bdd2002-11-20 22:28:10 +000095//
96bool BugDriver::addSources(const std::vector<std::string> &Filenames) {
97 assert(Program == 0 && "Cannot call addSources multiple times!");
98 assert(!Filenames.empty() && "Must specify at least on input filename!");
99
Chris Lattner2bd9d8e2006-05-14 19:15:56 +0000100 try {
101 // Load the first input file.
102 Program = ParseInputFile(Filenames[0]);
103 if (Program == 0) return true;
Chris Lattner9e9a34c2007-05-06 23:45:49 +0000104
Reid Spencer842118c2005-12-22 20:02:55 +0000105 if (!run_as_child)
Chris Lattner2bd9d8e2006-05-14 19:15:56 +0000106 std::cout << "Read input file : '" << Filenames[0] << "'\n";
107
108 for (unsigned i = 1, e = Filenames.size(); i != e; ++i) {
109 std::auto_ptr<Module> M(ParseInputFile(Filenames[i]));
110 if (M.get() == 0) return true;
111
112 if (!run_as_child)
113 std::cout << "Linking in input file: '" << Filenames[i] << "'\n";
114 std::string ErrorMessage;
115 if (Linker::LinkModules(Program, M.get(), &ErrorMessage)) {
116 std::cerr << ToolName << ": error linking in '" << Filenames[i] << "': "
117 << ErrorMessage << '\n';
118 return true;
119 }
Chris Lattner73a6bdd2002-11-20 22:28:10 +0000120 }
Chris Lattner2bd9d8e2006-05-14 19:15:56 +0000121 } catch (const std::string &Error) {
122 std::cerr << ToolName << ": error reading input '" << Error << "'\n";
123 return true;
Chris Lattner73a6bdd2002-11-20 22:28:10 +0000124 }
125
Reid Spencer842118c2005-12-22 20:02:55 +0000126 if (!run_as_child)
127 std::cout << "*** All input ok\n";
Chris Lattner73a6bdd2002-11-20 22:28:10 +0000128
129 // All input files read successfully!
130 return false;
131}
132
133
134
135/// run - The top level method that is invoked after all of the instance
136/// variables are set up from command line arguments.
137///
138bool BugDriver::run() {
Reid Spencer842118c2005-12-22 20:02:55 +0000139 // The first thing to do is determine if we're running as a child. If we are,
140 // then what to do is very narrow. This form of invocation is only called
141 // from the runPasses method to actually run those passes in a child process.
142 if (run_as_child) {
143 // Execute the passes
144 return runPassesAsChild(PassesToRun);
145 }
Patrick Jenkinsc46c0382006-08-15 16:40:49 +0000146
147 if (run_find_bugs) {
148 // Rearrange the passes and apply them to the program. Repeat this process
149 // until the user kills the program or we find a bug.
150 return runManyPasses(PassesToRun);
151 }
Reid Spencer842118c2005-12-22 20:02:55 +0000152
153 // If we're not running as a child, the first thing that we must do is
154 // determine what the problem is. Does the optimization series crash the
155 // compiler, or does it produce illegal code? We make the top-level
156 // decision by trying to run all of the passes on the the input program,
Gabor Greif0e535c3c2007-07-04 21:55:50 +0000157 // which should generate a bitcode file. If it does generate a bitcode
Reid Spencer842118c2005-12-22 20:02:55 +0000158 // file, then we know the compiler didn't crash, so try to diagnose a
159 // miscompilation.
Chris Lattner6ca0b872003-10-13 21:04:26 +0000160 if (!PassesToRun.empty()) {
161 std::cout << "Running selected passes on program to test for crash: ";
162 if (runPasses(PassesToRun))
Chris Lattneread1dff2004-02-18 21:02:04 +0000163 return debugOptimizerCrash();
Chris Lattner6ca0b872003-10-13 21:04:26 +0000164 }
Misha Brukmand792c9b2003-07-24 18:17:43 +0000165
Gabor Greif0e535c3c2007-07-04 21:55:50 +0000166 // Set up the execution environment, selecting a method to run LLVM bitcode.
Misha Brukmand792c9b2003-07-24 18:17:43 +0000167 if (initializeExecutionEnvironment()) return true;
168
Chris Lattner5e9868a2004-02-19 17:03:49 +0000169 // Test to see if we have a code generator crash.
170 std::cout << "Running the code generator to test for a crash: ";
171 try {
172 compileProgram(Program);
Misha Brukman6aa3c832004-07-23 01:30:49 +0000173 std::cout << '\n';
Chris Lattner5e9868a2004-02-19 17:03:49 +0000174 } catch (ToolExecutionError &TEE) {
175 std::cout << TEE.what();
176 return debugCodeGeneratorCrash();
177 }
178
179
Misha Brukmand792c9b2003-07-24 18:17:43 +0000180 // Run the raw input to see where we are coming from. If a reference output
181 // was specified, make sure that the raw output matches it. If not, it's a
182 // problem in the front-end or the code generator.
183 //
Chris Lattnerd1123fd2003-08-22 18:57:43 +0000184 bool CreatedOutput = false;
Misha Brukmand792c9b2003-07-24 18:17:43 +0000185 if (ReferenceOutputFile.empty()) {
Chris Lattner4e0969b2004-07-24 07:53:26 +0000186 std::cout << "Generating reference output from raw program: ";
Patrick Jenkinsc46c0382006-08-15 16:40:49 +0000187 if(!createReferenceFile(Program)){
Bill Wendling8ff43202008-02-26 10:46:10 +0000188 return debugCodeGeneratorCrash();
Chris Lattneread1dff2004-02-18 21:02:04 +0000189 }
Patrick Jenkinsc46c0382006-08-15 16:40:49 +0000190 CreatedOutput = true;
Misha Brukmand792c9b2003-07-24 18:17:43 +0000191 }
192
Chris Lattner2ed06422003-10-14 20:52:55 +0000193 // Make sure the reference output file gets deleted on exit from this
194 // function, if appropriate.
Reid Spencer08b4bd72004-12-20 19:16:12 +0000195 sys::Path ROF(ReferenceOutputFile);
196 FileRemover RemoverInstance(ROF, CreatedOutput);
Chris Lattner2ed06422003-10-14 20:52:55 +0000197
198 // Diff the output of the raw program against the reference output. If it
Patrick Jenkinsc46c0382006-08-15 16:40:49 +0000199 // matches, then we assume there is a miscompilation bug and try to
200 // diagnose it.
Chris Lattner2ed06422003-10-14 20:52:55 +0000201 std::cout << "*** Checking the code generator...\n";
Chris Lattneread1dff2004-02-18 21:02:04 +0000202 try {
203 if (!diffProgram()) {
204 std::cout << "\n*** Debugging miscompilation!\n";
205 return debugMiscompilation();
206 }
207 } catch (ToolExecutionError &TEE) {
Alkis Evlogimenos3562c2d2004-02-19 07:39:26 +0000208 std::cerr << TEE.what();
Chris Lattneread1dff2004-02-18 21:02:04 +0000209 return debugCodeGeneratorCrash();
Chris Lattner2ed06422003-10-14 20:52:55 +0000210 }
211
212 std::cout << "\n*** Input program does not match reference diff!\n";
213 std::cout << "Debugging code generator problem!\n";
Chris Lattner5e9868a2004-02-19 17:03:49 +0000214 try {
215 return debugCodeGenerator();
216 } catch (ToolExecutionError &TEE) {
217 std::cerr << TEE.what();
218 return debugCodeGeneratorCrash();
219 }
Misha Brukmand792c9b2003-07-24 18:17:43 +0000220}
221
Chris Lattnerfd72bed2004-03-14 20:50:42 +0000222void llvm::PrintFunctionList(const std::vector<Function*> &Funcs) {
223 unsigned NumPrint = Funcs.size();
224 if (NumPrint > 10) NumPrint = 10;
225 for (unsigned i = 0; i != NumPrint; ++i)
226 std::cout << " " << Funcs[i]->getName();
227 if (NumPrint < Funcs.size())
228 std::cout << "... <" << Funcs.size() << " total>";
Brian Gaekeadbbfeb2003-10-15 20:42:48 +0000229 std::cout << std::flush;
Chris Lattner73a6bdd2002-11-20 22:28:10 +0000230}
Bill Wendling3f833432006-10-25 18:36:14 +0000231
232void llvm::PrintGlobalVariableList(const std::vector<GlobalVariable*> &GVs) {
233 unsigned NumPrint = GVs.size();
234 if (NumPrint > 10) NumPrint = 10;
235 for (unsigned i = 0; i != NumPrint; ++i)
236 std::cout << " " << GVs[i]->getName();
237 if (NumPrint < GVs.size())
238 std::cout << "... <" << GVs.size() << " total>";
239 std::cout << std::flush;
240}