[llvm-commits] CVS: llvm/lib/ExecutionEngine/JIT/JIT.cpp JITEmitter.cpp

[Chris Lattner]

Changes in directory llvm/lib/ExecutionEngine/JIT:

JIT.cpp updated: 1.61 -> 1.62
JITEmitter.cpp updated: 1.87 -> 1.88
---
Log message:

Do not make the JIT memory manager manage the memory for globals.  Instead
just have the JIT malloc them.


---
Diffs of the changes:  (+19 -39)

 JIT.cpp        |   20 ++++++++++++++++----
 JITEmitter.cpp |   38 +++-----------------------------------
 2 files changed, 19 insertions(+), 39 deletions(-)


Index: llvm/lib/ExecutionEngine/JIT/JIT.cpp
diff -u llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.61 llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.62
--- llvm/lib/ExecutionEngine/JIT/JIT.cpp:1.61	Thu Mar 23 20:53:49 2006
+++ llvm/lib/ExecutionEngine/JIT/JIT.cpp	Tue May  2 16:57:51 2006
@@ -301,10 +301,22 @@
     // If the global hasn't been emitted to memory yet, allocate space.  We will
     // actually initialize the global after current function has finished
     // compilation.
-    uint64_t S = getTargetData().getTypeSize(GV->getType()->getElementType());
-    unsigned char A =
-      getTargetData().getTypeAlignment(GV->getType()->getElementType());
-    Ptr = MCE->allocateGlobal(S, A);
+    const Type *GlobalType = GV->getType()->getElementType();
+    size_t S = getTargetData().getTypeSize(GlobalType);
+    size_t A = getTargetData().getTypeAlignment(GlobalType);
+    if (A <= 8) {
+      Ptr = malloc(S);
+    } else {
+      // Allocate S+A bytes of memory, then use an aligned pointer within that
+      // space.
+      Ptr = malloc(S+A);
+      unsigned MisAligned = ((intptr_t)Ptr & (A-1));
+      unsigned Offset = MisAligned ? (A-MisAligned) : 0;
+      
+      // Trim the tail off the memory block.
+      realloc(Ptr, S+Offset);
+      Ptr = (char*)Ptr + Offset;
+    }
     state.getPendingGlobals(locked).push_back(GV);
   }
   addGlobalMapping(GV, Ptr);


Index: llvm/lib/ExecutionEngine/JIT/JITEmitter.cpp
diff -u llvm/lib/ExecutionEngine/JIT/JITEmitter.cpp:1.87 llvm/lib/ExecutionEngine/JIT/JITEmitter.cpp:1.88
--- llvm/lib/ExecutionEngine/JIT/JITEmitter.cpp:1.87	Tue May  2 16:44:14 2006
+++ llvm/lib/ExecutionEngine/JIT/JITEmitter.cpp	Tue May  2 16:57:51 2006
@@ -54,9 +54,8 @@
   class JITMemoryManager {
     std::list<sys::MemoryBlock> Blocks; // List of blocks allocated by the JIT
     unsigned char *FunctionBase; // Start of the function body area
-    unsigned char *GlobalBase;   // Start of the Global area
     unsigned char *ConstantBase; // Memory allocated for constant pools
-    unsigned char *CurStubPtr, *CurFunctionPtr, *CurConstantPtr, *CurGlobalPtr;
+    unsigned char *CurStubPtr, *CurFunctionPtr, *CurConstantPtr;
     unsigned char *GOTBase;      // Target Specific reserved memory
 
     // centralize memory block allocation
@@ -68,8 +67,6 @@
     inline unsigned char *allocateStub(unsigned StubSize);
     inline unsigned char *allocateConstant(unsigned ConstantSize,
                                            unsigned Alignment);
-    inline unsigned char* allocateGlobal(unsigned Size,
-                                         unsigned Alignment);
     inline unsigned char *startFunctionBody();
     inline void endFunctionBody(unsigned char *FunctionEnd);
     
@@ -87,28 +84,22 @@
   sys::MemoryBlock FunBlock = getNewMemoryBlock(16 << 20);
   // Allocate a 1M block of memory for Constants
   sys::MemoryBlock ConstBlock = getNewMemoryBlock(1 << 20);
-  // Allocate a 1M Block of memory for Globals
-  sys::MemoryBlock GVBlock = getNewMemoryBlock(1 << 20);
 
   Blocks.push_front(FunBlock);
   Blocks.push_front(ConstBlock);
-  Blocks.push_front(GVBlock);
 
   FunctionBase = reinterpret_cast<unsigned char*>(FunBlock.base());
   ConstantBase = reinterpret_cast<unsigned char*>(ConstBlock.base());
-  GlobalBase = reinterpret_cast<unsigned char*>(GVBlock.base());
 
   // Allocate stubs backwards from the base, allocate functions forward
   // from the base.
   CurStubPtr = CurFunctionPtr = FunctionBase + 512*1024;// Use 512k for stubs
 
   CurConstantPtr = ConstantBase + ConstBlock.size();
-  CurGlobalPtr = GlobalBase + GVBlock.size();
 
-  //Allocate the GOT just like a global array
+  // Allocate the GOT.
   GOTBase = NULL;
-  if (useGOT)
-    GOTBase = allocateGlobal(sizeof(void*) * 8192, 8);
+  if (useGOT) GOTBase = (unsigned char*)malloc(sizeof(void*) * 8192);
 }
 
 JITMemoryManager::~JITMemoryManager() {
@@ -145,23 +136,6 @@
   return CurConstantPtr;
 }
 
-unsigned char *JITMemoryManager::allocateGlobal(unsigned Size,
-                                                unsigned Alignment) {
- // Reserve space and align pointer.
-  CurGlobalPtr -= Size;
-  CurGlobalPtr =
-    (unsigned char *)((intptr_t)CurGlobalPtr & ~((intptr_t)Alignment - 1));
-
-  if (CurGlobalPtr < GlobalBase) {
-    //Either allocate another MB or 2xSize
-    sys::MemoryBlock GVBlock =  getNewMemoryBlock(2 * Size);
-    GlobalBase = reinterpret_cast<unsigned char*>(GVBlock.base());
-    CurGlobalPtr = GlobalBase + GVBlock.size();
-    return allocateGlobal(Size, Alignment);
-  }
-  return CurGlobalPtr;
-}
-
 unsigned char *JITMemoryManager::startFunctionBody() {
   // Round up to an even multiple of 8 bytes, this should eventually be target
   // specific.
@@ -453,7 +427,6 @@
 
     virtual uint64_t getConstantPoolEntryAddress(unsigned Entry);
     virtual uint64_t getJumpTableEntryAddress(unsigned Entry);
-    virtual unsigned char* allocateGlobal(unsigned size, unsigned alignment);
 
   private:
     void *getPointerToGlobal(GlobalValue *GV, void *Reference, bool NoNeedStub);
@@ -681,11 +654,6 @@
   return (intptr_t)((char *)JumpTableBase + Offset);
 }
 
-unsigned char* JITEmitter::allocateGlobal(unsigned size, unsigned alignment)
-{
-  return MemMgr.allocateGlobal(size, alignment);
-}
-
 // getPointerToNamedFunction - This function is used as a global wrapper to
 // JIT::getPointerToNamedFunction for the purpose of resolving symbols when
 // bugpoint is debugging the JIT. In that scenario, we are loading an .so and