JITEmitter.cpp revision 45730d71b69646afe0876dd03446b4df8b8d11f2
1//===-- Emitter.cpp - Write machine code to executable memory -------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file was developed by the LLVM research group and is distributed under 6// the University of Illinois Open Source License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines a MachineCodeEmitter object that is used by Jello to write 11// machine code to memory and remember where relocatable values lie. 12// 13//===----------------------------------------------------------------------===// 14 15#define DEBUG_TYPE "jit" 16#include "JIT.h" 17#include "llvm/Constant.h" 18#include "llvm/Module.h" 19#include "llvm/CodeGen/MachineCodeEmitter.h" 20#include "llvm/CodeGen/MachineFunction.h" 21#include "llvm/CodeGen/MachineConstantPool.h" 22#include "llvm/Target/TargetData.h" 23#include "llvm/Support/Debug.h" 24#include "llvm/ADT/Statistic.h" 25#include "llvm/System/Memory.h" 26 27using namespace llvm; 28 29namespace { 30 Statistic<> NumBytes("jit", "Number of bytes of machine code compiled"); 31 JIT *TheJIT = 0; 32 33 /// JITMemoryManager - Manage memory for the JIT code generation in a logical, 34 /// sane way. This splits a large block of MAP_NORESERVE'd memory into two 35 /// sections, one for function stubs, one for the functions themselves. We 36 /// have to do this because we may need to emit a function stub while in the 37 /// middle of emitting a function, and we don't know how large the function we 38 /// are emitting is. This never bothers to release the memory, because when 39 /// we are ready to destroy the JIT, the program exits. 40 class JITMemoryManager { 41 sys::MemoryBlock MemBlock; // Virtual memory block allocated RWX 42 unsigned char *MemBase; // Base of block of memory, start of stub mem 43 unsigned char *FunctionBase; // Start of the function body area 44 unsigned char *CurStubPtr, *CurFunctionPtr; 45 public: 46 JITMemoryManager(); 47 48 inline unsigned char *allocateStub(unsigned StubSize); 49 inline unsigned char *startFunctionBody(); 50 inline void endFunctionBody(unsigned char *FunctionEnd); 51 }; 52} 53 54JITMemoryManager::JITMemoryManager() { 55 // Allocate a 16M block of memory... 56 MemBlock = sys::Memory::AllocateRWX((16 << 20)); 57 MemBase = reinterpret_cast<unsigned char*>(MemBlock.base()); 58 FunctionBase = MemBase + 512*1024; // Use 512k for stubs 59 60 // Allocate stubs backwards from the function base, allocate functions forward 61 // from the function base. 62 CurStubPtr = CurFunctionPtr = FunctionBase; 63} 64 65unsigned char *JITMemoryManager::allocateStub(unsigned StubSize) { 66 CurStubPtr -= StubSize; 67 if (CurStubPtr < MemBase) { 68 std::cerr << "JIT ran out of memory for function stubs!\n"; 69 abort(); 70 } 71 return CurStubPtr; 72} 73 74unsigned char *JITMemoryManager::startFunctionBody() { 75 // Round up to an even multiple of 4 bytes, this should eventually be target 76 // specific. 77 return (unsigned char*)(((intptr_t)CurFunctionPtr + 3) & ~3); 78} 79 80void JITMemoryManager::endFunctionBody(unsigned char *FunctionEnd) { 81 assert(FunctionEnd > CurFunctionPtr); 82 CurFunctionPtr = FunctionEnd; 83} 84 85 86 87namespace { 88 /// Emitter - The JIT implementation of the MachineCodeEmitter, which is used 89 /// to output functions to memory for execution. 90 class Emitter : public MachineCodeEmitter { 91 JITMemoryManager MemMgr; 92 93 // CurBlock - The start of the current block of memory. CurByte - The 94 // current byte being emitted to. 95 unsigned char *CurBlock, *CurByte; 96 97 // When outputting a function stub in the context of some other function, we 98 // save CurBlock and CurByte here. 99 unsigned char *SavedCurBlock, *SavedCurByte; 100 101 // ConstantPoolAddresses - Contains the location for each entry in the 102 // constant pool. 103 std::vector<void*> ConstantPoolAddresses; 104 public: 105 Emitter(JIT &jit) { TheJIT = &jit; } 106 107 virtual void startFunction(MachineFunction &F); 108 virtual void finishFunction(MachineFunction &F); 109 virtual void emitConstantPool(MachineConstantPool *MCP); 110 virtual void startFunctionStub(const Function &F, unsigned StubSize); 111 virtual void* finishFunctionStub(const Function &F); 112 virtual void emitByte(unsigned char B); 113 virtual void emitWord(unsigned W); 114 virtual void emitWordAt(unsigned W, unsigned *Ptr); 115 116 virtual uint64_t getGlobalValueAddress(GlobalValue *V); 117 virtual uint64_t getGlobalValueAddress(const char *Name); 118 virtual uint64_t getConstantPoolEntryAddress(unsigned Entry); 119 virtual uint64_t getCurrentPCValue(); 120 121 // forceCompilationOf - Force the compilation of the specified function, and 122 // return its address, because we REALLY need the address now. 123 // 124 // FIXME: This is JIT specific! 125 // 126 virtual uint64_t forceCompilationOf(Function *F); 127 }; 128} 129 130MachineCodeEmitter *JIT::createEmitter(JIT &jit) { 131 return new Emitter(jit); 132} 133 134void Emitter::startFunction(MachineFunction &F) { 135 CurByte = CurBlock = MemMgr.startFunctionBody(); 136 TheJIT->addGlobalMapping(F.getFunction(), CurBlock); 137} 138 139void Emitter::finishFunction(MachineFunction &F) { 140 MemMgr.endFunctionBody(CurByte); 141 ConstantPoolAddresses.clear(); 142 NumBytes += CurByte-CurBlock; 143 144 DEBUG(std::cerr << "Finished CodeGen of [" << (void*)CurBlock 145 << "] Function: " << F.getFunction()->getName() 146 << ": " << CurByte-CurBlock << " bytes of text\n"); 147} 148 149void Emitter::emitConstantPool(MachineConstantPool *MCP) { 150 const std::vector<Constant*> &Constants = MCP->getConstants(); 151 if (Constants.empty()) return; 152 153 std::vector<unsigned> ConstantOffset; 154 ConstantOffset.reserve(Constants.size()); 155 156 // Calculate how much space we will need for all the constants, and the offset 157 // each one will live in. 158 unsigned TotalSize = 0; 159 for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 160 const Type *Ty = Constants[i]->getType(); 161 unsigned Size = TheJIT->getTargetData().getTypeSize(Ty); 162 unsigned Alignment = TheJIT->getTargetData().getTypeAlignment(Ty); 163 // Make sure to take into account the alignment requirements of the type. 164 TotalSize = (TotalSize + Alignment-1) & ~(Alignment-1); 165 166 // Remember the offset this element lives at. 167 ConstantOffset.push_back(TotalSize); 168 TotalSize += Size; // Reserve space for the constant. 169 } 170 171 // Now that we know how much memory to allocate, do so. 172 char *Pool = new char[TotalSize]; 173 174 // Actually output all of the constants, and remember their addresses. 175 for (unsigned i = 0, e = Constants.size(); i != e; ++i) { 176 void *Addr = Pool + ConstantOffset[i]; 177 TheJIT->InitializeMemory(Constants[i], Addr); 178 ConstantPoolAddresses.push_back(Addr); 179 } 180} 181 182void Emitter::startFunctionStub(const Function &F, unsigned StubSize) { 183 SavedCurBlock = CurBlock; SavedCurByte = CurByte; 184 CurByte = CurBlock = MemMgr.allocateStub(StubSize); 185} 186 187void *Emitter::finishFunctionStub(const Function &F) { 188 NumBytes += CurByte-CurBlock; 189 DEBUG(std::cerr << "Finished CodeGen of [0x" << std::hex 190 << (uintptr_t)CurBlock 191 << std::dec << "] Function stub for: " << F.getName() 192 << ": " << CurByte-CurBlock << " bytes of text\n"); 193 std::swap(CurBlock, SavedCurBlock); 194 CurByte = SavedCurByte; 195 return SavedCurBlock; 196} 197 198void Emitter::emitByte(unsigned char B) { 199 *CurByte++ = B; // Write the byte to memory 200} 201 202void Emitter::emitWord(unsigned W) { 203 // This won't work if the endianness of the host and target don't agree! (For 204 // a JIT this can't happen though. :) 205 *(unsigned*)CurByte = W; 206 CurByte += sizeof(unsigned); 207} 208 209void Emitter::emitWordAt(unsigned W, unsigned *Ptr) { 210 *Ptr = W; 211} 212 213uint64_t Emitter::getGlobalValueAddress(GlobalValue *V) { 214 // Try looking up the function to see if it is already compiled, if not return 215 // 0. 216 if (Function *F = dyn_cast<Function>(V)) { 217 void *Addr = TheJIT->getPointerToGlobalIfAvailable(F); 218 if (Addr == 0 && F->hasExternalLinkage()) { 219 // Do not output stubs for external functions. 220 Addr = TheJIT->getPointerToFunction(F); 221 } 222 return (intptr_t)Addr; 223 } else { 224 return (intptr_t)TheJIT->getOrEmitGlobalVariable(cast<GlobalVariable>(V)); 225 } 226} 227uint64_t Emitter::getGlobalValueAddress(const char *Name) { 228 return (intptr_t)TheJIT->getPointerToNamedFunction(Name); 229} 230 231// getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry 232// in the constant pool that was last emitted with the 'emitConstantPool' 233// method. 234// 235uint64_t Emitter::getConstantPoolEntryAddress(unsigned ConstantNum) { 236 assert(ConstantNum < ConstantPoolAddresses.size() && 237 "Invalid ConstantPoolIndex!"); 238 return (intptr_t)ConstantPoolAddresses[ConstantNum]; 239} 240 241// getCurrentPCValue - This returns the address that the next emitted byte 242// will be output to. 243// 244uint64_t Emitter::getCurrentPCValue() { 245 return (intptr_t)CurByte; 246} 247 248uint64_t Emitter::forceCompilationOf(Function *F) { 249 return (intptr_t)TheJIT->getPointerToFunction(F); 250} 251 252// getPointerToNamedFunction - This function is used as a global wrapper to 253// JIT::getPointerToNamedFunction for the purpose of resolving symbols when 254// bugpoint is debugging the JIT. In that scenario, we are loading an .so and 255// need to resolve function(s) that are being mis-codegenerated, so we need to 256// resolve their addresses at runtime, and this is the way to do it. 257extern "C" { 258 void *getPointerToNamedFunction(const char *Name) { 259 Module &M = TheJIT->getModule(); 260 if (Function *F = M.getNamedFunction(Name)) 261 return TheJIT->getPointerToFunction(F); 262 return TheJIT->getPointerToNamedFunction(Name); 263 } 264} 265