Implement PR135, lazy emission of global variables

[oota-llvm.git] / lib / ExecutionEngine / JIT / JITEmitter.cpp

diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp
index 94fef6a0ae7794d03e1178c0071fe9fd2d8623da..8da50919fd3b2c50d9d4ba6737e288d97e799256 100644 (file)
--- a/lib/ExecutionEngine/JIT/JITEmitter.cpp
+++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp
@@ -1,4 +1,11 @@
 //===-- Emitter.cpp - Write machine code to executable memory -------------===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file defines a MachineCodeEmitter object that is used by Jello to write
 // machine code to memory and remember where relocatable values lie.
@@ -9,20 +16,22 @@
 #ifndef _POSIX_MAPPED_FILES
 #define _POSIX_MAPPED_FILES
 #endif
-#include "VM.h"
+#include "JIT.h"
+#include "llvm/Constant.h"
+#include "llvm/Module.h"
 #include "llvm/CodeGen/MachineCodeEmitter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/Target/TargetData.h"
-#include "llvm/Module.h"
 #include "Support/Debug.h"
 #include "Support/Statistic.h"
 #include "Config/unistd.h"
 #include "Config/sys/mman.h"
+using namespace llvm;
 
 namespace {
-  Statistic<> NumBytes("jello", "Number of bytes of machine code compiled");
-  VM *TheVM = 0;
+  Statistic<> NumBytes("jit", "Number of bytes of machine code compiled");
+  JIT *TheJIT = 0;
 
   /// JITMemoryManager - Manage memory for the JIT code generation in a logical,
   /// sane way.  This splits a large block of MAP_NORESERVE'd memory into two
@@ -133,7 +142,7 @@ namespace {
     // constant pool.
     std::vector<void*> ConstantPoolAddresses;
   public:
-    Emitter(VM &vm) { TheVM = &vm; }
+    Emitter(JIT &jit) { TheJIT = &jit; }
 
     virtual void startFunction(MachineFunction &F);
     virtual void finishFunction(MachineFunction &F);
@@ -157,13 +166,13 @@ namespace {
   };
 }
 
-MachineCodeEmitter *VM::createEmitter(VM &V) {
-  return new Emitter(V);
+MachineCodeEmitter *JIT::createEmitter(JIT &jit) {
+  return new Emitter(jit);
 }
 
 void Emitter::startFunction(MachineFunction &F) {
   CurByte = CurBlock = MemMgr.startFunctionBody();
-  TheVM->addGlobalMapping(F.getFunction(), CurBlock);
+  TheJIT->addGlobalMapping(F.getFunction(), CurBlock);
 }
 
 void Emitter::finishFunction(MachineFunction &F) {
@@ -178,12 +187,33 @@ void Emitter::finishFunction(MachineFunction &F) {
 
 void Emitter::emitConstantPool(MachineConstantPool *MCP) {
   const std::vector<Constant*> &Constants = MCP->getConstants();
+  if (Constants.empty()) return;
+
+  std::vector<unsigned> ConstantOffset;
+  ConstantOffset.reserve(Constants.size());
+
+  // Calculate how much space we will need for all the constants, and the offset
+  // each one will live in.
+  unsigned TotalSize = 0;
   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);
+    const Type *Ty = Constants[i]->getType();
+    unsigned Size      = TheJIT->getTargetData().getTypeSize(Ty);
+    unsigned Alignment = TheJIT->getTargetData().getTypeAlignment(Ty);
+    // Make sure to take into account the alignment requirements of the type.
+    TotalSize = (TotalSize + Alignment-1) & ~(Alignment-1);
+
+    // Remember the offset this element lives at.
+    ConstantOffset.push_back(TotalSize);
+    TotalSize += Size;   // Reserve space for the constant.
+  }
+
+  // Now that we know how much memory to allocate, do so.
+  char *Pool = new char[TotalSize];
+
+  // Actually output all of the constants, and remember their addresses.
+  for (unsigned i = 0, e = Constants.size(); i != e; ++i) {
+    void *Addr = Pool + ConstantOffset[i];
+    TheJIT->InitializeMemory(Constants[i], Addr);
     ConstantPoolAddresses.push_back(Addr);
   }
 }
@@ -218,10 +248,14 @@ void Emitter::emitWord(unsigned W) {
 uint64_t Emitter::getGlobalValueAddress(GlobalValue *V) {
   // Try looking up the function to see if it is already compiled, if not return
   // 0.
-  return (intptr_t)TheVM->getPointerToGlobalIfAvailable(V);
+  if (isa<Function>(V))
+    return (intptr_t)TheJIT->getPointerToGlobalIfAvailable(V);
+  else {
+    return (intptr_t)TheJIT->getOrEmitGlobalVariable(cast<GlobalVariable>(V));
+  }
 }
 uint64_t Emitter::getGlobalValueAddress(const std::string &Name) {
-  return (intptr_t)TheVM->getPointerToNamedFunction(Name);
+  return (intptr_t)TheJIT->getPointerToNamedFunction(Name);
 }
 
 // getConstantPoolEntryAddress - Return the address of the 'ConstantNum' entry
@@ -242,19 +276,19 @@ uint64_t Emitter::getCurrentPCValue() {
 }
 
 uint64_t Emitter::forceCompilationOf(Function *F) {
-  return (intptr_t)TheVM->getPointerToFunction(F);
+  return (intptr_t)TheJIT->getPointerToFunction(F);
 }
 
 // getPointerToNamedFunction - This function is used as a global wrapper to
-// VM::getPointerToNamedFunction for the purpose of resolving symbols when
+// JIT::getPointerToNamedFunction for the purpose of resolving symbols when
 // bugpoint is debugging the JIT. In that scenario, we are loading an .so and
 // need to resolve function(s) that are being mis-codegenerated, so we need to
 // resolve their addresses at runtime, and this is the way to do it.
 extern "C" {
   void *getPointerToNamedFunction(const char *Name) {
-    Module &M = TheVM->getModule();
+    Module &M = TheJIT->getModule();
     if (Function *F = M.getNamedFunction(Name))
-      return TheVM->getPointerToFunction(F);
-    return TheVM->getPointerToNamedFunction(Name);
+      return TheJIT->getPointerToFunction(F);
+    return TheJIT->getPointerToNamedFunction(Name);
   }
 }