blob: aaf115a675ae80773e8a391130d3802a697174ed (
plain)
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
|
//===-- jello.cpp - LLVM Just in Time Compiler ----------------------------===//
//
// This tool implements a just-in-time compiler for LLVM, allowing direct
// execution of LLVM bytecode in an efficient manner.
//
// FIXME: This code will get more object oriented as we get the call back
// intercept stuff implemented.
//
//===----------------------------------------------------------------------===//
#include "llvm/Module.h"
#include "llvm/PassManager.h"
#include "llvm/Bytecode/Reader.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineImpls.h"
#include "Support/CommandLine.h"
#include "Support/Statistic.h"
#include "llvm/CodeGen/MachineCodeEmitter.h"
struct JelloMachineCodeEmitter : public MachineCodeEmitter {
};
namespace {
cl::opt<std::string>
InputFile(cl::desc("<input bytecode>"), cl::Positional, cl::init("-"));
cl::opt<std::string>
MainFunction("f", cl::desc("Function to execute"), cl::init("main"),
cl::value_desc("function name"));
}
//===----------------------------------------------------------------------===//
// main Driver function
//
int main(int argc, char **argv) {
cl::ParseCommandLineOptions(argc, argv, " llvm just in time compiler\n");
// Allocate a target... in the future this will be controllable on the
// command line.
std::auto_ptr<TargetMachine> target(allocateX86TargetMachine());
assert(target.get() && "Could not allocate target machine!");
TargetMachine &Target = *target.get();
// Parse the input bytecode file...
std::string ErrorMsg;
std::auto_ptr<Module> M(ParseBytecodeFile(InputFile, &ErrorMsg));
if (M.get() == 0) {
std::cerr << argv[0] << ": bytecode '" << InputFile
<< "' didn't read correctly: << " << ErrorMsg << "\n";
return 1;
}
PassManager Passes;
// Compile LLVM Code down to machine code in the intermediate representation
if (Target.addPassesToJITCompile(Passes)) {
std::cerr << argv[0] << ": target '" << Target.getName()
<< "' doesn't support JIT compilation!\n";
return 1;
}
// Turn the machine code intermediate representation into bytes in memory that
// may be executed.
//
JelloMachineCodeEmitter MCE;
if (Target.addPassesToEmitMachineCode(Passes, MCE)) {
std::cerr << argv[0] << ": target '" << Target.getName()
<< "' doesn't support machine code emission!\n";
return 1;
}
// JIT all of the methods in the module. Eventually this will JIT functions
// on demand.
Passes.run(*M.get());
return 0;
}
|
