1 //===- ExecutionDriver.cpp - Allow execution of LLVM program --------------===//
3 // This file contains code used to execute the program utilizing one of the
4 // various ways of running LLVM bytecode.
6 //===----------------------------------------------------------------------===//
11 1. Bugpoint should not leave any files behind if the program works properly
12 2. There should be an option to specify the program name, which specifies a
13 unique string to put into output files. This allows operation in the
14 SingleSource directory, e.g. default to the first input filename.
17 #include "BugDriver.h"
18 #include "Support/CommandLine.h"
19 #include "Support/Debug.h"
20 #include "Support/FileUtilities.h"
21 #include "Support/SystemUtils.h"
26 // OutputType - Allow the user to specify the way code should be run, to test
27 // for miscompilation.
30 RunLLI, RunJIT, RunLLC, RunCBE
33 InterpreterSel(cl::desc("Specify how LLVM code should be executed:"),
34 cl::values(clEnumValN(RunLLI, "run-lli", "Execute with LLI"),
35 clEnumValN(RunJIT, "run-jit", "Execute with JIT"),
36 clEnumValN(RunLLC, "run-llc", "Compile with LLC"),
37 clEnumValN(RunCBE, "run-cbe", "Compile with CBE"),
41 InputFile("input", cl::init("/dev/null"),
42 cl::desc("Filename to pipe in as stdin (default: /dev/null)"));
44 enum FileType { AsmFile, CFile };
47 // Anything specified after the --args option are taken as arguments to the
48 // program being debugged.
50 InputArgv("args", cl::Positional, cl::desc("<program arguments>..."),
53 /// AbstractInterpreter Class - Subclasses of this class are used to execute
54 /// LLVM bytecode in a variety of ways. This abstract interface hides this
55 /// complexity behind a simple interface.
57 struct AbstractInterpreter {
59 virtual ~AbstractInterpreter() {}
61 /// ExecuteProgram - Run the specified bytecode file, emitting output to the
62 /// specified filename. This returns the exit code of the program.
64 virtual int ExecuteProgram(const std::string &Bytecode,
65 const std::string &OutputFile,
66 const std::string &SharedLib = "") = 0;
70 //===----------------------------------------------------------------------===//
71 // LLI Implementation of AbstractIntepreter interface
73 class LLI : public AbstractInterpreter {
74 std::string LLIPath; // The path to the LLI executable
76 LLI(const std::string &Path) : LLIPath(Path) { }
78 // LLI create method - Try to find the LLI executable
79 static LLI *create(BugDriver *BD, std::string &Message) {
80 std::string LLIPath = FindExecutable("lli", BD->getToolName());
81 if (!LLIPath.empty()) {
82 Message = "Found lli: " + LLIPath + "\n";
83 return new LLI(LLIPath);
86 Message = "Cannot find `lli' in bugpoint executable directory or PATH!\n";
89 virtual int ExecuteProgram(const std::string &Bytecode,
90 const std::string &OutputFile,
91 const std::string &SharedLib = "");
94 int LLI::ExecuteProgram(const std::string &Bytecode,
95 const std::string &OutputFile,
96 const std::string &SharedLib) {
97 if (!SharedLib.empty()) {
98 std::cerr << "LLI currently does not support loading shared libraries.\n"
103 std::vector<const char*> LLIArgs;
104 LLIArgs.push_back(LLIPath.c_str());
105 LLIArgs.push_back("-abort-on-exception");
106 LLIArgs.push_back("-quiet");
107 LLIArgs.push_back("-force-interpreter=true");
108 LLIArgs.push_back(Bytecode.c_str());
109 // Add optional parameters to the running program from Argv
110 for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
111 LLIArgs.push_back(InputArgv[i].c_str());
112 LLIArgs.push_back(0);
114 std::cout << "<lli>" << std::flush;
115 DEBUG(std::cerr << "\nAbout to run:\n\t";
116 for (unsigned i=0, e = LLIArgs.size(); i != e; ++i)
117 std::cerr << " " << LLIArgs[i];
120 return RunProgramWithTimeout(LLIPath, &LLIArgs[0],
121 InputFile, OutputFile, OutputFile);
124 //===----------------------------------------------------------------------===//
127 // This is not a *real* AbstractInterpreter as it does not accept bytecode
128 // files, but only input acceptable to GCC, i.e. C, C++, and assembly files
131 std::string GCCPath; // The path to the gcc executable
133 GCC(const std::string &gccPath) : GCCPath(gccPath) { }
136 // GCC create method - Try to find the `gcc' executable
137 static GCC *create(BugDriver *BD, std::string &Message) {
138 std::string GCCPath = FindExecutable("gcc", BD->getToolName());
139 if (GCCPath.empty()) {
140 Message = "Cannot find `gcc' in bugpoint executable directory or PATH!\n";
144 Message = "Found gcc: " + GCCPath + "\n";
145 return new GCC(GCCPath);
148 virtual int ExecuteProgram(const std::string &ProgramFile,
150 const std::string &OutputFile,
151 const std::string &SharedLib = "");
153 int MakeSharedObject(const std::string &InputFile,
155 std::string &OutputFile);
157 void ProcessFailure(const char **Args);
160 int GCC::ExecuteProgram(const std::string &ProgramFile,
162 const std::string &OutputFile,
163 const std::string &SharedLib) {
164 std::string OutputBinary = getUniqueFilename("bugpoint.gcc.exe");
165 std::vector<const char*> GCCArgs;
167 GCCArgs.push_back(GCCPath.c_str());
168 if (!SharedLib.empty()) // Specify the shared library to link in...
169 GCCArgs.push_back(SharedLib.c_str());
170 GCCArgs.push_back("-x");
171 if (fileType == CFile) {
172 GCCArgs.push_back("c");
173 GCCArgs.push_back("-fno-strict-aliasing");
175 GCCArgs.push_back("assembler");
177 GCCArgs.push_back(ProgramFile.c_str()); // Specify the input filename...
178 GCCArgs.push_back("-o");
179 GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
180 GCCArgs.push_back("-lm"); // Hard-code the math library...
181 GCCArgs.push_back("-O2"); // Optimize the program a bit...
182 GCCArgs.push_back(0); // NULL terminator
184 std::cout << "<gcc>" << std::flush;
185 if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], "/dev/null", "/dev/null",
187 ProcessFailure(&GCCArgs[0]);
191 std::vector<const char*> ProgramArgs;
192 ProgramArgs.push_back(OutputBinary.c_str());
193 // Add optional parameters to the running program from Argv
194 for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
195 ProgramArgs.push_back(InputArgv[i].c_str());
196 ProgramArgs.push_back(0); // NULL terminator
198 // Now that we have a binary, run it!
199 std::cout << "<program>" << std::flush;
200 DEBUG(std::cerr << "\nAbout to run:\n\t";
201 for (unsigned i=0, e = ProgramArgs.size(); i != e; ++i)
202 std::cerr << " " << ProgramArgs[i];
205 int ProgramResult = RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
206 InputFile, OutputFile, OutputFile);
207 removeFile(OutputBinary);
208 return ProgramResult;
211 int GCC::MakeSharedObject(const std::string &InputFile,
213 std::string &OutputFile) {
214 OutputFile = getUniqueFilename("./bugpoint.so");
215 // Compile the C/asm file into a shared object
216 const char* GCCArgs[] = {
218 "-x", (fileType == AsmFile) ? "assembler" : "c",
219 "-fno-strict-aliasing",
220 InputFile.c_str(), // Specify the input filename...
221 #if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
222 "-G", // Compile a shared library, `-G' for Sparc
224 "-shared", // `-shared' for Linux/X86, maybe others
226 "-o", OutputFile.c_str(), // Output to the right filename...
227 "-O2", // Optimize the program a bit...
231 std::cout << "<gcc>" << std::flush;
232 if(RunProgramWithTimeout(GCCPath, GCCArgs, "/dev/null", "/dev/null",
234 ProcessFailure(GCCArgs);
240 void GCC::ProcessFailure(const char** GCCArgs) {
241 std::cerr << "\n*** bugpoint error: invocation of the C compiler failed!\n";
242 for (const char **Arg = GCCArgs; *Arg; ++Arg)
243 std::cerr << " " << *Arg;
246 // Rerun the compiler, capturing any error messages to print them.
247 std::string ErrorFilename = getUniqueFilename("bugpoint.gcc.errors");
248 RunProgramWithTimeout(GCCPath, GCCArgs, "/dev/null", ErrorFilename.c_str(),
249 ErrorFilename.c_str());
251 // Print out the error messages generated by GCC if possible...
252 std::ifstream ErrorFile(ErrorFilename.c_str());
254 std::copy(std::istreambuf_iterator<char>(ErrorFile),
255 std::istreambuf_iterator<char>(),
256 std::ostreambuf_iterator<char>(std::cerr));
261 removeFile(ErrorFilename);
264 //===----------------------------------------------------------------------===//
265 // LLC Implementation of AbstractIntepreter interface
267 class LLC : public AbstractInterpreter {
268 std::string LLCPath; // The path to the LLC executable
271 LLC(const std::string &llcPath, GCC *Gcc)
272 : LLCPath(llcPath), gcc(Gcc) { }
273 ~LLC() { delete gcc; }
275 // LLC create method - Try to find the LLC executable
276 static LLC *create(BugDriver *BD, std::string &Message) {
277 std::string LLCPath = FindExecutable("llc", BD->getToolName());
278 if (LLCPath.empty()) {
279 Message = "Cannot find `llc' in bugpoint executable directory or PATH!\n";
283 Message = "Found llc: " + LLCPath + "\n";
284 GCC *gcc = GCC::create(BD, Message);
286 std::cerr << Message << "\n";
289 return new LLC(LLCPath, gcc);
292 virtual int ExecuteProgram(const std::string &Bytecode,
293 const std::string &OutputFile,
294 const std::string &SharedLib = "");
296 int OutputAsm(const std::string &Bytecode,
297 std::string &OutputAsmFile);
300 int LLC::OutputAsm(const std::string &Bytecode,
301 std::string &OutputAsmFile) {
302 OutputAsmFile = "bugpoint.llc.s";
303 const char *LLCArgs[] = {
305 "-o", OutputAsmFile.c_str(), // Output to the Asm file
306 "-f", // Overwrite as necessary...
307 Bytecode.c_str(), // This is the input bytecode
311 std::cout << "<llc>" << std::flush;
312 if (RunProgramWithTimeout(LLCPath, LLCArgs, "/dev/null", "/dev/null",
314 // If LLC failed on the bytecode, print error...
315 std::cerr << "bugpoint error: `llc' failed!\n";
316 removeFile(OutputAsmFile);
323 int LLC::ExecuteProgram(const std::string &Bytecode,
324 const std::string &OutputFile,
325 const std::string &SharedLib) {
327 std::string OutputAsmFile;
328 if (OutputAsm(Bytecode, OutputAsmFile)) {
329 std::cerr << "Could not generate asm code with `llc', exiting.\n";
333 // Assuming LLC worked, compile the result with GCC and run it.
334 int Result = gcc->ExecuteProgram(OutputAsmFile,AsmFile,OutputFile,SharedLib);
335 removeFile(OutputAsmFile);
340 //===----------------------------------------------------------------------===//
341 // JIT Implementation of AbstractIntepreter interface
343 class JIT : public AbstractInterpreter {
344 std::string LLIPath; // The path to the LLI executable
346 JIT(const std::string &Path) : LLIPath(Path) { }
348 // JIT create method - Try to find the LLI executable
349 static JIT *create(BugDriver *BD, std::string &Message) {
350 std::string LLIPath = FindExecutable("lli", BD->getToolName());
351 if (!LLIPath.empty()) {
352 Message = "Found lli: " + LLIPath + "\n";
353 return new JIT(LLIPath);
356 Message = "Cannot find `lli' in bugpoint executable directory or PATH!\n";
359 virtual int ExecuteProgram(const std::string &Bytecode,
360 const std::string &OutputFile,
361 const std::string &SharedLib = "");
364 int JIT::ExecuteProgram(const std::string &Bytecode,
365 const std::string &OutputFile,
366 const std::string &SharedLib) {
367 // Construct a vector of parameters, incorporating those from the command-line
368 std::vector<const char*> JITArgs;
369 JITArgs.push_back(LLIPath.c_str());
370 JITArgs.push_back("-quiet");
371 JITArgs.push_back("-force-interpreter=false");
372 if (!SharedLib.empty()) {
373 JITArgs.push_back("-load");
374 JITArgs.push_back(SharedLib.c_str());
376 JITArgs.push_back(Bytecode.c_str());
377 // Add optional parameters to the running program from Argv
378 for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
379 JITArgs.push_back(InputArgv[i].c_str());
380 JITArgs.push_back(0);
382 std::cout << "<jit>" << std::flush;
383 DEBUG(std::cerr << "\nAbout to run:\n\t";
384 for (unsigned i=0, e = JITArgs.size(); i != e; ++i)
385 std::cerr << " " << JITArgs[i];
388 DEBUG(std::cerr << "\nSending output to " << OutputFile << "\n");
389 return RunProgramWithTimeout(LLIPath, &JITArgs[0],
390 InputFile, OutputFile, OutputFile);
393 //===----------------------------------------------------------------------===//
394 // CBE Implementation of AbstractIntepreter interface
396 class CBE : public AbstractInterpreter {
397 std::string DISPath; // The path to the LLVM 'dis' executable
400 CBE(const std::string &disPath, GCC *Gcc) : DISPath(disPath), gcc(Gcc) { }
401 ~CBE() { delete gcc; }
403 // CBE create method - Try to find the 'dis' executable
404 static CBE *create(BugDriver *BD, std::string &Message) {
405 std::string DISPath = FindExecutable("dis", BD->getToolName());
406 if (DISPath.empty()) {
407 Message = "Cannot find `dis' in bugpoint executable directory or PATH!\n";
411 Message = "Found dis: " + DISPath + "\n";
413 GCC *gcc = GCC::create(BD, Message);
415 std::cerr << Message << "\n";
418 return new CBE(DISPath, gcc);
421 virtual int ExecuteProgram(const std::string &Bytecode,
422 const std::string &OutputFile,
423 const std::string &SharedLib = "");
425 // Sometimes we just want to go half-way and only generate the C file,
426 // not necessarily compile it with GCC and run the program
427 virtual int OutputC(const std::string &Bytecode,
428 std::string &OutputCFile);
432 int CBE::OutputC(const std::string &Bytecode,
433 std::string &OutputCFile) {
434 OutputCFile = "bugpoint.cbe.c";
435 const char *DisArgs[] = {
437 "-o", OutputCFile.c_str(), // Output to the C file
439 "-f", // Overwrite as necessary...
440 Bytecode.c_str(), // This is the input bytecode
444 std::cout << "<cbe>" << std::flush;
445 if (RunProgramWithTimeout(DISPath, DisArgs, "/dev/null", "/dev/null",
447 // If dis failed on the bytecode, print error...
448 std::cerr << "bugpoint error: `dis -c' failed!\n";
456 int CBE::ExecuteProgram(const std::string &Bytecode,
457 const std::string &OutputFile,
458 const std::string &SharedLib) {
459 std::string OutputCFile;
460 if (OutputC(Bytecode, OutputCFile)) {
461 std::cerr << "Could not generate C code with `dis', exiting.\n";
465 int Result = gcc->ExecuteProgram(OutputCFile, CFile, OutputFile, SharedLib);
466 removeFile(OutputCFile);
472 //===----------------------------------------------------------------------===//
473 // BugDriver method implementation
476 /// initializeExecutionEnvironment - This method is used to set up the
477 /// environment for executing LLVM programs.
479 bool BugDriver::initializeExecutionEnvironment() {
480 std::cout << "Initializing execution environment: ";
482 // FIXME: This should default to searching for the best interpreter to use on
483 // this platform, which would be JIT, then LLC, then CBE, then LLI.
485 // Create an instance of the AbstractInterpreter interface as specified on the
488 switch (InterpreterSel) {
489 case RunLLI: Interpreter = LLI::create(this, Message); break;
490 case RunLLC: Interpreter = LLC::create(this, Message); break;
491 case RunJIT: Interpreter = JIT::create(this, Message); break;
492 case RunCBE: Interpreter = CBE::create(this, Message); break;
494 Message = " Sorry, this back-end is not supported by bugpoint right now!\n";
498 std::cout << Message;
500 // Initialize auxiliary tools for debugging
501 cbe = CBE::create(this, Message);
502 if (!cbe) { std::cout << Message << "\nExiting.\n"; exit(1); }
503 gcc = GCC::create(this, Message);
504 if (!gcc) { std::cout << Message << "\nExiting.\n"; exit(1); }
506 // If there was an error creating the selected interpreter, quit with error.
507 return Interpreter == 0;
511 /// executeProgram - This method runs "Program", capturing the output of the
512 /// program to a file, returning the filename of the file. A recommended
513 /// filename may be optionally specified.
515 std::string BugDriver::executeProgram(std::string OutputFile,
516 std::string BytecodeFile,
517 std::string SharedObject,
518 AbstractInterpreter *AI) {
519 assert((Interpreter || AI) &&"Interpreter should have been created already!");
520 bool CreatedBytecode = false;
521 if (BytecodeFile.empty()) {
522 // Emit the program to a bytecode file...
523 BytecodeFile = getUniqueFilename("bugpoint-test-program.bc");
525 if (writeProgramToFile(BytecodeFile, Program)) {
526 std::cerr << ToolName << ": Error emitting bytecode to file '"
527 << BytecodeFile << "'!\n";
530 CreatedBytecode = true;
533 if (OutputFile.empty()) OutputFile = "bugpoint-execution-output";
535 // Check to see if this is a valid output filename...
536 OutputFile = getUniqueFilename(OutputFile);
538 // Actually execute the program!
539 int RetVal = (AI != 0) ?
540 AI->ExecuteProgram(BytecodeFile, OutputFile, SharedObject) :
541 Interpreter->ExecuteProgram(BytecodeFile, OutputFile, SharedObject);
543 // Remove the temporary bytecode file.
544 if (CreatedBytecode) removeFile(BytecodeFile);
546 // Return the filename we captured the output to.
550 std::string BugDriver::executeProgramWithCBE(std::string OutputFile,
551 std::string BytecodeFile,
552 std::string SharedObject) {
553 return executeProgram(OutputFile, BytecodeFile, SharedObject, cbe);
556 int BugDriver::compileSharedObject(const std::string &BytecodeFile,
557 std::string &SharedObject) {
558 assert(Interpreter && "Interpreter should have been created already!");
559 std::string Message, OutputCFile;
562 cbe->OutputC(BytecodeFile, OutputCFile);
564 #if 0 /* This is an alternative, as yet unimplemented */
566 LLC *llc = LLC::create(this, Message);
567 if (llc->OutputAsm(BytecodeFile, OutputFile)) {
568 std::cerr << "Could not generate asm code with `llc', exiting.\n";
573 gcc->MakeSharedObject(OutputCFile, CFile, SharedObject);
575 // Remove the intermediate C file
576 removeFile(OutputCFile);
582 /// diffProgram - This method executes the specified module and diffs the output
583 /// against the file specified by ReferenceOutputFile. If the output is
584 /// different, true is returned.
586 bool BugDriver::diffProgram(const std::string &BytecodeFile,
587 const std::string &SharedObject,
588 bool RemoveBytecode) {
589 // Execute the program, generating an output file...
590 std::string Output = executeProgram("", BytecodeFile, SharedObject);
593 bool FilesDifferent = false;
594 if (DiffFiles(ReferenceOutputFile, Output, &Error)) {
595 if (!Error.empty()) {
596 std::cerr << "While diffing output: " << Error << "\n";
599 FilesDifferent = true;
602 if (RemoveBytecode) removeFile(BytecodeFile);
603 return FilesDifferent;
606 bool BugDriver::isExecutingJIT() {
607 return InterpreterSel == RunJIT;