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
_______________________________________________
llvm-commits mailing list
llvm-commits@cs.uiuc.edu
http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits
