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
|
//===-- 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"
#if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT)
#define NO_JITS_ENABLED
#endif
namespace llvm {
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.
#ifndef NO_JITS_ENABLED
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!");
}
#else
return 0;
#endif
// 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();
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;
}
} // End llvm namespace
|
