6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-13 22:24:07 +00:00
Code Issues Projects Releases Wiki Activity

Allow for specification of which JIT to run on the commandline.

Browse Source 
`lli -march=x86' or `lli -march=sparc' will forcefully select the JIT even on a
different platform. Running lli without the -march option will select the JIT
for the platform that it's currently running on.

Pro: can test Sparc JIT (debug printing mode) on X86 -- faster to compile/link
LLVM source base to test changes.
Con: Linking lli on x86 now pulls in all the Sparc libs -> longer link time
(but X86 can bear it, right?)

In the future, perhaps this should be a ./configure option to enable/disable
target JITting...


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@6360 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Misha Brukman
2003-05-27 21:40:39 +00:00
parent 68d9ed8b76
commit abb027cf41
5 changed files with 271 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
lib/ExecutionEngine/JIT/JIT.cpp
View File

@ -9,28 +9,65 @@
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineImpls.h"
#include "llvm/Module.h"
#include "Support/CommandLine.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) {
// FIXME: This should be controlled by which subdirectory gets linked in!
#if !defined(i386) && !defined(__i386__) && !defined(__x86__)
return 0;
#endif
// Allocate a target... in the future this will be controllable on the
// command line.
TargetMachine *Target = allocateX86TargetMachine(Config);
assert(Target && "Could not allocate X86 target machine!");
TargetMachine* (*TargetMachineAllocator)(unsigned) = 0;
if (Arch == "")
Arch = DefaultArch;
// Create the virtual machine object...
return new VM(M, Target);
// 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;
} else if (Arch == "sparc") {
TargetMachineAllocator = allocateSparcTargetMachine;
}
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());
MCE = createEmitter(*this); // Initialize MCE
// Initialize MCE
if (Arch == "x86") {
MCE = createX86Emitter(*this);
} else if (Arch == "sparc") {
MCE = createSparcEmitter(*this);
}
setupPassManager();
registerCallback();
emitGlobals();