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
|
//===-- JIT.cpp - LLVM Just in Time Compiler ------------------------------===//
//
// 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 implements the top-level support for creating a Just-In-Time
// compiler for the current architecture.
//
//===----------------------------------------------------------------------===//
#include "VM.h"
#include "llvm/Module.h"
#include "llvm/ModuleProvider.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineImpls.h"
#include "Support/CommandLine.h"
// FIXME: REMOVE THIS
#include "llvm/PassManager.h"
#if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT)
#define NO_JITS_ENABLED
#endif
namespace {
enum ArchName { x86, Sparc };
#ifndef NO_JITS_ENABLED
cl::opt<ArchName>
Arch("march", cl::desc("Architecture to JIT to:"), cl::Prefix,
cl::values(
#ifdef ENABLE_X86_JIT
clEnumVal(x86, " IA-32 (Pentium and above)"),
#endif
#ifdef ENABLE_SPARC_JIT
clEnumValN(Sparc, "sparc", " Sparc-V9"),
#endif
0),
#if defined(ENABLE_X86_JIT)
cl::init(x86)
#elif defined(ENABLE_SPARC_JIT)
cl::init(Sparc)
#endif
);
#endif /* NO_JITS_ENABLED */
}
/// create - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise, return null.
///
ExecutionEngine *VM::create(ModuleProvider *MP) {
TargetMachine* (*TargetMachineAllocator)(const Module &) = 0;
// 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.
#ifdef NO_JITS_ENABLED
return 0;
#endif
switch (Arch) {
#ifdef ENABLE_X86_JIT
case x86:
TargetMachineAllocator = allocateX86TargetMachine;
break;
#endif
#ifdef ENABLE_SPARC_JIT
case Sparc:
TargetMachineAllocator = allocateSparcTargetMachine;
break;
#endif
default:
assert(0 && "-march flag not supported on this host!");
}
// Allocate a target...
TargetMachine *Target = TargetMachineAllocator(*MP->getModule());
assert(Target && "Could not allocate target machine!");
// Create the virtual machine object...
return new VM(MP, Target);
}
VM::VM(ModuleProvider *MP, TargetMachine *tm) : ExecutionEngine(MP), TM(*tm),
PM(MP)
{
setTargetData(TM.getTargetData());
// Initialize MCE
MCE = createEmitter(*this);
setupPassManager();
#ifdef ENABLE_SPARC_JIT
// 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));
// We cannot utilize function-at-a-time loading here because PreSelection
// is a ModulePass.
MP->materializeModule();
PM.run(*MP->getModule());
}
#endif
emitGlobals();
}
/// run - Start execution with the specified function and arguments.
///
GenericValue VM::run(Function *F, const std::vector<GenericValue> &ArgValues)
{
assert (F && "Function *F was null at entry to run()");
int (*PF)(int, char **, const char **) =
(int(*)(int, char **, const char **))getPointerToFunction(F);
assert(PF != 0 && "Pointer to fn's code was null after getPointerToFunction");
// Call the function.
int ExitCode = PF(ArgValues[0].IntVal, (char **) GVTOP (ArgValues[1]),
(const char **) GVTOP (ArgValues[2]));
// Run any atexit handlers now!
runAtExitHandlers();
GenericValue rv;
rv.IntVal = ExitCode;
return rv;
}
|
