blob: 5a3245b91b60e8f30f5d42194c46c61f9ed5efa7 (
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
//
// This file implements the top-level support for creating a Just-In-Time
// compiler for the current architecture.
//
//===----------------------------------------------------------------------===//
#include "VM.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineImpls.h"
#include "llvm/Module.h"
#include "Support/CommandLine.h"
// FIXME: REMOVE THIS
#include "llvm/PassManager.h"
namespace {
cl::opt<std::string>
Arch("march", cl::desc("Architecture: `x86' or `sparc'"), cl::Prefix,
cl::value_desc("machine architecture"));
static std::string DefaultArch =
#if defined(i386) || defined(__i386__) || defined(__x86__)
"x86";
#elif defined(sparc) || defined(__sparc__) || defined(__sparcv9)
"sparc";
#else
"";
#endif
}
/// createJIT - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise it returns null.
///
ExecutionEngine *ExecutionEngine::createJIT(Module *M, unsigned Config) {
TargetMachine* (*TargetMachineAllocator)(unsigned) = 0;
if (Arch == "")
Arch = DefaultArch;
// Allow a command-line switch to override what *should* be the default target
// machine for this platform. This allows for debugging a Sparc JIT on X86 --
// our X86 machines are much faster at recompiling LLVM and linking lli.
if (Arch == "x86") {
TargetMachineAllocator = allocateX86TargetMachine;
#if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
} else if (Arch == "sparc") {
TargetMachineAllocator = allocateSparcTargetMachine;
#endif
}
if (TargetMachineAllocator) {
// Allocate a target...
TargetMachine *Target = (*TargetMachineAllocator)(Config);
assert(Target && "Could not allocate target machine!");
// Create the virtual machine object...
return new VM(M, Target);
} else {
return 0;
}
}
VM::VM(Module *M, TargetMachine *tm) : ExecutionEngine(M), TM(*tm) {
setTargetData(TM.getTargetData());
// Initialize MCE
MCE = createEmitter(*this);
setupPassManager();
#if defined(sparc) || defined(__sparc__) || defined(__sparcv9)
// THIS GOES BEYOND UGLY HACKS
if (TM.getName() == "UltraSparc-Native") {
extern Pass *createPreSelectionPass(TargetMachine &TM);
PassManager PM;
// Specialize LLVM code for this target machine and then
// run basic dataflow optimizations on LLVM code.
PM.add(createPreSelectionPass(TM));
PM.run(*M);
}
#endif
emitGlobals();
}
int VM::run(const std::string &FnName, const std::vector<std::string> &Args) {
Function *F = getModule().getNamedFunction(FnName);
if (F == 0) {
std::cerr << "Could not find function '" << FnName <<"' in module!\n";
return 1;
}
int(*PF)(int, char**) = (int(*)(int, char**))getPointerToFunction(F);
assert(PF != 0 && "Null pointer to function?");
// Build an argv vector...
char **Argv = (char**)CreateArgv(Args);
// Call the main function...
int Result = PF(Args.size(), Argv);
// Run any atexit handlers now!
runAtExitHandlers();
return Result;
}
|
