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
193
194
195
|
//===-- llc.cpp - Implement the LLVM Compiler -----------------------------===//
//
// This is the llc compiler driver.
//
//===----------------------------------------------------------------------===//
#include "llvm/Bytecode/Reader.h"
#include "llvm/Target/Sparc.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Transforms/Instrumentation/TraceValues.h"
#include "llvm/Transforms/LowerAllocations.h"
#include "llvm/Transforms/HoistPHIConstants.h"
#include "llvm/Transforms/PrintModulePass.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Module.h"
#include "llvm/Method.h"
#include <memory>
#include <string>
#include <fstream>
cl::String InputFilename ("", "Input filename", cl::NoFlags, "-");
cl::String OutputFilename("o", "Output filename", cl::NoFlags, "");
cl::Flag Force ("f", "Overwrite output files");
cl::Flag DumpAsm ("d", "Print bytecode before native code generation",
cl::Hidden);
cl::Flag DoNotEmitAssembly("noasm", "Do not emit assembly code", cl::Hidden);
cl::Flag TraceBBValues ("trace",
"Trace values at basic block and method exits");
cl::Flag TraceMethodValues("tracem", "Trace values only at method exits");
cl::Flag DebugTrace ("dumptrace",
"output trace code to a <fn>.trace.ll file",
cl::Hidden);
// GetFileNameRoot - Helper function to get the basename of a filename...
static inline string GetFileNameRoot(const string &InputFilename) {
string IFN = InputFilename;
string outputFilename;
int Len = IFN.length();
if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') {
outputFilename = string(IFN.begin(), IFN.end()-3); // s/.bc/.s/
} else {
outputFilename = IFN;
}
return outputFilename;
}
//===---------------------------------------------------------------------===//
// GenerateCodeForTarget Pass
//
// Native code generation for a specified target.
//===---------------------------------------------------------------------===//
class GenerateCodeForTarget : public Pass {
TargetMachine &Target;
public:
inline GenerateCodeForTarget(TargetMachine &T) : Target(T) {}
// doPerMethodWork - This method does the actual work of generating code for
// the specified method.
//
bool doPerMethodWork(Method *M) {
if (!M->isExternal() && Target.compileMethod(M)) {
cerr << "Error compiling " << InputFilename << "!\n";
return true;
}
return false;
}
};
//===---------------------------------------------------------------------===//
// EmitAssembly Pass
//
// Write assembly code to specified output stream
//===---------------------------------------------------------------------===//
class EmitAssembly : public Pass {
const TargetMachine &Target; // Target to compile for
ostream *Out; // Stream to print on
bool DeleteStream; // Delete stream in dtor?
public:
inline EmitAssembly(const TargetMachine &T, ostream *O, bool D)
: Target(T), Out(O), DeleteStream(D) {}
virtual bool doPassFinalization(Module *M) {
// TODO: This should be performed as a moduleCleanup function, but we don't
// have one yet!
Target.emitAssembly(M, *Out);
if (DeleteStream) delete Out;
return false;
}
};
//===---------------------------------------------------------------------===//
// Function main()
//
// Entry point for the llc compiler.
//===---------------------------------------------------------------------===//
int main(int argc, char **argv) {
cl::ParseCommandLineOptions(argc, argv, " llvm system compiler\n");
// Allocate a target... in the future this will be controllable on the
// command line.
auto_ptr<TargetMachine> target(allocateSparcTargetMachine());
assert(target.get() && "Could not allocate target machine!");
TargetMachine &Target = *target.get();
// Load the module to be compiled...
auto_ptr<Module> M(ParseBytecodeFile(InputFilename));
if (M.get() == 0) {
cerr << "bytecode didn't read correctly.\n";
return 1;
}
// Build up all of the passes that we want to do to the module...
vector<Pass*> Passes;
// Replace malloc and free instructions with library calls
Passes.push_back(new LowerAllocations(Target.DataLayout));
// Hoist constants out of PHI nodes into predecessor BB's
Passes.push_back(new HoistPHIConstants());
if (TraceBBValues || TraceMethodValues) // If tracing enabled...
// Insert trace code in all methods in the module
Passes.push_back(new InsertTraceCode(TraceBBValues,
TraceBBValues || TraceMethodValues));
if (DebugTrace) { // If Trace Debugging is enabled...
// Then write the module with tracing code out in assembly form
assert(InputFilename != "-" && "files on stdin not supported with tracing");
string traceFileName = GetFileNameRoot(InputFilename) + ".trace.ll";
ostream *os = new ofstream(traceFileName.c_str(),
(Force ? 0 : ios::noreplace)|ios::out);
if (!os->good()) {
cerr << "Error opening " << traceFileName << "!\n";
delete os;
return 1;
}
Passes.push_back(new PrintModulePass("", os, true));
}
// If LLVM dumping after transformations is requested, add it to the pipeline
if (DumpAsm)
Passes.push_back(new PrintModulePass("Method after xformations: \n",&cerr));
// Generate Target code...
Passes.push_back(new GenerateCodeForTarget(Target));
if (!DoNotEmitAssembly) { // If asm output is enabled...
// Figure out where we are going to send the output...
ostream *Out = 0;
if (OutputFilename != "") { // Specified an output filename?
Out = new ofstream(OutputFilename.c_str(),
(Force ? 0 : ios::noreplace)|ios::out);
} else {
if (InputFilename == "-") {
OutputFilename = "-";
Out = &cout;
} else {
string OutputFilename = GetFileNameRoot(InputFilename);
OutputFilename += ".s";
Out = new ofstream(OutputFilename.c_str(),
(Force ? 0 : ios::noreplace)|ios::out);
if (!Out->good()) {
cerr << "Error opening " << OutputFilename << "!\n";
delete Out;
return 1;
}
}
}
// Output assembly language to the .s file
Passes.push_back(new EmitAssembly(Target, Out, Out != &cout));
}
// Run our queue of passes all at once now, efficiently. This form of
// runAllPasses frees the Pass objects after runAllPasses completes.
Pass::runAllPassesAndFree(M.get(), Passes);
return 0;
}
|
