1 //===- ExecutionDriver.cpp - Allow execution of LLVM program --------------===//
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 file contains code used to execute the program utilizing one of the
11 // various ways of running LLVM bitcode.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "BugDriver.h"
16 #include "ToolRunner.h"
17 #include "llvm/Support/CommandLine.h"
18 #include "llvm/Support/Debug.h"
19 #include "llvm/Support/FileUtilities.h"
20 #include "llvm/Support/SystemUtils.h"
21 #include "llvm/Support/raw_ostream.h"
22 #include <fstream>
23 
24 using namespace llvm;
25 
26 namespace {
27   // OutputType - Allow the user to specify the way code should be run, to test
28   // for miscompilation.
29   //
30   enum OutputType {
31     AutoPick, RunLLI, RunJIT, RunLLC, RunCBE, CBE_bug, LLC_Safe, Custom
32   };
33 
34   cl::opt<double>
35   AbsTolerance("abs-tolerance", cl::desc("Absolute error tolerated"),
36                cl::init(0.0));
37   cl::opt<double>
38   RelTolerance("rel-tolerance", cl::desc("Relative error tolerated"),
39                cl::init(0.0));
40 
41   cl::opt<OutputType>
42   InterpreterSel(cl::desc("Specify the \"test\" i.e. suspect back-end:"),
43                  cl::values(clEnumValN(AutoPick, "auto", "Use best guess"),
44                             clEnumValN(RunLLI, "run-int",
45                                        "Execute with the interpreter"),
46                             clEnumValN(RunJIT, "run-jit", "Execute with JIT"),
47                             clEnumValN(RunLLC, "run-llc", "Compile with LLC"),
48                             clEnumValN(RunCBE, "run-cbe", "Compile with CBE"),
49                             clEnumValN(CBE_bug,"cbe-bug", "Find CBE bugs"),
50                             clEnumValN(LLC_Safe, "llc-safe", "Use LLC for all"),
51                             clEnumValN(Custom, "run-custom",
52                             "Use -exec-command to define a command to execute "
53                             "the bitcode. Useful for cross-compilation."),
54                             clEnumValEnd),
55                  cl::init(AutoPick));
56 
57   cl::opt<OutputType>
58   SafeInterpreterSel(cl::desc("Specify \"safe\" i.e. known-good backend:"),
59               cl::values(clEnumValN(AutoPick, "safe-auto", "Use best guess"),
60                          clEnumValN(RunLLC, "safe-run-llc", "Compile with LLC"),
61                          clEnumValN(RunCBE, "safe-run-cbe", "Compile with CBE"),
62                          clEnumValN(Custom, "safe-run-custom",
63                          "Use -exec-command to define a command to execute "
64                          "the bitcode. Useful for cross-compilation."),
65                          clEnumValEnd),
66                      cl::init(AutoPick));
67 
68   cl::opt<std::string>
69   SafeInterpreterPath("safe-path",
70                    cl::desc("Specify the path to the \"safe\" backend program"),
71                    cl::init(""));
72 
73   cl::opt<bool>
74   AppendProgramExitCode("append-exit-code",
75       cl::desc("Append the exit code to the output so it gets diff'd too"),
76       cl::init(false));
77 
78   cl::opt<std::string>
79   InputFile("input", cl::init("/dev/null"),
80             cl::desc("Filename to pipe in as stdin (default: /dev/null)"));
81 
82   cl::list<std::string>
83   AdditionalSOs("additional-so",
84                 cl::desc("Additional shared objects to load "
85                          "into executing programs"));
86 
87   cl::list<std::string>
88   AdditionalLinkerArgs("Xlinker",
89       cl::desc("Additional arguments to pass to the linker"));
90 
91   cl::opt<std::string>
92   CustomExecCommand("exec-command", cl::init("simulate"),
93       cl::desc("Command to execute the bitcode (use with -run-custom) "
94                "(default: simulate)"));
95 }
96 
97 namespace llvm {
98   // Anything specified after the --args option are taken as arguments to the
99   // program being debugged.
100   cl::list<std::string>
101   InputArgv("args", cl::Positional, cl::desc("<program arguments>..."),
102             cl::ZeroOrMore, cl::PositionalEatsArgs);
103 
104   cl::opt<std::string>
105   OutputPrefix("output-prefix", cl::init("bugpoint"),
106             cl::desc("Prefix to use for outputs (default: 'bugpoint')"));
107 }
108 
109 namespace {
110   cl::list<std::string>
111   ToolArgv("tool-args", cl::Positional, cl::desc("<tool arguments>..."),
112            cl::ZeroOrMore, cl::PositionalEatsArgs);
113 
114   cl::list<std::string>
115   SafeToolArgv("safe-tool-args", cl::Positional,
116                cl::desc("<safe-tool arguments>..."),
117                cl::ZeroOrMore, cl::PositionalEatsArgs);
118 
119   cl::list<std::string>
120   GCCToolArgv("gcc-tool-args", cl::Positional,
121               cl::desc("<gcc-tool arguments>..."),
122               cl::ZeroOrMore, cl::PositionalEatsArgs);
123 }
124 
125 //===----------------------------------------------------------------------===//
126 // BugDriver method implementation
127 //
128 
129 /// initializeExecutionEnvironment - This method is used to set up the
130 /// environment for executing LLVM programs.
131 ///
132 bool BugDriver::initializeExecutionEnvironment() {
133   outs() << "Initializing execution environment: ";
134 
135   // Create an instance of the AbstractInterpreter interface as specified on
136   // the command line
137   SafeInterpreter = 0;
138   std::string Message;
139 
140   switch (InterpreterSel) {
141   case AutoPick:
142     InterpreterSel = RunCBE;
143     Interpreter =
144       AbstractInterpreter::createCBE(getToolName(), Message, &ToolArgv,
145                                      &GCCToolArgv);
146     if (!Interpreter) {
147       InterpreterSel = RunJIT;
148       Interpreter = AbstractInterpreter::createJIT(getToolName(), Message,
149                                                    &ToolArgv);
150     }
151     if (!Interpreter) {
152       InterpreterSel = RunLLC;
153       Interpreter = AbstractInterpreter::createLLC(getToolName(), Message,
154                                                    &ToolArgv, &GCCToolArgv);
155     }
156     if (!Interpreter) {
157       InterpreterSel = RunLLI;
158       Interpreter = AbstractInterpreter::createLLI(getToolName(), Message,
159                                                    &ToolArgv);
160     }
161     if (!Interpreter) {
162       InterpreterSel = AutoPick;
163       Message = "Sorry, I can't automatically select an interpreter!\n";
164     }
165     break;
166   case RunLLI:
167     Interpreter = AbstractInterpreter::createLLI(getToolName(), Message,
168                                                  &ToolArgv);
169     break;
170   case RunLLC:
171   case LLC_Safe:
172     Interpreter = AbstractInterpreter::createLLC(getToolName(), Message,
173                                                  &ToolArgv, &GCCToolArgv);
174     break;
175   case RunJIT:
176     Interpreter = AbstractInterpreter::createJIT(getToolName(), Message,
177                                                  &ToolArgv);
178     break;
179   case RunCBE:
180   case CBE_bug:
181     Interpreter = AbstractInterpreter::createCBE(getToolName(), Message,
182                                                  &ToolArgv, &GCCToolArgv);
183     break;
184   case Custom:
185     Interpreter = AbstractInterpreter::createCustom(Message, CustomExecCommand);
186     break;
187   default:
188     Message = "Sorry, this back-end is not supported by bugpoint right now!\n";
189     break;
190   }
191   if (!Interpreter)
192     errs() << Message;
193   else // Display informational messages on stdout instead of stderr
194     outs() << Message;
195 
196   std::string Path = SafeInterpreterPath;
197   if (Path.empty())
198     Path = getToolName();
199   std::vector<std::string> SafeToolArgs = SafeToolArgv;
200   switch (SafeInterpreterSel) {
201   case AutoPick:
202     // In "cbe-bug" mode, default to using LLC as the "safe" backend.
203     if (!SafeInterpreter &&
204         InterpreterSel == CBE_bug) {
205       SafeInterpreterSel = RunLLC;
206       SafeToolArgs.push_back("--relocation-model=pic");
207       SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message,
208                                                        &SafeToolArgs,
209                                                        &GCCToolArgv);
210     }
211 
212     // In "llc-safe" mode, default to using LLC as the "safe" backend.
213     if (!SafeInterpreter &&
214         InterpreterSel == LLC_Safe) {
215       SafeInterpreterSel = RunLLC;
216       SafeToolArgs.push_back("--relocation-model=pic");
217       SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message,
218                                                        &SafeToolArgs,
219                                                        &GCCToolArgv);
220     }
221 
222     // Pick a backend that's different from the test backend. The JIT and
223     // LLC backends share a lot of code, so prefer to use the CBE as the
224     // safe back-end when testing them.
225     if (!SafeInterpreter &&
226         InterpreterSel != RunCBE) {
227       SafeInterpreterSel = RunCBE;
228       SafeInterpreter = AbstractInterpreter::createCBE(Path.c_str(), Message,
229                                                        &SafeToolArgs,
230                                                        &GCCToolArgv);
231     }
232     if (!SafeInterpreter &&
233         InterpreterSel != RunLLC &&
234         InterpreterSel != RunJIT) {
235       SafeInterpreterSel = RunLLC;
236       SafeToolArgs.push_back("--relocation-model=pic");
237       SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message,
238                                                        &SafeToolArgs,
239                                                        &GCCToolArgv);
240     }
241     if (!SafeInterpreter) {
242       SafeInterpreterSel = AutoPick;
243       Message = "Sorry, I can't automatically select an interpreter!\n";
244     }
245     break;
246   case RunLLC:
247     SafeToolArgs.push_back("--relocation-model=pic");
248     SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message,
249                                                      &SafeToolArgs,
250                                                      &GCCToolArgv);
251     break;
252   case RunCBE:
253     SafeInterpreter = AbstractInterpreter::createCBE(Path.c_str(), Message,
254                                                      &SafeToolArgs,
255                                                      &GCCToolArgv);
256     break;
257   case Custom:
258     SafeInterpreter = AbstractInterpreter::createCustom(Message,
259                                                         CustomExecCommand);
260     break;
261   default:
262     Message = "Sorry, this back-end is not supported by bugpoint as the "
263               "\"safe\" backend right now!\n";
264     break;
265   }
266   if (!SafeInterpreter) { outs() << Message << "\nExiting.\n"; exit(1); }
267 
268   gcc = GCC::create(Message, &GCCToolArgv);
269   if (!gcc) { outs() << Message << "\nExiting.\n"; exit(1); }
270 
271   // If there was an error creating the selected interpreter, quit with error.
272   return Interpreter == 0;
273 }
274 
275 /// compileProgram - Try to compile the specified module, throwing an exception
276 /// if an error occurs, or returning normally if not.  This is used for code
277 /// generation crash testing.
278 ///
279 void BugDriver::compileProgram(Module *M) {
280   // Emit the program to a bitcode file...
281   sys::Path BitcodeFile (OutputPrefix + "-test-program.bc");
282   std::string ErrMsg;
283   if (BitcodeFile.makeUnique(true,&ErrMsg)) {
284     errs() << ToolName << ": Error making unique filename: " << ErrMsg
285            << "\n";
286     exit(1);
287   }
288   if (writeProgramToFile(BitcodeFile.str(), M)) {
289     errs() << ToolName << ": Error emitting bitcode to file '"
290            << BitcodeFile.str() << "'!\n";
291     exit(1);
292   }
293 
294     // Remove the temporary bitcode file when we are done.
295   FileRemover BitcodeFileRemover(BitcodeFile, !SaveTemps);
296 
297   // Actually compile the program!
298   Interpreter->compileProgram(BitcodeFile.str());
299 }
300 
301 
302 /// executeProgram - This method runs "Program", capturing the output of the
303 /// program to a file, returning the filename of the file.  A recommended
304 /// filename may be optionally specified.
305 ///
306 std::string BugDriver::executeProgram(std::string OutputFile,
307                                       std::string BitcodeFile,
308                                       const std::string &SharedObj,
309                                       AbstractInterpreter *AI,
310                                       bool *ProgramExitedNonzero) {
311   if (AI == 0) AI = Interpreter;
312   assert(AI && "Interpreter should have been created already!");
313   bool CreatedBitcode = false;
314   std::string ErrMsg;
315   if (BitcodeFile.empty()) {
316     // Emit the program to a bitcode file...
317     sys::Path uniqueFilename(OutputPrefix + "-test-program.bc");
318     if (uniqueFilename.makeUnique(true, &ErrMsg)) {
319       errs() << ToolName << ": Error making unique filename: "
320              << ErrMsg << "!\n";
321       exit(1);
322     }
323     BitcodeFile = uniqueFilename.str();
324 
325     if (writeProgramToFile(BitcodeFile, Program)) {
326       errs() << ToolName << ": Error emitting bitcode to file '"
327              << BitcodeFile << "'!\n";
328       exit(1);
329     }
330     CreatedBitcode = true;
331   }
332 
333   // Remove the temporary bitcode file when we are done.
334   sys::Path BitcodePath (BitcodeFile);
335   FileRemover BitcodeFileRemover(BitcodePath, CreatedBitcode && !SaveTemps);
336 
337   if (OutputFile.empty()) OutputFile = OutputPrefix + "-execution-output";
338 
339   // Check to see if this is a valid output filename...
340   sys::Path uniqueFile(OutputFile);
341   if (uniqueFile.makeUnique(true, &ErrMsg)) {
342     errs() << ToolName << ": Error making unique filename: "
343            << ErrMsg << "\n";
344     exit(1);
345   }
346   OutputFile = uniqueFile.str();
347 
348   // Figure out which shared objects to run, if any.
349   std::vector<std::string> SharedObjs(AdditionalSOs);
350   if (!SharedObj.empty())
351     SharedObjs.push_back(SharedObj);
352 
353   int RetVal = AI->ExecuteProgram(BitcodeFile, InputArgv, InputFile,
354                                   OutputFile, AdditionalLinkerArgs, SharedObjs,
355                                   Timeout, MemoryLimit);
356 
357   if (RetVal == -1) {
358     errs() << "<timeout>";
359     static bool FirstTimeout = true;
360     if (FirstTimeout) {
361       outs() << "\n"
362  "*** Program execution timed out!  This mechanism is designed to handle\n"
363  "    programs stuck in infinite loops gracefully.  The -timeout option\n"
364  "    can be used to change the timeout threshold or disable it completely\n"
365  "    (with -timeout=0).  This message is only displayed once.\n";
366       FirstTimeout = false;
367     }
368   }
369 
370   if (AppendProgramExitCode) {
371     std::ofstream outFile(OutputFile.c_str(), std::ios_base::app);
372     outFile << "exit " << RetVal << '\n';
373     outFile.close();
374   }
375 
376   if (ProgramExitedNonzero != 0)
377     *ProgramExitedNonzero = (RetVal != 0);
378 
379   // Return the filename we captured the output to.
380   return OutputFile;
381 }
382 
383 /// executeProgramSafely - Used to create reference output with the "safe"
384 /// backend, if reference output is not provided.
385 ///
386 std::string BugDriver::executeProgramSafely(std::string OutputFile) {
387   bool ProgramExitedNonzero;
388   std::string outFN = executeProgram(OutputFile, "", "", SafeInterpreter,
389                                      &ProgramExitedNonzero);
390   return outFN;
391 }
392 
393 std::string BugDriver::compileSharedObject(const std::string &BitcodeFile) {
394   assert(Interpreter && "Interpreter should have been created already!");
395   sys::Path OutputFile;
396 
397   // Using the known-good backend.
398   GCC::FileType FT = SafeInterpreter->OutputCode(BitcodeFile, OutputFile);
399 
400   std::string SharedObjectFile;
401   if (gcc->MakeSharedObject(OutputFile.str(), FT,
402                             SharedObjectFile, AdditionalLinkerArgs))
403     exit(1);
404 
405   // Remove the intermediate C file
406   OutputFile.eraseFromDisk();
407 
408   return "./" + SharedObjectFile;
409 }
410 
411 /// createReferenceFile - calls compileProgram and then records the output
412 /// into ReferenceOutputFile. Returns true if reference file created, false
413 /// otherwise. Note: initializeExecutionEnvironment should be called BEFORE
414 /// this function.
415 ///
416 bool BugDriver::createReferenceFile(Module *M, const std::string &Filename) {
417   try {
418     compileProgram(Program);
419   } catch (ToolExecutionError &) {
420     return false;
421   }
422   try {
423     ReferenceOutputFile = executeProgramSafely(Filename);
424     outs() << "\nReference output is: " << ReferenceOutputFile << "\n\n";
425   } catch (ToolExecutionError &TEE) {
426     errs() << TEE.what();
427     if (Interpreter != SafeInterpreter) {
428       errs() << "*** There is a bug running the \"safe\" backend.  Either"
429              << " debug it (for example with the -run-cbe bugpoint option,"
430              << " if CBE is being used as the \"safe\" backend), or fix the"
431              << " error some other way.\n";
432     }
433     return false;
434   }
435   return true;
436 }
437 
438 /// diffProgram - This method executes the specified module and diffs the
439 /// output against the file specified by ReferenceOutputFile.  If the output
440 /// is different, true is returned.  If there is a problem with the code
441 /// generator (e.g., llc crashes), this will throw an exception.
442 ///
443 bool BugDriver::diffProgram(const std::string &BitcodeFile,
444                             const std::string &SharedObject,
445                             bool RemoveBitcode) {
446   bool ProgramExitedNonzero;
447 
448   // Execute the program, generating an output file...
449   sys::Path Output(executeProgram("", BitcodeFile, SharedObject, 0,
450                                       &ProgramExitedNonzero));
451 
452   std::string Error;
453   bool FilesDifferent = false;
454   if (int Diff = DiffFilesWithTolerance(sys::Path(ReferenceOutputFile),
455                                         sys::Path(Output.str()),
456                                         AbsTolerance, RelTolerance, &Error)) {
457     if (Diff == 2) {
458       errs() << "While diffing output: " << Error << '\n';
459       exit(1);
460     }
461     FilesDifferent = true;
462   }
463   else {
464     // Remove the generated output if there are no differences.
465     Output.eraseFromDisk();
466   }
467 
468   // Remove the bitcode file if we are supposed to.
469   if (RemoveBitcode)
470     sys::Path(BitcodeFile).eraseFromDisk();
471   return FilesDifferent;
472 }
473 
474 bool BugDriver::isExecutingJIT() {
475   return InterpreterSel == RunJIT;
476 }
477 
478