lib/ExecutionEngine/JIT/JITEmitter.cpp

   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
  27 using namespace llvm;
  28
  29 namespace {
  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
  54 JITMemoryManager::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
  65 unsigned 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
  74 unsigned 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
  80 void JITMemoryManager::endFunctionBody(unsigned char *FunctionEnd) {
  81   assert(FunctionEnd > CurFunctionPtr);
  82   CurFunctionPtr = FunctionEnd;
  83 }
  84
  85
  86
  87 namespace {
  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 std::string &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
 130 MachineCodeEmitter *JIT::createEmitter(JIT &jit) {
 131   return new Emitter(jit);
 132 }
 133
 134 void Emitter::startFunction(MachineFunction &F) {
 135   CurByte = CurBlock = MemMgr.startFunctionBody();
 136   TheJIT->addGlobalMapping(F.getFunction(), CurBlock);
 137 }
 138
 139 void 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
 149 void 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
 182 void Emitter::startFunctionStub(const Function &F, unsigned StubSize) {
 183   SavedCurBlock = CurBlock;  SavedCurByte = CurByte;
 184   CurByte = CurBlock = MemMgr.allocateStub(StubSize);
 185 }
 186
 187 void *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
 198 void Emitter::emitByte(unsigned char B) {
 199   *CurByte++ = B;   // Write the byte to memory
 200 }
 201
 202 void 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
 209 void Emitter::emitWordAt(unsigned W, unsigned *Ptr) {
 210   *Ptr = W;
 211 }
 212
 213 uint64_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 }
 227 uint64_t Emitter::getGlobalValueAddress(const std::string &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 //
 235 uint64_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 //
 244 uint64_t Emitter::getCurrentPCValue() {
 245   return (intptr_t)CurByte;
 246 }
 247
 248 uint64_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.
 257 extern "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 }