1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
//===- ExecutionDriver.cpp - Allow execution of LLVM program --------------===//
//
// This file contains code used to execute the program utilizing one of the
// various ways of running LLVM bytecode.
//
//===----------------------------------------------------------------------===//
/*
BUGPOINT NOTES:
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.
*/
#include "BugDriver.h"
#include "SystemUtils.h"
#include "Support/CommandLine.h"
#include <fstream>
#include <iostream>
namespace {
// OutputType - Allow the user to specify the way code should be run, to test
// for miscompilation.
//
enum OutputType {
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));
}
/// 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,
"/dev/null", OutputFile, OutputFile);
}
//===----------------------------------------------------------------------===//
// 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: ";
// 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
std::string Message;
if (InterpreterSel == RunLLI) {
Interpreter = LLI::create(this, Message);
} else {
Message = " Sorry, only LLI is supported right now!";
}
std::cout << Message;
// 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) {
assert(Interpreter && "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";
exit(1);
}
CreatedBytecode = true;
}
if (OutputFile.empty()) OutputFile = "bugpoint-execution-output";
// Check to see if this is a valid output filename...
OutputFile = getUniqueFilename(OutputFile);
// Actually execute the program!
int RetVal = Interpreter->ExecuteProgram(BytecodeFile, OutputFile);
// Remove the temporary bytecode file.
if (CreatedBytecode)
removeFile(BytecodeFile);
// 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.
///
bool BugDriver::diffProgram(const std::string &ReferenceOutputFile,
const std::string &BytecodeFile) {
// Execute the program, generating an output file...
std::string Output = executeProgram("", BytecodeFile);
std::ifstream ReferenceFile(ReferenceOutputFile.c_str());
if (!ReferenceFile) {
std::cerr << "Couldn't open reference output file '"
<< ReferenceOutputFile << "'\n";
exit(1);
}
std::ifstream OutputFile(Output.c_str());
if (!OutputFile) {
std::cerr << "Couldn't open output file: " << Output << "'!\n";
exit(1);
}
bool FilesDifferent = false;
// Compare the two files...
int C1, C2;
do {
C1 = ReferenceFile.get();
C2 = OutputFile.get();
if (C1 != C2) { FilesDifferent = true; break; }
} while (C1 != EOF);
removeFile(Output);
return FilesDifferent;
}
|
