//===- ExecutionDriver.cpp - Allow execution of LLVM program --------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// This file contains code used to execute the program utilizing one of the
// various ways of running LLVM bytecode.
1. Bugpoint should not leave any files behind if the program works properly
2. There should be an option to specify the program name, which specifies a
unique string to put into output files. This allows operation in the
- SingleSource directory f.e. Default to the first input filename.
+ SingleSource directory, e.g. default to the first input filename.
*/
#include "BugDriver.h"
-#include "SystemUtils.h"
#include "Support/CommandLine.h"
+#include "Support/Debug.h"
+#include "Support/FileUtilities.h"
+#include "Support/SystemUtils.h"
+#include "llvm/Support/ToolRunner.h"
#include <fstream>
#include <iostream>
+using namespace llvm;
namespace {
// OutputType - Allow the user to specify the way code should be run, to test
// for miscompilation.
//
enum OutputType {
- RunLLI, RunJIT, RunLLC, RunCBE
+ AutoPick, RunLLI, RunJIT, RunLLC, RunCBE
};
+
cl::opt<OutputType>
InterpreterSel(cl::desc("Specify how LLVM code should be executed:"),
- cl::values(clEnumValN(RunLLI, "run-lli", "Execute with LLI"),
- clEnumValN(RunJIT, "run-jit", "Execute with JIT"),
- clEnumValN(RunLLC, "run-llc", "Compile with LLC"),
- clEnumValN(RunCBE, "run-cbe", "Compile with CBE"),
- 0));
+ cl::values(clEnumValN(AutoPick, "auto", "Use best guess"),
+ clEnumValN(RunLLI, "run-int", "Execute with the interpreter"),
+ clEnumValN(RunJIT, "run-jit", "Execute with JIT"),
+ clEnumValN(RunLLC, "run-llc", "Compile with LLC"),
+ clEnumValN(RunCBE, "run-cbe", "Compile with CBE"),
+ 0),
+ cl::init(AutoPick));
+
+ cl::opt<bool>
+ CheckProgramExitCode("check-exit-code",
+ cl::desc("Assume nonzero exit code is failure (default on)"),
+ cl::init(true));
cl::opt<std::string>
InputFile("input", cl::init("/dev/null"),
cl::desc("Filename to pipe in as stdin (default: /dev/null)"));
-}
-
-/// AbstractInterpreter Class - Subclasses of this class are used to execute
-/// LLVM bytecode in a variety of ways. This abstract interface hides this
-/// complexity behind a simple interface.
-///
-struct AbstractInterpreter {
-
- virtual ~AbstractInterpreter() {}
-
- /// ExecuteProgram - Run the specified bytecode file, emitting output to the
- /// specified filename. This returns the exit code of the program.
- ///
- virtual int ExecuteProgram(const std::string &Bytecode,
- const std::string &OutputFile) = 0;
-
-};
-
-//===----------------------------------------------------------------------===//
-// LLI Implementation of AbstractIntepreter interface
-//
-class LLI : public AbstractInterpreter {
- std::string LLIPath; // The path to the LLI executable
-public:
- LLI(const std::string &Path) : LLIPath(Path) { }
-
- // LLI create method - Try to find the LLI executable
- static LLI *create(BugDriver *BD, std::string &Message) {
- std::string LLIPath = FindExecutable("lli", BD->getToolName());
- if (!LLIPath.empty()) {
- Message = "Found lli: " + LLIPath + "\n";
- return new LLI(LLIPath);
- }
-
- Message = "Cannot find 'lli' in bugpoint executable directory or PATH!\n";
- return 0;
- }
- virtual int ExecuteProgram(const std::string &Bytecode,
- const std::string &OutputFile);
-};
-
-int LLI::ExecuteProgram(const std::string &Bytecode,
- const std::string &OutputFile) {
- const char *Args[] = {
- "-abort-on-exception",
- "-quiet",
- Bytecode.c_str(),
- 0
- };
-
- return RunProgramWithTimeout(LLIPath, Args,
- InputFile, OutputFile, OutputFile);
+ cl::list<std::string>
+ AdditionalSOs("additional-so",
+ cl::desc("Additional shared objects to load "
+ "into executing programs"));
}
+namespace llvm {
+ // Anything specified after the --args option are taken as arguments to the
+ // program being debugged.
+ cl::list<std::string>
+ InputArgv("args", cl::Positional, cl::desc("<program arguments>..."),
+ cl::ZeroOrMore);
+}
//===----------------------------------------------------------------------===//
// BugDriver method implementation
bool BugDriver::initializeExecutionEnvironment() {
std::cout << "Initializing execution environment: ";
- // FIXME: This should default to searching for the best interpreter to use on
- // this platform, which would be JIT, then LLC, then CBE, then LLI.
-
- // Create an instance of the AbstractInterpreter interface as specified on the
- // command line
+ // Create an instance of the AbstractInterpreter interface as specified on
+ // the command line
+ cbe = 0;
std::string Message;
- if (InterpreterSel == RunLLI) {
- Interpreter = LLI::create(this, Message);
- } else {
- Message = " Sorry, only LLI is supported right now!";
+ switch (InterpreterSel) {
+ case AutoPick:
+ InterpreterSel = RunCBE;
+ Interpreter = cbe = AbstractInterpreter::createCBE(getToolName(), Message);
+ if (!Interpreter) {
+ InterpreterSel = RunJIT;
+ Interpreter = AbstractInterpreter::createJIT(getToolName(), Message);
+ }
+ if (!Interpreter) {
+ InterpreterSel = RunLLC;
+ Interpreter = AbstractInterpreter::createLLC(getToolName(), Message);
+ }
+ if (!Interpreter) {
+ InterpreterSel = RunLLI;
+ Interpreter = AbstractInterpreter::createLLI(getToolName(), Message);
+ }
+ if (!Interpreter) {
+ InterpreterSel = AutoPick;
+ Message = "Sorry, I can't automatically select an interpreter!\n";
+ }
+ break;
+ case RunLLI:
+ Interpreter = AbstractInterpreter::createLLI(getToolName(), Message);
+ break;
+ case RunLLC:
+ Interpreter = AbstractInterpreter::createLLC(getToolName(), Message);
+ break;
+ case RunJIT:
+ Interpreter = AbstractInterpreter::createJIT(getToolName(), Message);
+ break;
+ case RunCBE:
+ Interpreter = cbe = AbstractInterpreter::createCBE(getToolName(), Message);
+ break;
+ default:
+ Message = "Sorry, this back-end is not supported by bugpoint right now!\n";
+ break;
}
+ std::cerr << Message;
- std::cout << Message;
+ // Initialize auxiliary tools for debugging
+ if (!cbe) {
+ cbe = AbstractInterpreter::createCBE(getToolName(), Message);
+ if (!cbe) { std::cout << Message << "\nExiting.\n"; exit(1); }
+ }
+ gcc = GCC::create(getToolName(), Message);
+ if (!gcc) { std::cout << Message << "\nExiting.\n"; exit(1); }
// If there was an error creating the selected interpreter, quit with error.
return Interpreter == 0;
}
+/// compileProgram - Try to compile the specified module, throwing an exception
+/// if an error occurs, or returning normally if not. This is used for code
+/// generation crash testing.
+///
+void BugDriver::compileProgram(Module *M) {
+ // Emit the program to a bytecode file...
+ std::string BytecodeFile = getUniqueFilename("bugpoint-test-program.bc");
+ if (writeProgramToFile(BytecodeFile, M)) {
+ std::cerr << ToolName << ": Error emitting bytecode to file '"
+ << BytecodeFile << "'!\n";
+ exit(1);
+ }
+
+ // Remove the temporary bytecode file when we are done.
+ FileRemover BytecodeFileRemover(BytecodeFile);
+
+ // Actually compile the program!
+ Interpreter->compileProgram(BytecodeFile);
+}
+
/// executeProgram - This method runs "Program", capturing the output of the
/// program to a file, returning the filename of the file. A recommended
/// filename may be optionally specified.
///
std::string BugDriver::executeProgram(std::string OutputFile,
- std::string BytecodeFile) {
- assert(Interpreter && "Interpreter should have been created already!");
+ std::string BytecodeFile,
+ const std::string &SharedObj,
+ AbstractInterpreter *AI,
+ bool *ProgramExitedNonzero) {
+ if (AI == 0) AI = Interpreter;
+ assert(AI && "Interpreter should have been created already!");
bool CreatedBytecode = false;
if (BytecodeFile.empty()) {
// Emit the program to a bytecode file...
if (writeProgramToFile(BytecodeFile, Program)) {
std::cerr << ToolName << ": Error emitting bytecode to file '"
- << BytecodeFile << "'!\n";
+ << BytecodeFile << "'!\n";
exit(1);
}
CreatedBytecode = true;
}
+ // Remove the temporary bytecode file when we are done.
+ FileRemover BytecodeFileRemover(BytecodeFile, CreatedBytecode);
+
if (OutputFile.empty()) OutputFile = "bugpoint-execution-output";
-
+
// Check to see if this is a valid output filename...
OutputFile = getUniqueFilename(OutputFile);
+ // Figure out which shared objects to run, if any.
+ std::vector<std::string> SharedObjs(AdditionalSOs);
+ if (!SharedObj.empty())
+ SharedObjs.push_back(SharedObj);
+
// Actually execute the program!
- int RetVal = Interpreter->ExecuteProgram(BytecodeFile, OutputFile);
+ int RetVal = AI->ExecuteProgram(BytecodeFile, InputArgv, InputFile,
+ OutputFile, SharedObjs);
- // Remove the temporary bytecode file.
- if (CreatedBytecode)
- removeFile(BytecodeFile);
+ if (ProgramExitedNonzero != 0)
+ *ProgramExitedNonzero = (RetVal != 0);
// Return the filename we captured the output to.
return OutputFile;
}
-/// diffProgram - This method executes the specified module and diffs the output
-/// against the file specified by ReferenceOutputFile. If the output is
-/// different, true is returned.
+/// executeProgramWithCBE - Used to create reference output with the C
+/// backend, if reference output is not provided.
///
-bool BugDriver::diffProgram(const std::string &ReferenceOutputFile,
- const std::string &BytecodeFile,
- bool RemoveBytecode) {
- // Execute the program, generating an output file...
- std::string Output = executeProgram("", BytecodeFile);
+std::string BugDriver::executeProgramWithCBE(std::string OutputFile) {
+ bool ProgramExitedNonzero;
+ std::string outFN = executeProgram(OutputFile, "", "",
+ (AbstractInterpreter*)cbe,
+ &ProgramExitedNonzero);
+ if (ProgramExitedNonzero) {
+ std::cerr
+ << "Warning: While generating reference output, program exited with\n"
+ << "non-zero exit code. This will NOT be treated as a failure.\n";
+ CheckProgramExitCode = false;
+ }
+ return outFN;
+}
- std::ifstream ReferenceFile(ReferenceOutputFile.c_str());
- if (!ReferenceFile) {
- std::cerr << "Couldn't open reference output file '"
- << ReferenceOutputFile << "'\n";
+std::string BugDriver::compileSharedObject(const std::string &BytecodeFile) {
+ assert(Interpreter && "Interpreter should have been created already!");
+ std::string OutputCFile;
+
+ // Using CBE
+ cbe->OutputC(BytecodeFile, OutputCFile);
+
+#if 0 /* This is an alternative, as yet unimplemented */
+ // Using LLC
+ std::string Message;
+ LLC *llc = createLLCtool(Message);
+ if (llc->OutputAsm(BytecodeFile, OutputFile)) {
+ std::cerr << "Could not generate asm code with `llc', exiting.\n";
exit(1);
}
+#endif
- std::ifstream OutputFile(Output.c_str());
- if (!OutputFile) {
- std::cerr << "Couldn't open output file: " << Output << "'!\n";
+ std::string SharedObjectFile;
+ if (gcc->MakeSharedObject(OutputCFile, GCC::CFile, SharedObjectFile))
exit(1);
- }
- bool FilesDifferent = false;
+ // Remove the intermediate C file
+ removeFile(OutputCFile);
+
+ return "./" + SharedObjectFile;
+}
+
- // Compare the two files...
- int C1, C2;
- do {
- C1 = ReferenceFile.get();
- C2 = OutputFile.get();
- if (C1 != C2) { FilesDifferent = true; break; }
- } while (C1 != EOF);
+/// diffProgram - This method executes the specified module and diffs the output
+/// against the file specified by ReferenceOutputFile. If the output is
+/// different, true is returned.
+///
+bool BugDriver::diffProgram(const std::string &BytecodeFile,
+ const std::string &SharedObject,
+ bool RemoveBytecode) {
+ bool ProgramExitedNonzero;
+ // Execute the program, generating an output file...
+ std::string Output = executeProgram("", BytecodeFile, SharedObject, 0,
+ &ProgramExitedNonzero);
+
+ // If we're checking the program exit code, assume anything nonzero is bad.
+ if (CheckProgramExitCode && ProgramExitedNonzero) {
+ removeFile(Output);
+ if (RemoveBytecode) removeFile(BytecodeFile);
+ return true;
+ }
+
+ std::string Error;
+ bool FilesDifferent = false;
+ if (DiffFiles(ReferenceOutputFile, Output, &Error)) {
+ if (!Error.empty()) {
+ std::cerr << "While diffing output: " << Error << "\n";
+ exit(1);
+ }
+ FilesDifferent = true;
+ }
+
+ // Remove the generated output.
removeFile(Output);
+
+ // Remove the bytecode file if we are supposed to.
if (RemoveBytecode) removeFile(BytecodeFile);
return FilesDifferent;
}
+
+bool BugDriver::isExecutingJIT() {
+ return InterpreterSel == RunJIT;
+}
+