]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
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" | |
970d7e83 | 18 | #include "llvm/IR/Module.h" |
1a4d82fc JJ |
19 | #include "llvm/IRReader/IRReader.h" |
20 | #include "llvm/Linker/Linker.h" | |
223e47cc | 21 | #include "llvm/Pass.h" |
223e47cc LB |
22 | #include "llvm/Support/CommandLine.h" |
23 | #include "llvm/Support/FileUtilities.h" | |
970d7e83 | 24 | #include "llvm/Support/Host.h" |
223e47cc LB |
25 | #include "llvm/Support/SourceMgr.h" |
26 | #include "llvm/Support/raw_ostream.h" | |
223e47cc LB |
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), | |
1a4d82fc JJ |
73 | Program(nullptr), Interpreter(nullptr), SafeInterpreter(nullptr), |
74 | gcc(nullptr), run_find_bugs(find_bugs), Timeout(timeout), | |
223e47cc LB |
75 | MemoryLimit(memlimit), UseValgrind(use_valgrind) {} |
76 | ||
77 | BugDriver::~BugDriver() { | |
78 | delete Program; | |
1a4d82fc JJ |
79 | if (Interpreter != SafeInterpreter) |
80 | delete Interpreter; | |
81 | delete SafeInterpreter; | |
82 | delete gcc; | |
223e47cc LB |
83 | } |
84 | ||
1a4d82fc JJ |
85 | std::unique_ptr<Module> llvm::parseInputFile(StringRef Filename, |
86 | LLVMContext &Ctxt) { | |
223e47cc | 87 | SMDiagnostic Err; |
1a4d82fc | 88 | std::unique_ptr<Module> Result = parseIRFile(Filename, Err, Ctxt); |
223e47cc LB |
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::getDefaultTargetTriple()); | |
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) { | |
1a4d82fc | 115 | assert(!Program && "Cannot call addSources multiple times!"); |
223e47cc LB |
116 | assert(!Filenames.empty() && "Must specify at least on input filename!"); |
117 | ||
118 | // Load the first input file. | |
1a4d82fc JJ |
119 | Program = parseInputFile(Filenames[0], Context).release(); |
120 | if (!Program) return true; | |
223e47cc LB |
121 | |
122 | outs() << "Read input file : '" << Filenames[0] << "'\n"; | |
123 | ||
124 | for (unsigned i = 1, e = Filenames.size(); i != e; ++i) { | |
1a4d82fc JJ |
125 | std::unique_ptr<Module> M = parseInputFile(Filenames[i], Context); |
126 | if (!M.get()) return true; | |
223e47cc LB |
127 | |
128 | outs() << "Linking in input file: '" << Filenames[i] << "'\n"; | |
85aaf69f | 129 | if (Linker::LinkModules(Program, M.get())) |
223e47cc | 130 | return true; |
223e47cc LB |
131 | } |
132 | ||
133 | outs() << "*** All input ok\n"; | |
134 | ||
135 | // All input files read successfully! | |
136 | return false; | |
137 | } | |
138 | ||
139 | ||
140 | ||
141 | /// run - The top level method that is invoked after all of the instance | |
142 | /// variables are set up from command line arguments. | |
143 | /// | |
144 | bool BugDriver::run(std::string &ErrMsg) { | |
145 | if (run_find_bugs) { | |
146 | // Rearrange the passes and apply them to the program. Repeat this process | |
147 | // until the user kills the program or we find a bug. | |
148 | return runManyPasses(PassesToRun, ErrMsg); | |
149 | } | |
150 | ||
151 | // If we're not running as a child, the first thing that we must do is | |
152 | // determine what the problem is. Does the optimization series crash the | |
153 | // compiler, or does it produce illegal code? We make the top-level | |
154 | // decision by trying to run all of the passes on the input program, | |
155 | // which should generate a bitcode file. If it does generate a bitcode | |
156 | // file, then we know the compiler didn't crash, so try to diagnose a | |
157 | // miscompilation. | |
158 | if (!PassesToRun.empty()) { | |
159 | outs() << "Running selected passes on program to test for crash: "; | |
160 | if (runPasses(Program, PassesToRun)) | |
161 | return debugOptimizerCrash(); | |
162 | } | |
163 | ||
164 | // Set up the execution environment, selecting a method to run LLVM bitcode. | |
165 | if (initializeExecutionEnvironment()) return true; | |
166 | ||
167 | // Test to see if we have a code generator crash. | |
168 | outs() << "Running the code generator to test for a crash: "; | |
169 | std::string Error; | |
170 | compileProgram(Program, &Error); | |
171 | if (!Error.empty()) { | |
172 | outs() << Error; | |
173 | return debugCodeGeneratorCrash(ErrMsg); | |
174 | } | |
175 | outs() << '\n'; | |
176 | ||
177 | // Run the raw input to see where we are coming from. If a reference output | |
178 | // was specified, make sure that the raw output matches it. If not, it's a | |
179 | // problem in the front-end or the code generator. | |
180 | // | |
181 | bool CreatedOutput = false; | |
182 | if (ReferenceOutputFile.empty()) { | |
183 | outs() << "Generating reference output from raw program: "; | |
184 | if (!createReferenceFile(Program)) { | |
185 | return debugCodeGeneratorCrash(ErrMsg); | |
186 | } | |
187 | CreatedOutput = true; | |
188 | } | |
189 | ||
190 | // Make sure the reference output file gets deleted on exit from this | |
191 | // function, if appropriate. | |
1a4d82fc JJ |
192 | std::string ROF(ReferenceOutputFile); |
193 | FileRemover RemoverInstance(ROF, CreatedOutput && !SaveTemps); | |
223e47cc LB |
194 | |
195 | // Diff the output of the raw program against the reference output. If it | |
196 | // matches, then we assume there is a miscompilation bug and try to | |
197 | // diagnose it. | |
198 | outs() << "*** Checking the code generator...\n"; | |
199 | bool Diff = diffProgram(Program, "", "", false, &Error); | |
200 | if (!Error.empty()) { | |
201 | errs() << Error; | |
202 | return debugCodeGeneratorCrash(ErrMsg); | |
203 | } | |
204 | if (!Diff) { | |
205 | outs() << "\n*** Output matches: Debugging miscompilation!\n"; | |
206 | debugMiscompilation(&Error); | |
207 | if (!Error.empty()) { | |
208 | errs() << Error; | |
209 | return debugCodeGeneratorCrash(ErrMsg); | |
210 | } | |
211 | return false; | |
212 | } | |
213 | ||
214 | outs() << "\n*** Input program does not match reference diff!\n"; | |
215 | outs() << "Debugging code generator problem!\n"; | |
216 | bool Failure = debugCodeGenerator(&Error); | |
217 | if (!Error.empty()) { | |
218 | errs() << Error; | |
219 | return debugCodeGeneratorCrash(ErrMsg); | |
220 | } | |
221 | return Failure; | |
222 | } | |
223 | ||
224 | void llvm::PrintFunctionList(const std::vector<Function*> &Funcs) { | |
225 | unsigned NumPrint = Funcs.size(); | |
226 | if (NumPrint > 10) NumPrint = 10; | |
227 | for (unsigned i = 0; i != NumPrint; ++i) | |
228 | outs() << " " << Funcs[i]->getName(); | |
229 | if (NumPrint < Funcs.size()) | |
230 | outs() << "... <" << Funcs.size() << " total>"; | |
231 | outs().flush(); | |
232 | } | |
233 | ||
234 | void llvm::PrintGlobalVariableList(const std::vector<GlobalVariable*> &GVs) { | |
235 | unsigned NumPrint = GVs.size(); | |
236 | if (NumPrint > 10) NumPrint = 10; | |
237 | for (unsigned i = 0; i != NumPrint; ++i) | |
238 | outs() << " " << GVs[i]->getName(); | |
239 | if (NumPrint < GVs.size()) | |
240 | outs() << "... <" << GVs.size() << " total>"; | |
241 | outs().flush(); | |
242 | } |