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/SystemUtils.h"
19 #include "Support/CommandLine.h"
20 #include "Support/Debug.h"
21 #include "Support/FileUtilities.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 GCCArgs.push_back((fileType == AsmFile) ? "assembler" : "c");
172 GCCArgs.push_back(ProgramFile.c_str()); // Specify the input filename...
173 GCCArgs.push_back("-o");
174 GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file...
175 GCCArgs.push_back("-lm"); // Hard-code the math library...
176 GCCArgs.push_back("-O2"); // Optimize the program a bit...
177 GCCArgs.push_back(0); // NULL terminator
179 std::cout << "<gcc>" << std::flush;
180 if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], "/dev/null", "/dev/null",
182 ProcessFailure(&GCCArgs[0]);
186 std::vector<const char*> ProgramArgs;
187 ProgramArgs.push_back(OutputBinary.c_str());
188 // Add optional parameters to the running program from Argv
189 for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
190 ProgramArgs.push_back(InputArgv[i].c_str());
191 ProgramArgs.push_back(0); // NULL terminator
193 // Now that we have a binary, run it!
194 std::cout << "<program>" << std::flush;
195 DEBUG(std::cerr << "\nAbout to run:\n\t";
196 for (unsigned i=0, e = ProgramArgs.size(); i != e; ++i)
197 std::cerr << " " << ProgramArgs[i];
200 int ProgramResult = RunProgramWithTimeout(OutputBinary, &ProgramArgs[0],
201 InputFile, OutputFile, OutputFile);
202 removeFile(OutputBinary);
203 return ProgramResult;
206 int GCC::MakeSharedObject(const std::string &InputFile,
208 std::string &OutputFile) {
209 OutputFile = getUniqueFilename("./bugpoint.so");
210 // Compile the C/asm file into a shared object
211 const char* GCCArgs[] = {
213 "-x", (fileType == AsmFile) ? "assembler" : "c",
214 InputFile.c_str(), // Specify the input filename...
215 #if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
216 "-G", // Compile a shared library, `-G' for Sparc
218 "-shared", // `-shared' for Linux/X86, maybe others
220 "-o", OutputFile.c_str(), // Output to the right filename...
221 "-O2", // Optimize the program a bit...
225 std::cout << "<gcc>" << std::flush;
226 if(RunProgramWithTimeout(GCCPath, GCCArgs, "/dev/null", "/dev/null",
228 ProcessFailure(GCCArgs);
234 void GCC::ProcessFailure(const char** GCCArgs) {
235 std::cerr << "\n*** bugpoint error: invocation of the C compiler failed!\n";
236 for (const char **Arg = GCCArgs; *Arg; ++Arg)
237 std::cerr << " " << *Arg;
240 // Rerun the compiler, capturing any error messages to print them.
241 std::string ErrorFilename = getUniqueFilename("bugpoint.gcc.errors");
242 RunProgramWithTimeout(GCCPath, GCCArgs, "/dev/null", ErrorFilename.c_str(),
243 ErrorFilename.c_str());
245 // Print out the error messages generated by GCC if possible...
246 std::ifstream ErrorFile(ErrorFilename.c_str());
248 std::copy(std::istreambuf_iterator<char>(ErrorFile),
249 std::istreambuf_iterator<char>(),
250 std::ostreambuf_iterator<char>(std::cerr));
255 removeFile(ErrorFilename);
258 //===----------------------------------------------------------------------===//
259 // LLC Implementation of AbstractIntepreter interface
261 class LLC : public AbstractInterpreter {
262 std::string LLCPath; // The path to the LLC executable
265 LLC(const std::string &llcPath, GCC *Gcc)
266 : LLCPath(llcPath), gcc(Gcc) { }
267 ~LLC() { delete gcc; }
269 // LLC create method - Try to find the LLC executable
270 static LLC *create(BugDriver *BD, std::string &Message) {
271 std::string LLCPath = FindExecutable("llc", BD->getToolName());
272 if (LLCPath.empty()) {
273 Message = "Cannot find `llc' in bugpoint executable directory or PATH!\n";
277 Message = "Found llc: " + LLCPath + "\n";
278 GCC *gcc = GCC::create(BD, Message);
280 std::cerr << Message << "\n";
283 return new LLC(LLCPath, gcc);
286 virtual int ExecuteProgram(const std::string &Bytecode,
287 const std::string &OutputFile,
288 const std::string &SharedLib = "");
290 int OutputAsm(const std::string &Bytecode,
291 std::string &OutputAsmFile);
294 int LLC::OutputAsm(const std::string &Bytecode,
295 std::string &OutputAsmFile) {
296 OutputAsmFile = "bugpoint.llc.s";
297 const char *LLCArgs[] = {
299 "-o", OutputAsmFile.c_str(), // Output to the Asm file
300 "-f", // Overwrite as necessary...
301 Bytecode.c_str(), // This is the input bytecode
305 std::cout << "<llc>" << std::flush;
306 if (RunProgramWithTimeout(LLCPath, LLCArgs, "/dev/null", "/dev/null",
308 // If LLC failed on the bytecode, print error...
309 std::cerr << "bugpoint error: `llc' failed!\n";
310 removeFile(OutputAsmFile);
317 int LLC::ExecuteProgram(const std::string &Bytecode,
318 const std::string &OutputFile,
319 const std::string &SharedLib) {
321 std::string OutputAsmFile;
322 if (OutputAsm(Bytecode, OutputAsmFile)) {
323 std::cerr << "Could not generate asm code with `llc', exiting.\n";
327 // Assuming LLC worked, compile the result with GCC and run it.
328 int Result = gcc->ExecuteProgram(OutputAsmFile,AsmFile,OutputFile,SharedLib);
329 removeFile(OutputAsmFile);
334 //===----------------------------------------------------------------------===//
335 // JIT Implementation of AbstractIntepreter interface
337 class JIT : public AbstractInterpreter {
338 std::string LLIPath; // The path to the LLI executable
340 JIT(const std::string &Path) : LLIPath(Path) { }
342 // JIT create method - Try to find the LLI executable
343 static JIT *create(BugDriver *BD, std::string &Message) {
344 std::string LLIPath = FindExecutable("lli", BD->getToolName());
345 if (!LLIPath.empty()) {
346 Message = "Found lli: " + LLIPath + "\n";
347 return new JIT(LLIPath);
350 Message = "Cannot find `lli' in bugpoint executable directory or PATH!\n";
353 virtual int ExecuteProgram(const std::string &Bytecode,
354 const std::string &OutputFile,
355 const std::string &SharedLib = "");
358 int JIT::ExecuteProgram(const std::string &Bytecode,
359 const std::string &OutputFile,
360 const std::string &SharedLib) {
361 // Construct a vector of parameters, incorporating those from the command-line
362 std::vector<const char*> JITArgs;
363 JITArgs.push_back(LLIPath.c_str());
364 JITArgs.push_back("-quiet");
365 JITArgs.push_back("-force-interpreter=false");
366 if (!SharedLib.empty()) {
367 JITArgs.push_back("-load");
368 JITArgs.push_back(SharedLib.c_str());
370 JITArgs.push_back(Bytecode.c_str());
371 // Add optional parameters to the running program from Argv
372 for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
373 JITArgs.push_back(InputArgv[i].c_str());
374 JITArgs.push_back(0);
376 std::cout << "<jit>" << std::flush;
377 DEBUG(std::cerr << "\nAbout to run:\n\t";
378 for (unsigned i=0, e = JITArgs.size(); i != e; ++i)
379 std::cerr << " " << JITArgs[i];
382 DEBUG(std::cerr << "\nSending output to " << OutputFile << "\n");
383 return RunProgramWithTimeout(LLIPath, &JITArgs[0],
384 InputFile, OutputFile, OutputFile);
387 //===----------------------------------------------------------------------===//
388 // CBE Implementation of AbstractIntepreter interface
390 class CBE : public AbstractInterpreter {
391 std::string DISPath; // The path to the LLVM 'dis' executable
394 CBE(const std::string &disPath, GCC *Gcc) : DISPath(disPath), gcc(Gcc) { }
395 ~CBE() { delete gcc; }
397 // CBE create method - Try to find the 'dis' executable
398 static CBE *create(BugDriver *BD, std::string &Message) {
399 std::string DISPath = FindExecutable("dis", BD->getToolName());
400 if (DISPath.empty()) {
401 Message = "Cannot find `dis' in bugpoint executable directory or PATH!\n";
405 Message = "Found dis: " + DISPath + "\n";
407 GCC *gcc = GCC::create(BD, Message);
409 std::cerr << Message << "\n";
412 return new CBE(DISPath, gcc);
415 virtual int ExecuteProgram(const std::string &Bytecode,
416 const std::string &OutputFile,
417 const std::string &SharedLib = "");
419 // Sometimes we just want to go half-way and only generate the C file,
420 // not necessarily compile it with GCC and run the program
421 virtual int OutputC(const std::string &Bytecode,
422 std::string &OutputCFile);
426 int CBE::OutputC(const std::string &Bytecode,
427 std::string &OutputCFile) {
428 OutputCFile = "bugpoint.cbe.c";
429 const char *DisArgs[] = {
431 "-o", OutputCFile.c_str(), // Output to the C file
433 "-f", // Overwrite as necessary...
434 Bytecode.c_str(), // This is the input bytecode
438 std::cout << "<cbe>" << std::flush;
439 if (RunProgramWithTimeout(DISPath, DisArgs, "/dev/null", "/dev/null",
441 // If dis failed on the bytecode, print error...
442 std::cerr << "bugpoint error: `dis -c' failed!\n";
450 int CBE::ExecuteProgram(const std::string &Bytecode,
451 const std::string &OutputFile,
452 const std::string &SharedLib) {
453 std::string OutputCFile;
454 if (OutputC(Bytecode, OutputCFile)) {
455 std::cerr << "Could not generate C code with `dis', exiting.\n";
459 int Result = gcc->ExecuteProgram(OutputCFile, CFile, OutputFile, SharedLib);
460 removeFile(OutputCFile);
466 //===----------------------------------------------------------------------===//
467 // BugDriver method implementation
470 /// initializeExecutionEnvironment - This method is used to set up the
471 /// environment for executing LLVM programs.
473 bool BugDriver::initializeExecutionEnvironment() {
474 std::cout << "Initializing execution environment: ";
476 // FIXME: This should default to searching for the best interpreter to use on
477 // this platform, which would be JIT, then LLC, then CBE, then LLI.
479 // Create an instance of the AbstractInterpreter interface as specified on the
482 switch (InterpreterSel) {
483 case RunLLI: Interpreter = LLI::create(this, Message); break;
484 case RunLLC: Interpreter = LLC::create(this, Message); break;
485 case RunJIT: Interpreter = JIT::create(this, Message); break;
486 case RunCBE: Interpreter = CBE::create(this, Message); break;
488 Message = " Sorry, this back-end is not supported by bugpoint right now!\n";
492 std::cout << Message;
494 // Initialize auxiliary tools for debugging
495 cbe = CBE::create(this, Message);
496 if (!cbe) { std::cout << Message << "\nExiting.\n"; exit(1); }
497 gcc = GCC::create(this, Message);
498 if (!gcc) { std::cout << Message << "\nExiting.\n"; exit(1); }
500 // If there was an error creating the selected interpreter, quit with error.
501 return Interpreter == 0;
505 /// executeProgram - This method runs "Program", capturing the output of the
506 /// program to a file, returning the filename of the file. A recommended
507 /// filename may be optionally specified.
509 std::string BugDriver::executeProgram(std::string OutputFile,
510 std::string BytecodeFile,
511 std::string SharedObject,
512 AbstractInterpreter *AI) {
513 assert((Interpreter || AI) &&"Interpreter should have been created already!");
514 bool CreatedBytecode = false;
515 if (BytecodeFile.empty()) {
516 // Emit the program to a bytecode file...
517 BytecodeFile = getUniqueFilename("bugpoint-test-program.bc");
519 if (writeProgramToFile(BytecodeFile, Program)) {
520 std::cerr << ToolName << ": Error emitting bytecode to file '"
521 << BytecodeFile << "'!\n";
524 CreatedBytecode = true;
527 if (OutputFile.empty()) OutputFile = "bugpoint-execution-output";
529 // Check to see if this is a valid output filename...
530 OutputFile = getUniqueFilename(OutputFile);
532 // Actually execute the program!
533 int RetVal = (AI != 0) ?
534 AI->ExecuteProgram(BytecodeFile, OutputFile, SharedObject) :
535 Interpreter->ExecuteProgram(BytecodeFile, OutputFile, SharedObject);
537 // Remove the temporary bytecode file.
538 if (CreatedBytecode) removeFile(BytecodeFile);
540 // Return the filename we captured the output to.
544 std::string BugDriver::executeProgramWithCBE(std::string OutputFile,
545 std::string BytecodeFile,
546 std::string SharedObject) {
547 return executeProgram(OutputFile, BytecodeFile, SharedObject, cbe);
550 int BugDriver::compileSharedObject(const std::string &BytecodeFile,
551 std::string &SharedObject) {
552 assert(Interpreter && "Interpreter should have been created already!");
553 std::string Message, OutputCFile;
556 cbe->OutputC(BytecodeFile, OutputCFile);
558 #if 0 /* This is an alternative, as yet unimplemented */
560 LLC *llc = LLC::create(this, Message);
561 if (llc->OutputAsm(BytecodeFile, OutputFile)) {
562 std::cerr << "Could not generate asm code with `llc', exiting.\n";
567 gcc->MakeSharedObject(OutputCFile, CFile, SharedObject);
569 // Remove the intermediate C file
570 removeFile(OutputCFile);
576 /// diffProgram - This method executes the specified module and diffs the output
577 /// against the file specified by ReferenceOutputFile. If the output is
578 /// different, true is returned.
580 bool BugDriver::diffProgram(const std::string &BytecodeFile,
581 const std::string &SharedObject,
582 bool RemoveBytecode) {
583 // Execute the program, generating an output file...
584 std::string Output = executeProgram("", BytecodeFile, SharedObject);
587 bool FilesDifferent = false;
588 if (DiffFiles(ReferenceOutputFile, Output, &Error)) {
589 if (!Error.empty()) {
590 std::cerr << "While diffing output: " << Error << "\n";
593 FilesDifferent = true;
596 if (RemoveBytecode) removeFile(BytecodeFile);
597 return FilesDifferent;
600 bool BugDriver::isExecutingJIT() {
601 return InterpreterSel == RunJIT;