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 "SystemUtils.h"
19 #include "Support/CommandLine.h"
20 #include "Support/Statistic.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>";
115 DEBUG(std::cerr << "About 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>";
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>";
195 DEBUG(std::cerr << "About 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);
203 removeFile(OutputBinary);
204 return ProgramResult;
207 int GCC::MakeSharedObject(const std::string &InputFile,
209 std::string &OutputFile) {
210 OutputFile = getUniqueFilename("./bugpoint.so");
211 // Compile the C/asm file into a shared object
212 const char* GCCArgs[] = {
214 "-x", (fileType == AsmFile) ? "assembler" : "c",
215 InputFile.c_str(), // Specify the input filename...
216 #if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
217 "-G", // Compile a shared library, `-G' for Sparc
219 "-shared", // `-shared' for Linux/X86, maybe others
221 "-o", OutputFile.c_str(), // Output to the right filename...
222 "-O2", // Optimize the program a bit...
226 std::cout << "<gcc>";
227 if(RunProgramWithTimeout(GCCPath, GCCArgs, "/dev/null", "/dev/null",
229 ProcessFailure(GCCArgs);
235 void GCC::ProcessFailure(const char** GCCArgs) {
236 std::cerr << "\n*** bugpoint error: invocation of the C compiler failed!\n";
237 for (const char **Arg = GCCArgs; *Arg; ++Arg)
238 std::cerr << " " << *Arg;
241 // Rerun the compiler, capturing any error messages to print them.
242 std::string ErrorFilename = getUniqueFilename("bugpoint.gcc.errors");
243 RunProgramWithTimeout(GCCPath, GCCArgs, "/dev/null", ErrorFilename.c_str(),
244 ErrorFilename.c_str());
246 // Print out the error messages generated by GCC if possible...
247 std::ifstream ErrorFile(ErrorFilename.c_str());
249 std::copy(std::istreambuf_iterator<char>(ErrorFile),
250 std::istreambuf_iterator<char>(),
251 std::ostreambuf_iterator<char>(std::cerr));
256 removeFile(ErrorFilename);
259 //===----------------------------------------------------------------------===//
260 // LLC Implementation of AbstractIntepreter interface
262 class LLC : public AbstractInterpreter {
263 std::string LLCPath; // The path to the LLC executable
266 LLC(const std::string &llcPath, GCC *Gcc)
267 : LLCPath(llcPath), gcc(Gcc) { }
268 ~LLC() { delete gcc; }
270 // LLC create method - Try to find the LLC executable
271 static LLC *create(BugDriver *BD, std::string &Message) {
272 std::string LLCPath = FindExecutable("llc", BD->getToolName());
273 if (LLCPath.empty()) {
274 Message = "Cannot find `llc' in bugpoint executable directory or PATH!\n";
278 Message = "Found llc: " + LLCPath + "\n";
279 GCC *gcc = GCC::create(BD, Message);
281 std::cerr << Message << "\n";
284 return new LLC(LLCPath, gcc);
287 virtual int ExecuteProgram(const std::string &Bytecode,
288 const std::string &OutputFile,
289 const std::string &SharedLib = "");
291 int OutputAsm(const std::string &Bytecode,
292 std::string &OutputAsmFile);
295 int LLC::OutputAsm(const std::string &Bytecode,
296 std::string &OutputAsmFile) {
297 OutputAsmFile = "bugpoint.llc.s";
298 const char *LLCArgs[] = {
300 "-o", OutputAsmFile.c_str(), // Output to the Asm file
301 "-f", // Overwrite as necessary...
302 Bytecode.c_str(), // This is the input bytecode
306 std::cout << "<llc>";
307 if (RunProgramWithTimeout(LLCPath, LLCArgs, "/dev/null", "/dev/null",
309 // If LLC failed on the bytecode, print error...
310 std::cerr << "bugpoint error: `llc' failed!\n";
311 removeFile(OutputAsmFile);
318 int LLC::ExecuteProgram(const std::string &Bytecode,
319 const std::string &OutputFile,
320 const std::string &SharedLib) {
322 std::string OutputAsmFile;
323 if (OutputAsm(Bytecode, OutputAsmFile)) {
324 std::cerr << "Could not generate asm code with `llc', exiting.\n";
328 // Assuming LLC worked, compile the result with GCC and run it.
329 int Result = gcc->ExecuteProgram(OutputAsmFile,AsmFile,OutputFile,SharedLib);
330 removeFile(OutputAsmFile);
335 //===----------------------------------------------------------------------===//
336 // JIT Implementation of AbstractIntepreter interface
338 class JIT : public AbstractInterpreter {
339 std::string LLIPath; // The path to the LLI executable
341 JIT(const std::string &Path) : LLIPath(Path) { }
343 // JIT create method - Try to find the LLI executable
344 static JIT *create(BugDriver *BD, std::string &Message) {
345 std::string LLIPath = FindExecutable("lli", BD->getToolName());
346 if (!LLIPath.empty()) {
347 Message = "Found lli: " + LLIPath + "\n";
348 return new JIT(LLIPath);
351 Message = "Cannot find `lli' in bugpoint executable directory or PATH!\n";
354 virtual int ExecuteProgram(const std::string &Bytecode,
355 const std::string &OutputFile,
356 const std::string &SharedLib = "");
359 int JIT::ExecuteProgram(const std::string &Bytecode,
360 const std::string &OutputFile,
361 const std::string &SharedLib) {
362 // Construct a vector of parameters, incorporating those from the command-line
363 std::vector<const char*> JITArgs;
364 JITArgs.push_back(LLIPath.c_str());
365 JITArgs.push_back("-quiet");
366 JITArgs.push_back("-force-interpreter=false");
367 if (!SharedLib.empty()) {
368 JITArgs.push_back("-load");
369 JITArgs.push_back(SharedLib.c_str());
371 JITArgs.push_back(Bytecode.c_str());
372 // Add optional parameters to the running program from Argv
373 for (unsigned i=0, e = InputArgv.size(); i != e; ++i)
374 JITArgs.push_back(InputArgv[i].c_str());
375 JITArgs.push_back(0);
377 std::cout << "<jit>\n";
378 DEBUG(std::cerr << "About to run:\n\t";
379 for (unsigned i=0, e = JITArgs.size(); i != e; ++i)
380 std::cerr << " " << JITArgs[i];
383 DEBUG(std::cerr << "\nSending output to " << OutputFile << "\n");
384 return RunProgramWithTimeout(LLIPath, &JITArgs[0],
385 InputFile, OutputFile, OutputFile);
388 //===----------------------------------------------------------------------===//
389 // CBE Implementation of AbstractIntepreter interface
391 class CBE : public AbstractInterpreter {
392 std::string DISPath; // The path to the LLVM 'dis' executable
395 CBE(const std::string &disPath, GCC *Gcc) : DISPath(disPath), gcc(Gcc) { }
396 ~CBE() { delete gcc; }
398 // CBE create method - Try to find the 'dis' executable
399 static CBE *create(BugDriver *BD, std::string &Message) {
400 std::string DISPath = FindExecutable("dis", BD->getToolName());
401 if (DISPath.empty()) {
402 Message = "Cannot find `dis' in bugpoint executable directory or PATH!\n";
406 Message = "Found dis: " + DISPath + "\n";
408 GCC *gcc = GCC::create(BD, Message);
410 std::cerr << Message << "\n";
413 return new CBE(DISPath, gcc);
416 virtual int ExecuteProgram(const std::string &Bytecode,
417 const std::string &OutputFile,
418 const std::string &SharedLib = "");
420 // Sometimes we just want to go half-way and only generate the C file,
421 // not necessarily compile it with GCC and run the program
422 virtual int OutputC(const std::string &Bytecode,
423 std::string &OutputCFile);
427 int CBE::OutputC(const std::string &Bytecode,
428 std::string &OutputCFile) {
429 OutputCFile = "bugpoint.cbe.c";
430 const char *DisArgs[] = {
432 "-o", OutputCFile.c_str(), // Output to the C file
434 "-f", // Overwrite as necessary...
435 Bytecode.c_str(), // This is the input bytecode
439 std::cout << "<cbe>";
440 if (RunProgramWithTimeout(DISPath, DisArgs, "/dev/null", "/dev/null",
442 // If dis failed on the bytecode, print error...
443 std::cerr << "bugpoint error: `dis -c' failed!\n";
451 int CBE::ExecuteProgram(const std::string &Bytecode,
452 const std::string &OutputFile,
453 const std::string &SharedLib) {
454 std::string OutputCFile;
455 if (OutputC(Bytecode, OutputCFile)) {
456 std::cerr << "Could not generate C code with `dis', exiting.\n";
460 int Result = gcc->ExecuteProgram(OutputCFile, CFile, OutputFile, SharedLib);
461 removeFile(OutputCFile);
467 //===----------------------------------------------------------------------===//
468 // BugDriver method implementation
471 /// initializeExecutionEnvironment - This method is used to set up the
472 /// environment for executing LLVM programs.
474 bool BugDriver::initializeExecutionEnvironment() {
475 std::cout << "Initializing execution environment: ";
477 // FIXME: This should default to searching for the best interpreter to use on
478 // this platform, which would be JIT, then LLC, then CBE, then LLI.
480 // Create an instance of the AbstractInterpreter interface as specified on the
483 switch (InterpreterSel) {
484 case RunLLI: Interpreter = LLI::create(this, Message); break;
485 case RunLLC: Interpreter = LLC::create(this, Message); break;
486 case RunJIT: Interpreter = JIT::create(this, Message); break;
487 case RunCBE: Interpreter = CBE::create(this, Message); break;
489 Message = " Sorry, this back-end is not supported by bugpoint right now!\n";
493 std::cout << Message;
495 // Initialize auxiliary tools for debugging
496 cbe = CBE::create(this, Message);
497 if (!cbe) { std::cout << Message << "\nExiting.\n"; exit(1); }
498 gcc = GCC::create(this, Message);
499 if (!gcc) { std::cout << Message << "\nExiting.\n"; exit(1); }
501 // If there was an error creating the selected interpreter, quit with error.
502 return Interpreter == 0;
506 /// executeProgram - This method runs "Program", capturing the output of the
507 /// program to a file, returning the filename of the file. A recommended
508 /// filename may be optionally specified.
510 std::string BugDriver::executeProgram(std::string OutputFile,
511 std::string BytecodeFile,
512 std::string SharedObject,
513 AbstractInterpreter *AI) {
514 assert((Interpreter || AI) &&"Interpreter should have been created already!");
515 bool CreatedBytecode = false;
516 if (BytecodeFile.empty()) {
517 // Emit the program to a bytecode file...
518 BytecodeFile = getUniqueFilename("bugpoint-test-program.bc");
520 if (writeProgramToFile(BytecodeFile, Program)) {
521 std::cerr << ToolName << ": Error emitting bytecode to file '"
522 << BytecodeFile << "'!\n";
525 CreatedBytecode = true;
528 if (OutputFile.empty()) OutputFile = "bugpoint-execution-output";
530 // Check to see if this is a valid output filename...
531 OutputFile = getUniqueFilename(OutputFile);
533 // Actually execute the program!
534 int RetVal = (AI != 0) ?
535 AI->ExecuteProgram(BytecodeFile, OutputFile, SharedObject) :
536 Interpreter->ExecuteProgram(BytecodeFile, OutputFile, SharedObject);
538 // Remove the temporary bytecode file.
539 if (CreatedBytecode) removeFile(BytecodeFile);
541 // Return the filename we captured the output to.
545 std::string BugDriver::executeProgramWithCBE(std::string OutputFile,
546 std::string BytecodeFile,
547 std::string SharedObject) {
548 return executeProgram(OutputFile, BytecodeFile, SharedObject, cbe);
551 int BugDriver::compileSharedObject(const std::string &BytecodeFile,
552 std::string &SharedObject) {
553 assert(Interpreter && "Interpreter should have been created already!");
554 std::string Message, OutputCFile;
557 cbe->OutputC(BytecodeFile, OutputCFile);
559 #if 0 /* This is an alternative, as yet unimplemented */
561 LLC *llc = LLC::create(this, Message);
562 if (llc->OutputAsm(BytecodeFile, OutputFile)) {
563 std::cerr << "Could not generate asm code with `llc', exiting.\n";
568 gcc->MakeSharedObject(OutputCFile, CFile, SharedObject);
570 // Remove the intermediate C file
571 removeFile(OutputCFile);
577 /// diffProgram - This method executes the specified module and diffs the output
578 /// against the file specified by ReferenceOutputFile. If the output is
579 /// different, true is returned.
581 bool BugDriver::diffProgram(const std::string &BytecodeFile,
582 const std::string &SharedObject,
583 bool RemoveBytecode) {
584 // Execute the program, generating an output file...
585 std::string Output = executeProgram("", BytecodeFile, SharedObject);
588 bool FilesDifferent = false;
589 if (DiffFiles(ReferenceOutputFile, Output, &Error)) {
590 if (!Error.empty()) {
591 std::cerr << "While diffing output: " << Error << "\n";
594 FilesDifferent = true;
597 if (RemoveBytecode) removeFile(BytecodeFile);
598 return FilesDifferent;
601 bool BugDriver::isExecutingJIT() {
602 return InterpreterSel == RunJIT;