blob: 596aeb95a887934a2563034b1a15a42f3458f4b4 [file] [log] [blame]
//===- 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, e.g. default to the first input filename.
#include "BugDriver.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>
namespace {
// OutputType - Allow the user to specify the way code should be run, to test
// for miscompilation.
enum OutputType {
AutoPick, RunLLI, RunJIT, RunLLC, RunCBE
InterpreterSel(cl::desc("Specify how LLVM code should be executed:"),
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"),
InputFile("input", cl::init("/dev/null"),
cl::desc("Filename to pipe in as stdin (default: /dev/null)"));
cl::desc("Additional shared objects to load "
"into executing programs"));
// Anything specified after the --args option are taken as arguments to the
// program being debugged.
InputArgv("args", cl::Positional, cl::desc("<program arguments>..."),
// BugDriver method implementation
/// initializeExecutionEnvironment - This method is used to set up the
/// environment for executing LLVM programs.
bool BugDriver::initializeExecutionEnvironment() {
std::cout << "Initializing execution environment: ";
// Create an instance of the AbstractInterpreter interface as specified on
// the command line
std::string Message;
switch (InterpreterSel) {
case AutoPick:
InterpreterSel = RunCBE;
Interpreter = 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";
case RunLLI:
Interpreter = AbstractInterpreter::createLLI(getToolName(), Message);
case RunLLC:
Interpreter = AbstractInterpreter::createLLC(getToolName(), Message);
case RunJIT:
Interpreter = AbstractInterpreter::createJIT(getToolName(), Message);
case RunCBE:
Interpreter = AbstractInterpreter::createCBE(getToolName(), Message);
Message = "Sorry, this back-end is not supported by bugpoint right now!\n";
std::cerr << Message;
// Initialize auxiliary tools for debugging
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;
/// 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,
const std::string &SharedObj,
AbstractInterpreter *AI) {
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...
BytecodeFile = getUniqueFilename("bugpoint-test-program.bc");
if (writeProgramToFile(BytecodeFile, Program)) {
std::cerr << ToolName << ": Error emitting bytecode to file '"
<< BytecodeFile << "'!\n";
CreatedBytecode = true;
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())
// Actually execute the program!
int RetVal = AI->ExecuteProgram(BytecodeFile, InputArgv, InputFile,
OutputFile, SharedObjs);
// Remove the temporary bytecode file.
if (CreatedBytecode) removeFile(BytecodeFile);
// Return the filename we captured the output to.
return OutputFile;
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";
std::string SharedObjectFile;
if (gcc->MakeSharedObject(OutputCFile, GCC::CFile, SharedObjectFile))
// Remove the intermediate C file
return "./" + SharedObjectFile;
/// 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) {
// Execute the program, generating an output file...
std::string Output = executeProgram("", BytecodeFile, SharedObject);
std::string Error;
bool FilesDifferent = false;
if (DiffFiles(ReferenceOutputFile, Output, &Error)) {
if (!Error.empty()) {
std::cerr << "While diffing output: " << Error << "\n";
FilesDifferent = true;
// Remove the generated output.
// Remove the bytecode file if we are supposed to.
if (RemoveBytecode) removeFile(BytecodeFile);
return FilesDifferent;
bool BugDriver::isExecutingJIT() {
return InterpreterSel == RunJIT;