Allow for specification of which JIT to run on the commandline.
`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... llvm-svn: 6360
This commit is contained in:
Misha Brukman
parent
ecf2020cf7
commit
56d27325c0
|
|
@ -48,7 +48,7 @@ namespace {
|
|||
};
|
||||
}
|
||||
|
||||
MachineCodeEmitter *VM::createEmitter(VM &V) {
|
||||
MachineCodeEmitter *VM::createX86Emitter(VM &V) {
|
||||
return new Emitter(V);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -0,0 +1,218 @@
|
|||
//===-- SparcEmitter.cpp - Write machine code to executable memory --------===//
|
||||
//
|
||||
// This file defines a MachineCodeEmitter object that is used by Jello to write
|
||||
// machine code to memory and remember where relocatable values lie.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "VM.h"
|
||||
#include "llvm/CodeGen/MachineCodeEmitter.h"
|
||||
#include "llvm/CodeGen/MachineFunction.h"
|
||||
#include "llvm/CodeGen/MachineConstantPool.h"
|
||||
#include "llvm/CodeGen/MachineInstr.h"
|
||||
#include "llvm/Target/TargetData.h"
|
||||
#include "llvm/Function.h"
|
||||
#include "Support/Statistic.h"
|
||||
// FIXME
|
||||
#include "../../../lib/Target/Sparc/SparcV9CodeEmitter.h"
|
||||
|
||||
namespace {
|
||||
Statistic<> NumBytes("jello", "Number of bytes of machine code compiled");
|
||||
|
||||
class SparcEmitter : public MachineCodeEmitter {
|
||||
VM &TheVM;
|
||||
|
||||
unsigned char *CurBlock, *CurByte;
|
||||
|
||||
// When outputting a function stub in the context of some other function, we
|
||||
// save CurBlock and CurByte here.
|
||||
unsigned char *SavedCurBlock, *SavedCurByte;
|
||||
|
||||
std::vector<std::pair<BasicBlock*,
|
||||
std::pair<unsigned*,MachineInstr*> > > BBRefs;
|
||||
std::map<BasicBlock*, unsigned> BBLocations;
|
||||
std::vector<void*> ConstantPoolAddresses;
|
||||
public:
|
||||
SparcEmitter(VM &vm) : TheVM(vm) {}
|
||||
|
||||
virtual void startFunction(MachineFunction &F);
|
||||
virtual void finishFunction(MachineFunction &F);
|
||||
virtual void emitConstantPool(MachineConstantPool *MCP);
|
||||
virtual void startBasicBlock(MachineBasicBlock &BB);
|
||||
virtual void startFunctionStub(const Function &F, unsigned StubSize);
|
||||
virtual void* finishFunctionStub(const Function &F);
|
||||
virtual void emitByte(unsigned char B);
|
||||
virtual void emitPCRelativeDisp(Value *V);
|
||||
virtual void emitGlobalAddress(GlobalValue *V, bool isPCRelative);
|
||||
virtual void emitGlobalAddress(const std::string &Name, bool isPCRelative);
|
||||
virtual void emitFunctionConstantValueAddress(unsigned ConstantNum,
|
||||
int Offset);
|
||||
|
||||
virtual void saveBBreference(BasicBlock *BB, MachineInstr &MI);
|
||||
|
||||
private:
|
||||
void emitAddress(void *Addr, bool isPCRelative);
|
||||
};
|
||||
}
|
||||
|
||||
MachineCodeEmitter *VM::createSparcEmitter(VM &V) {
|
||||
return new SparcEmitter(V);
|
||||
}
|
||||
|
||||
|
||||
#define _POSIX_MAPPED_FILES
|
||||
#include <unistd.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
// FIXME: This should be rewritten to support a real memory manager for
|
||||
// executable memory pages!
|
||||
static void *getMemory(unsigned NumPages) {
|
||||
return mmap(0, 4096*NumPages, PROT_READ|PROT_WRITE|PROT_EXEC,
|
||||
MAP_PRIVATE|MAP_ANONYMOUS, 0, 0);
|
||||
}
|
||||
|
||||
|
||||
void SparcEmitter::startFunction(MachineFunction &F) {
|
||||
CurBlock = (unsigned char *)getMemory(8);
|
||||
CurByte = CurBlock; // Start writing at the beginning of the fn.
|
||||
TheVM.addGlobalMapping(F.getFunction(), CurBlock);
|
||||
}
|
||||
|
||||
void SparcEmitter::finishFunction(MachineFunction &F) {
|
||||
ConstantPoolAddresses.clear();
|
||||
for (unsigned i = 0, e = BBRefs.size(); i != e; ++i) {
|
||||
// Re-write branches to BasicBlocks for the entire function
|
||||
unsigned Location = BBLocations[BBRefs[i].first];
|
||||
unsigned *Ref = BBRefs[i].second.first;
|
||||
MachineInstr *MI = BBRefs[i].second.second;
|
||||
for (unsigned i=0, e = MI->getNumOperands(); i != e; ++i) {
|
||||
MachineOperand &op = MI->getOperand(i);
|
||||
if (op.isImmediate()) {
|
||||
MI->SetMachineOperandConst(i, op.getType(), Location);
|
||||
break;
|
||||
}
|
||||
}
|
||||
unsigned fixedInstr = SparcV9CodeEmitter::getBinaryCodeForInstr(*MI);
|
||||
*Ref = fixedInstr;
|
||||
}
|
||||
BBRefs.clear();
|
||||
BBLocations.clear();
|
||||
|
||||
NumBytes += CurByte-CurBlock;
|
||||
|
||||
DEBUG(std::cerr << "Finished CodeGen of [0x" << std::hex
|
||||
<< (unsigned)(intptr_t)CurBlock
|
||||
<< std::dec << "] Function: " << F.getFunction()->getName()
|
||||
<< ": " << CurByte-CurBlock << " bytes of text\n");
|
||||
}
|
||||
|
||||
void SparcEmitter::emitConstantPool(MachineConstantPool *MCP) {
|
||||
const std::vector<Constant*> &Constants = MCP->getConstants();
|
||||
for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
|
||||
// For now we just allocate some memory on the heap, this can be
|
||||
// dramatically improved.
|
||||
const Type *Ty = ((Value*)Constants[i])->getType();
|
||||
void *Addr = malloc(TheVM.getTargetData().getTypeSize(Ty));
|
||||
TheVM.InitializeMemory(Constants[i], Addr);
|
||||
ConstantPoolAddresses.push_back(Addr);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void SparcEmitter::startBasicBlock(MachineBasicBlock &BB) {
|
||||
BBLocations[BB.getBasicBlock()] = (unsigned)(intptr_t)CurByte;
|
||||
}
|
||||
|
||||
|
||||
void SparcEmitter::startFunctionStub(const Function &F, unsigned StubSize) {
|
||||
SavedCurBlock = CurBlock; SavedCurByte = CurByte;
|
||||
// FIXME: this is a huge waste of memory.
|
||||
CurBlock = (unsigned char *)getMemory((StubSize+4095)/4096);
|
||||
CurByte = CurBlock; // Start writing at the beginning of the fn.
|
||||
}
|
||||
|
||||
void *SparcEmitter::finishFunctionStub(const Function &F) {
|
||||
NumBytes += CurByte-CurBlock;
|
||||
DEBUG(std::cerr << "Finished CodeGen of [0x" << std::hex
|
||||
<< (unsigned)(intptr_t)CurBlock
|
||||
<< std::dec << "] Function stub for: " << F.getName()
|
||||
<< ": " << CurByte-CurBlock << " bytes of text\n");
|
||||
std::swap(CurBlock, SavedCurBlock);
|
||||
CurByte = SavedCurByte;
|
||||
return SavedCurBlock;
|
||||
}
|
||||
|
||||
void SparcEmitter::emitByte(unsigned char B) {
|
||||
*CurByte++ = B; // Write the byte to memory
|
||||
}
|
||||
|
||||
// BasicBlock -> pair<memloc, MachineInstr>
|
||||
// when the BB is emitted, machineinstr is modified with then-currbyte,
|
||||
// processed with MCE, and written out at memloc.
|
||||
void SparcEmitter::saveBBreference(BasicBlock *BB, MachineInstr &MI) {
|
||||
BBRefs.push_back(std::make_pair(BB, std::make_pair((unsigned*)CurByte, &MI)));
|
||||
}
|
||||
|
||||
|
||||
// emitPCRelativeDisp - For functions, just output a displacement that will
|
||||
// cause a reference to the zero page, which will cause a seg-fault, causing
|
||||
// things to get resolved on demand. Keep track of these markers.
|
||||
//
|
||||
// For basic block references, keep track of where the references are so they
|
||||
// may be patched up when the basic block is defined.
|
||||
//
|
||||
// BasicBlock -> pair<memloc, MachineInstr>
|
||||
// when the BB is emitted, machineinstr is modified with then-currbyte,
|
||||
// processed with MCE, and written out at memloc.
|
||||
|
||||
void SparcEmitter::emitPCRelativeDisp(Value *V) {
|
||||
#if 0
|
||||
BasicBlock *BB = cast<BasicBlock>(V); // Keep track of reference...
|
||||
BBRefs.push_back(std::make_pair(BB, (unsigned*)CurByte));
|
||||
CurByte += 4;
|
||||
#endif
|
||||
}
|
||||
|
||||
// emitAddress - Emit an address in either direct or PCRelative form...
|
||||
//
|
||||
void SparcEmitter::emitAddress(void *Addr, bool isPCRelative) {
|
||||
#if 0
|
||||
if (isPCRelative) {
|
||||
*(intptr_t*)CurByte = (intptr_t)Addr - (intptr_t)CurByte-4;
|
||||
} else {
|
||||
*(void**)CurByte = Addr;
|
||||
}
|
||||
CurByte += 4;
|
||||
#endif
|
||||
}
|
||||
|
||||
void SparcEmitter::emitGlobalAddress(GlobalValue *V, bool isPCRelative) {
|
||||
if (isPCRelative) { // must be a call, this is a major hack!
|
||||
// Try looking up the function to see if it is already compiled!
|
||||
if (void *Addr = TheVM.getPointerToGlobalIfAvailable(V)) {
|
||||
emitAddress(Addr, isPCRelative);
|
||||
} else { // Function has not yet been code generated!
|
||||
TheVM.addFunctionRef(CurByte, cast<Function>(V));
|
||||
|
||||
// Delayed resolution...
|
||||
emitAddress((void*)VM::CompilationCallback, isPCRelative);
|
||||
}
|
||||
} else {
|
||||
emitAddress(TheVM.getPointerToGlobal(V), isPCRelative);
|
||||
}
|
||||
}
|
||||
|
||||
void SparcEmitter::emitGlobalAddress(const std::string &Name, bool isPCRelative)
|
||||
{
|
||||
#if 0
|
||||
emitAddress(TheVM.getPointerToNamedFunction(Name), isPCRelative);
|
||||
#endif
|
||||
}
|
||||
|
||||
void SparcEmitter::emitFunctionConstantValueAddress(unsigned ConstantNum,
|
||||
int Offset) {
|
||||
assert(ConstantNum < ConstantPoolAddresses.size() &&
|
||||
"Invalid ConstantPoolIndex!");
|
||||
*(void**)CurByte = (char*)ConstantPoolAddresses[ConstantNum]+Offset;
|
||||
CurByte += 4;
|
||||
}
|
||||
|
|
@ -62,7 +62,8 @@ public:
|
|||
static void runAtExitHandlers();
|
||||
|
||||
private:
|
||||
static MachineCodeEmitter *createEmitter(VM &V);
|
||||
static MachineCodeEmitter *createX86Emitter(VM &V);
|
||||
static MachineCodeEmitter *createSparcEmitter(VM &V);
|
||||
void setupPassManager();
|
||||
void *getPointerToFunction(const Function *F);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue