diff options
Diffstat (limited to 'lib/ExecutionEngine')
| -rw-r--r-- | lib/ExecutionEngine/JIT/JIT.cpp | 59 | ||||
| -rw-r--r-- | lib/ExecutionEngine/JIT/JIT.h | 3 | ||||
| -rw-r--r-- | lib/ExecutionEngine/JIT/JITEmitter.cpp | 2 | ||||
| -rw-r--r-- | lib/ExecutionEngine/JIT/SparcEmitter.cpp | 218 | ||||
| -rw-r--r-- | lib/ExecutionEngine/JIT/VM.h | 3 |
5 files changed, 271 insertions, 14 deletions
diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp index 05aa934a85..95d7331f8c 100644 --- a/lib/ExecutionEngine/JIT/JIT.cpp +++ b/lib/ExecutionEngine/JIT/JIT.cpp @@ -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; + + // 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); + // 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(); diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h index a720c960f3..58b7a3895b 100644 --- a/lib/ExecutionEngine/JIT/JIT.h +++ b/lib/ExecutionEngine/JIT/JIT.h @@ -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); diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp index f6f6b30f0f..e6fe09b135 100644 --- a/lib/ExecutionEngine/JIT/JITEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp @@ -48,7 +48,7 @@ namespace { }; } -MachineCodeEmitter *VM::createEmitter(VM &V) { +MachineCodeEmitter *VM::createX86Emitter(VM &V) { return new Emitter(V); } diff --git a/lib/ExecutionEngine/JIT/SparcEmitter.cpp b/lib/ExecutionEngine/JIT/SparcEmitter.cpp new file mode 100644 index 0000000000..77f48b2d88 --- /dev/null +++ b/lib/ExecutionEngine/JIT/SparcEmitter.cpp @@ -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; +} diff --git a/lib/ExecutionEngine/JIT/VM.h b/lib/ExecutionEngine/JIT/VM.h index a720c960f3..58b7a3895b 100644 --- a/lib/ExecutionEngine/JIT/VM.h +++ b/lib/ExecutionEngine/JIT/VM.h @@ -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); |