6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-28 19:31:58 +00:00
Code Issues Projects Releases Wiki Activity

Goodbye macro hell, hello nice clean simple extensible code. This change

Browse Source 
also gives the JIT the ability to dynamically load targets. e.g.

lli -load libparisc.so -march=parisc foo.bc


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14750 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2004-07-11 04:02:06 +00:00
parent d7099bc608
commit d5e1d9d5f4
1 changed files with 13 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
lib/ExecutionEngine/JIT/TargetSelect.cpp
View File

@ -19,69 +19,29 @@
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/ModuleProvider.h" #include "llvm/ModuleProvider.h"
#include "llvm/Target/TargetMachine.h" #include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetMachineImpls.h" #include "llvm/Target/TargetMachineRegistry.h"
#include "Support/CommandLine.h" #include <iostream>
using namespace llvm; using namespace llvm;
#if !defined(ENABLE_X86_JIT) && !defined(ENABLE_SPARC_JIT) static cl::opt<const TargetMachineRegistry::Entry*, false, TargetNameParser>
#define NO_JITS_ENABLED MArch("march", cl::desc("Architecture to generate assembly for:"));
#endif
namespace {
enum ArchName { x86, SparcV9 };
#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(SparcV9, "sparcv9", " Sparc-V9"),
#endif
0),
#if defined(ENABLE_X86_JIT)
cl::init(x86)
#elif defined(ENABLE_SPARC_JIT)
cl::init(SparcV9)
#endif
);
#endif /* NO_JITS_ENABLED */
}
/// create - Create an return a new JIT compiler if there is one available /// create - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise, return null. /// for the current target. Otherwise, return null.
/// ///
ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) { ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
TargetMachine* (*TargetMachineAllocator)(const Module &, if (MArch == 0) {
IntrinsicLowering *IL) = 0; std::string Error;
MArch = TargetMachineRegistry::getClosestTargetForJIT(Error);
// Allow a command-line switch to override what *should* be the default target if (MArch == 0) return 0;
// machine for this platform. This allows for debugging a Sparc JIT on X86 -- } else if (MArch->JITMatchQualityFn() == 0) {
// our X86 machines are much faster at recompiling LLVM and linking LLI. std::cerr << "WARNING: This target JIT is not designed for the host you are"
#ifndef NO_JITS_ENABLED << " running. If bad things happen, please choose a different "
<< "-march switch.\n";
switch (Arch) {
#ifdef ENABLE_X86_JIT
case x86:
TargetMachineAllocator = allocateX86TargetMachine;
break;
#endif
#ifdef ENABLE_SPARC_JIT
case SparcV9:
TargetMachineAllocator = allocateSparcV9TargetMachine;
break;
#endif
default:
assert(0 && "-march flag not supported on this host!");
} }
#else
return 0;
#endif
// Allocate a target... // Allocate a target...
TargetMachine *Target = TargetMachineAllocator(*MP->getModule(), IL); TargetMachine *Target = MArch->CtorFn(*MP->getModule(), IL);
assert(Target && "Could not allocate target machine!"); assert(Target && "Could not allocate target machine!");
// If the target supports JIT code generation, return a new JIT now. // If the target supports JIT code generation, return a new JIT now.
@ -89,5 +49,3 @@ ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
return new JIT(MP, *Target, *TJ); return new JIT(MP, *Target, *TJ);
return 0; return 0;
} }