[llvm-commits] [llvm] r72650 - in /llvm/trunk: include/llvm/CodeGen/JITCodeEmitter.h include/llvm/CodeGen/MachineCodeEmitter.h include/llvm/ExecutionEngine/JITMemoryManager.h lib/CodeGen/MachOWriter.cpp lib/CodeGen/MachOWriter.h lib/ExecutionEngine/JIT/JITEmitter.cpp lib/ExecutionEngine/JIT/JITMemoryManager.cpp
Bruno Cardoso Lopes
bruno.cardoso at gmail.com
Sat May 30 16:50:33 PDT 2009
Author: bruno
Date: Sat May 30 18:50:33 2009
New Revision: 72650
URL: http://llvm.org/viewvc/llvm-project?rev=72650&view=rev
Log:
Use uint8_t and int32_t in {JIT,Machine}CodeEmiters
Modified:
llvm/trunk/include/llvm/CodeGen/JITCodeEmitter.h
llvm/trunk/include/llvm/CodeGen/MachineCodeEmitter.h
llvm/trunk/include/llvm/ExecutionEngine/JITMemoryManager.h
llvm/trunk/lib/CodeGen/MachOWriter.cpp
llvm/trunk/lib/CodeGen/MachOWriter.h
llvm/trunk/lib/ExecutionEngine/JIT/JITEmitter.cpp
llvm/trunk/lib/ExecutionEngine/JIT/JITMemoryManager.cpp
Modified: llvm/trunk/include/llvm/CodeGen/JITCodeEmitter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/JITCodeEmitter.h?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/JITCodeEmitter.h (original)
+++ llvm/trunk/include/llvm/CodeGen/JITCodeEmitter.h Sat May 30 18:50:33 2009
@@ -89,7 +89,7 @@
/// emitByte - This callback is invoked when a byte needs to be written to the
/// output stream.
///
- void emitByte(unsigned char B) {
+ void emitByte(uint8_t B) {
if (CurBufferPtr != BufferEnd)
*CurBufferPtr++ = B;
}
@@ -99,10 +99,10 @@
///
void emitWordLE(unsigned W) {
if (4 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 0);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
} else {
CurBufferPtr = BufferEnd;
}
@@ -113,10 +113,10 @@
///
void emitWordBE(unsigned W) {
if (4 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 24);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
} else {
CurBufferPtr = BufferEnd;
}
@@ -127,14 +127,14 @@
///
void emitDWordLE(uint64_t W) {
if (8 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 0);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 24);
- *CurBufferPtr++ = (unsigned char)(W >> 32);
- *CurBufferPtr++ = (unsigned char)(W >> 40);
- *CurBufferPtr++ = (unsigned char)(W >> 48);
- *CurBufferPtr++ = (unsigned char)(W >> 56);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 32);
+ *CurBufferPtr++ = (uint8_t)(W >> 40);
+ *CurBufferPtr++ = (uint8_t)(W >> 48);
+ *CurBufferPtr++ = (uint8_t)(W >> 56);
} else {
CurBufferPtr = BufferEnd;
}
@@ -145,14 +145,14 @@
///
void emitDWordBE(uint64_t W) {
if (8 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 56);
- *CurBufferPtr++ = (unsigned char)(W >> 48);
- *CurBufferPtr++ = (unsigned char)(W >> 40);
- *CurBufferPtr++ = (unsigned char)(W >> 32);
- *CurBufferPtr++ = (unsigned char)(W >> 24);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 56);
+ *CurBufferPtr++ = (uint8_t)(W >> 48);
+ *CurBufferPtr++ = (uint8_t)(W >> 40);
+ *CurBufferPtr++ = (uint8_t)(W >> 32);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
} else {
CurBufferPtr = BufferEnd;
}
@@ -166,8 +166,8 @@
if(Alignment <= (uintptr_t)(BufferEnd-CurBufferPtr)) {
// Move the current buffer ptr up to the specified alignment.
CurBufferPtr =
- (unsigned char*)(((uintptr_t)CurBufferPtr+Alignment-1) &
- ~(uintptr_t)(Alignment-1));
+ (uint8_t*)(((uintptr_t)CurBufferPtr+Alignment-1) &
+ ~(uintptr_t)(Alignment-1));
} else {
CurBufferPtr = BufferEnd;
}
@@ -178,7 +178,7 @@
/// written to the output stream.
void emitULEB128Bytes(unsigned Value) {
do {
- unsigned char Byte = Value & 0x7f;
+ uint8_t Byte = Value & 0x7f;
Value >>= 7;
if (Value) Byte |= 0x80;
emitByte(Byte);
@@ -187,12 +187,12 @@
/// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
/// written to the output stream.
- void emitSLEB128Bytes(int Value) {
- int Sign = Value >> (8 * sizeof(Value) - 1);
+ void emitSLEB128Bytes(int32_t Value) {
+ int32_t Sign = Value >> (8 * sizeof(Value) - 1);
bool IsMore;
do {
- unsigned char Byte = Value & 0x7f;
+ uint8_t Byte = Value & 0x7f;
Value >>= 7;
IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
if (IsMore) Byte |= 0x80;
@@ -205,14 +205,14 @@
void emitString(const std::string &String) {
for (unsigned i = 0, N = static_cast<unsigned>(String.size());
i < N; ++i) {
- unsigned char C = String[i];
+ uint8_t C = String[i];
emitByte(C);
}
emitByte(0);
}
/// emitInt32 - Emit a int32 directive.
- void emitInt32(int Value) {
+ void emitInt32(int32_t Value) {
if (4 <= BufferEnd-CurBufferPtr) {
*((uint32_t*)CurBufferPtr) = Value;
CurBufferPtr += 4;
Modified: llvm/trunk/include/llvm/CodeGen/MachineCodeEmitter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/CodeGen/MachineCodeEmitter.h?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/include/llvm/CodeGen/MachineCodeEmitter.h (original)
+++ llvm/trunk/include/llvm/CodeGen/MachineCodeEmitter.h Sat May 30 18:50:33 2009
@@ -50,14 +50,14 @@
protected:
/// BufferBegin/BufferEnd - Pointers to the start and end of the memory
/// allocated for this code buffer.
- unsigned char *BufferBegin, *BufferEnd;
+ uint8_t *BufferBegin, *BufferEnd;
/// CurBufferPtr - Pointer to the next byte of memory to fill when emitting
/// code. This is guranteed to be in the range [BufferBegin,BufferEnd]. If
/// this pointer is at BufferEnd, it will never move due to code emission, and
/// all code emission requests will be ignored (this is the buffer overflow
/// condition).
- unsigned char *CurBufferPtr;
+ uint8_t *CurBufferPtr;
public:
virtual ~MachineCodeEmitter() {}
@@ -96,7 +96,7 @@
/// emitByte - This callback is invoked when a byte needs to be written to the
/// output stream.
///
- void emitByte(unsigned char B) {
+ void emitByte(uint8_t B) {
if (CurBufferPtr != BufferEnd)
*CurBufferPtr++ = B;
}
@@ -106,10 +106,10 @@
///
void emitWordLE(unsigned W) {
if (4 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 0);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
} else {
CurBufferPtr = BufferEnd;
}
@@ -120,10 +120,10 @@
///
void emitWordBE(unsigned W) {
if (4 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 24);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
} else {
CurBufferPtr = BufferEnd;
}
@@ -134,14 +134,14 @@
///
void emitDWordLE(uint64_t W) {
if (8 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 0);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 24);
- *CurBufferPtr++ = (unsigned char)(W >> 32);
- *CurBufferPtr++ = (unsigned char)(W >> 40);
- *CurBufferPtr++ = (unsigned char)(W >> 48);
- *CurBufferPtr++ = (unsigned char)(W >> 56);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 32);
+ *CurBufferPtr++ = (uint8_t)(W >> 40);
+ *CurBufferPtr++ = (uint8_t)(W >> 48);
+ *CurBufferPtr++ = (uint8_t)(W >> 56);
} else {
CurBufferPtr = BufferEnd;
}
@@ -152,14 +152,14 @@
///
void emitDWordBE(uint64_t W) {
if (8 <= BufferEnd-CurBufferPtr) {
- *CurBufferPtr++ = (unsigned char)(W >> 56);
- *CurBufferPtr++ = (unsigned char)(W >> 48);
- *CurBufferPtr++ = (unsigned char)(W >> 40);
- *CurBufferPtr++ = (unsigned char)(W >> 32);
- *CurBufferPtr++ = (unsigned char)(W >> 24);
- *CurBufferPtr++ = (unsigned char)(W >> 16);
- *CurBufferPtr++ = (unsigned char)(W >> 8);
- *CurBufferPtr++ = (unsigned char)(W >> 0);
+ *CurBufferPtr++ = (uint8_t)(W >> 56);
+ *CurBufferPtr++ = (uint8_t)(W >> 48);
+ *CurBufferPtr++ = (uint8_t)(W >> 40);
+ *CurBufferPtr++ = (uint8_t)(W >> 32);
+ *CurBufferPtr++ = (uint8_t)(W >> 24);
+ *CurBufferPtr++ = (uint8_t)(W >> 16);
+ *CurBufferPtr++ = (uint8_t)(W >> 8);
+ *CurBufferPtr++ = (uint8_t)(W >> 0);
} else {
CurBufferPtr = BufferEnd;
}
@@ -173,8 +173,8 @@
if(Alignment <= (uintptr_t)(BufferEnd-CurBufferPtr)) {
// Move the current buffer ptr up to the specified alignment.
CurBufferPtr =
- (unsigned char*)(((uintptr_t)CurBufferPtr+Alignment-1) &
- ~(uintptr_t)(Alignment-1));
+ (uint8_t*)(((uintptr_t)CurBufferPtr+Alignment-1) &
+ ~(uintptr_t)(Alignment-1));
} else {
CurBufferPtr = BufferEnd;
}
@@ -185,7 +185,7 @@
/// written to the output stream.
void emitULEB128Bytes(unsigned Value) {
do {
- unsigned char Byte = Value & 0x7f;
+ uint8_t Byte = Value & 0x7f;
Value >>= 7;
if (Value) Byte |= 0x80;
emitByte(Byte);
@@ -194,12 +194,12 @@
/// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
/// written to the output stream.
- void emitSLEB128Bytes(int Value) {
- int Sign = Value >> (8 * sizeof(Value) - 1);
+ void emitSLEB128Bytes(int32_t Value) {
+ int32_t Sign = Value >> (8 * sizeof(Value) - 1);
bool IsMore;
do {
- unsigned char Byte = Value & 0x7f;
+ uint8_t Byte = Value & 0x7f;
Value >>= 7;
IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
if (IsMore) Byte |= 0x80;
@@ -212,14 +212,14 @@
void emitString(const std::string &String) {
for (unsigned i = 0, N = static_cast<unsigned>(String.size());
i < N; ++i) {
- unsigned char C = String[i];
+ uint8_t C = String[i];
emitByte(C);
}
emitByte(0);
}
/// emitInt32 - Emit a int32 directive.
- void emitInt32(int Value) {
+ void emitInt32(int32_t Value) {
if (4 <= BufferEnd-CurBufferPtr) {
*((uint32_t*)CurBufferPtr) = Value;
CurBufferPtr += 4;
Modified: llvm/trunk/include/llvm/ExecutionEngine/JITMemoryManager.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ExecutionEngine/JITMemoryManager.h?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/include/llvm/ExecutionEngine/JITMemoryManager.h (original)
+++ llvm/trunk/include/llvm/ExecutionEngine/JITMemoryManager.h Sat May 30 18:50:33 2009
@@ -60,7 +60,7 @@
/// getGOTBase - If this is managing a Global Offset Table, this method should
/// return a pointer to its base.
- virtual unsigned char *getGOTBase() const = 0;
+ virtual uint8_t *getGOTBase() const = 0;
/// SetDlsymTable - If the JIT must be able to relocate stubs after they have
/// been emitted, potentially because they are being copied to a process
@@ -89,8 +89,8 @@
/// emit the function, so it doesn't pass in the size. Instead, this method
/// is required to pass back a "valid size". The JIT will be careful to not
/// write more than the returned ActualSize bytes of memory.
- virtual unsigned char *startFunctionBody(const Function *F,
- uintptr_t &ActualSize) = 0;
+ virtual uint8_t *startFunctionBody(const Function *F,
+ uintptr_t &ActualSize) = 0;
/// allocateStub - This method is called by the JIT to allocate space for a
/// function stub (used to handle limited branch displacements) while it is
@@ -100,9 +100,8 @@
/// thunk for it. The stub should be "close" to the current function body,
/// but should not be included in the 'actualsize' returned by
/// startFunctionBody.
- virtual unsigned char *allocateStub(const GlobalValue* F, unsigned StubSize,
- unsigned Alignment) =0;
-
+ virtual uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
+ unsigned Alignment) = 0;
/// endFunctionBody - This method is called when the JIT is done codegen'ing
/// the specified function. At this point we know the size of the JIT
@@ -110,11 +109,11 @@
/// the startFunctionBody method) and FunctionEnd which is a pointer to the
/// actual end of the function. This method should mark the space allocated
/// and remember where it is in case the client wants to deallocate it.
- virtual void endFunctionBody(const Function *F, unsigned char *FunctionStart,
- unsigned char *FunctionEnd) = 0;
+ virtual void endFunctionBody(const Function *F, uint8_t *FunctionStart,
+ uint8_t *FunctionEnd) = 0;
/// allocateSpace - Allocate a memory block of the given size.
- virtual unsigned char *allocateSpace(intptr_t Size, unsigned Alignment) = 0;
+ virtual uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) = 0;
/// deallocateMemForFunction - Free JIT memory for the specified function.
/// This is never called when the JIT is currently emitting a function.
@@ -122,14 +121,13 @@
/// startExceptionTable - When we finished JITing the function, if exception
/// handling is set, we emit the exception table.
- virtual unsigned char* startExceptionTable(const Function* F,
- uintptr_t &ActualSize) = 0;
+ virtual uint8_t* startExceptionTable(const Function* F,
+ uintptr_t &ActualSize) = 0;
/// endExceptionTable - This method is called when the JIT is done emitting
/// the exception table.
- virtual void endExceptionTable(const Function *F, unsigned char *TableStart,
- unsigned char *TableEnd,
- unsigned char* FrameRegister) = 0;
+ virtual void endExceptionTable(const Function *F, uint8_t *TableStart,
+ uint8_t *TableEnd, uint8_t* FrameRegister) = 0;
};
} // end namespace llvm.
Modified: llvm/trunk/lib/CodeGen/MachOWriter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachOWriter.cpp?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MachOWriter.cpp (original)
+++ llvm/trunk/lib/CodeGen/MachOWriter.cpp Sat May 30 18:50:33 2009
@@ -847,7 +847,7 @@
break;
}
} else if (PC->getType()->isSingleValueType()) {
- unsigned char *ptr = (unsigned char *)PA;
+ uint8_t *ptr = (uint8_t *)PA;
switch (PC->getType()->getTypeID()) {
case Type::IntegerTyID: {
unsigned NumBits = cast<IntegerType>(PC->getType())->getBitWidth();
Modified: llvm/trunk/lib/CodeGen/MachOWriter.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/CodeGen/MachOWriter.h?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/lib/CodeGen/MachOWriter.h (original)
+++ llvm/trunk/lib/CodeGen/MachOWriter.h Sat May 30 18:50:33 2009
@@ -98,7 +98,7 @@
return "Mach-O Writer";
}
- typedef std::vector<unsigned char> DataBuffer;
+ typedef std::vector<uint8_t> DataBuffer;
protected:
/// Output stream to send the resultant object file to.
///
Modified: llvm/trunk/lib/ExecutionEngine/JIT/JITEmitter.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/JIT/JITEmitter.cpp?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/JIT/JITEmitter.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/JIT/JITEmitter.cpp Sat May 30 18:50:33 2009
@@ -551,7 +551,7 @@
// When outputting a function stub in the context of some other function, we
// save BufferBegin/BufferEnd/CurBufferPtr here.
- unsigned char *SavedBufferBegin, *SavedBufferEnd, *SavedCurBufferPtr;
+ uint8_t *SavedBufferBegin, *SavedBufferEnd, *SavedCurBufferPtr;
/// Relocations - These are the relocations that the function needs, as
/// emitted.
@@ -1056,11 +1056,11 @@
// FnStart is the start of the text, not the start of the constant pool and
// other per-function data.
- unsigned char *FnStart =
- (unsigned char *)TheJIT->getPointerToGlobalIfAvailable(F.getFunction());
+ uint8_t *FnStart =
+ (uint8_t *)TheJIT->getPointerToGlobalIfAvailable(F.getFunction());
// FnEnd is the end of the function's machine code.
- unsigned char *FnEnd = CurBufferPtr;
+ uint8_t *FnEnd = CurBufferPtr;
if (!Relocations.empty()) {
CurFn = F.getFunction();
@@ -1183,7 +1183,7 @@
} else {
DOUT << "JIT: Binary code:\n";
DOUT << std::hex;
- unsigned char* q = FnStart;
+ uint8_t* q = FnStart;
for (int i = 0; q < FnEnd; q += 4, ++i) {
if (i == 4)
i = 0;
@@ -1221,7 +1221,7 @@
BufferBegin = CurBufferPtr = MemMgr->startExceptionTable(F.getFunction(),
ActualSize);
BufferEnd = BufferBegin+ActualSize;
- unsigned char* FrameRegister = DE->EmitDwarfTable(F, *this, FnStart, FnEnd);
+ uint8_t* FrameRegister = DE->EmitDwarfTable(F, *this, FnStart, FnEnd);
MemMgr->endExceptionTable(F.getFunction(), BufferBegin, CurBufferPtr,
FrameRegister);
BufferBegin = SavedBufferBegin;
@@ -1416,7 +1416,7 @@
SavedBufferEnd = BufferEnd;
SavedCurBufferPtr = CurBufferPtr;
- BufferBegin = CurBufferPtr = (unsigned char *)Buffer;
+ BufferBegin = CurBufferPtr = (uint8_t *)Buffer;
BufferEnd = BufferBegin+StubSize+1;
}
Modified: llvm/trunk/lib/ExecutionEngine/JIT/JITMemoryManager.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ExecutionEngine/JIT/JITMemoryManager.cpp?rev=72650&r1=72649&r2=72650&view=diff
==============================================================================
--- llvm/trunk/lib/ExecutionEngine/JIT/JITMemoryManager.cpp (original)
+++ llvm/trunk/lib/ExecutionEngine/JIT/JITMemoryManager.cpp Sat May 30 18:50:33 2009
@@ -257,9 +257,9 @@
// When emitting code into a memory block, this is the block.
MemoryRangeHeader *CurBlock;
- unsigned char *CurStubPtr, *StubBase;
- unsigned char *GOTBase; // Target Specific reserved memory
- void *DlsymTable; // Stub external symbol information
+ uint8_t *CurStubPtr, *StubBase;
+ uint8_t *GOTBase; // Target Specific reserved memory
+ void *DlsymTable; // Stub external symbol information
// Centralize memory block allocation.
sys::MemoryBlock getNewMemoryBlock(unsigned size);
@@ -273,12 +273,12 @@
void AllocateGOT();
void SetDlsymTable(void *);
- unsigned char *allocateStub(const GlobalValue* F, unsigned StubSize,
- unsigned Alignment);
+ uint8_t *allocateStub(const GlobalValue* F, unsigned StubSize,
+ unsigned Alignment);
/// startFunctionBody - When a function starts, allocate a block of free
/// executable memory, returning a pointer to it and its actual size.
- unsigned char *startFunctionBody(const Function *F, uintptr_t &ActualSize) {
+ uint8_t *startFunctionBody(const Function *F, uintptr_t &ActualSize) {
FreeRangeHeader* candidateBlock = FreeMemoryList;
FreeRangeHeader* head = FreeMemoryList;
@@ -301,18 +301,18 @@
// Allocate the entire memory block.
FreeMemoryList = candidateBlock->AllocateBlock();
ActualSize = CurBlock->BlockSize-sizeof(MemoryRangeHeader);
- return (unsigned char *)(CurBlock+1);
+ return (uint8_t *)(CurBlock+1);
}
/// endFunctionBody - The function F is now allocated, and takes the memory
/// in the range [FunctionStart,FunctionEnd).
- void endFunctionBody(const Function *F, unsigned char *FunctionStart,
- unsigned char *FunctionEnd) {
+ void endFunctionBody(const Function *F, uint8_t *FunctionStart,
+ uint8_t *FunctionEnd) {
assert(FunctionEnd > FunctionStart);
- assert(FunctionStart == (unsigned char *)(CurBlock+1) &&
+ assert(FunctionStart == (uint8_t *)(CurBlock+1) &&
"Mismatched function start/end!");
- uintptr_t BlockSize = FunctionEnd - (unsigned char *)CurBlock;
+ uintptr_t BlockSize = FunctionEnd - (uint8_t *)CurBlock;
FunctionBlocks[F] = CurBlock;
// Release the memory at the end of this block that isn't needed.
@@ -320,17 +320,17 @@
}
/// allocateSpace - Allocate a memory block of the given size.
- unsigned char *allocateSpace(intptr_t Size, unsigned Alignment) {
+ uint8_t *allocateSpace(intptr_t Size, unsigned Alignment) {
CurBlock = FreeMemoryList;
FreeMemoryList = FreeMemoryList->AllocateBlock();
- unsigned char *result = (unsigned char *)CurBlock+1;
+ uint8_t *result = (uint8_t *)CurBlock+1;
if (Alignment == 0) Alignment = 1;
- result = (unsigned char*)(((intptr_t)result+Alignment-1) &
+ result = (uint8_t*)(((intptr_t)result+Alignment-1) &
~(intptr_t)(Alignment-1));
- uintptr_t BlockSize = result + Size - (unsigned char *)CurBlock;
+ uintptr_t BlockSize = result + Size - (uint8_t *)CurBlock;
FreeMemoryList =CurBlock->TrimAllocationToSize(FreeMemoryList, BlockSize);
return result;
@@ -338,28 +338,26 @@
/// startExceptionTable - Use startFunctionBody to allocate memory for the
/// function's exception table.
- unsigned char* startExceptionTable(const Function* F,
- uintptr_t &ActualSize) {
+ uint8_t* startExceptionTable(const Function* F, uintptr_t &ActualSize) {
return startFunctionBody(F, ActualSize);
}
/// endExceptionTable - The exception table of F is now allocated,
/// and takes the memory in the range [TableStart,TableEnd).
- void endExceptionTable(const Function *F, unsigned char *TableStart,
- unsigned char *TableEnd,
- unsigned char* FrameRegister) {
+ void endExceptionTable(const Function *F, uint8_t *TableStart,
+ uint8_t *TableEnd, uint8_t* FrameRegister) {
assert(TableEnd > TableStart);
- assert(TableStart == (unsigned char *)(CurBlock+1) &&
+ assert(TableStart == (uint8_t *)(CurBlock+1) &&
"Mismatched table start/end!");
- uintptr_t BlockSize = TableEnd - (unsigned char *)CurBlock;
+ uintptr_t BlockSize = TableEnd - (uint8_t *)CurBlock;
TableBlocks[F] = CurBlock;
// Release the memory at the end of this block that isn't needed.
FreeMemoryList =CurBlock->TrimAllocationToSize(FreeMemoryList, BlockSize);
}
- unsigned char *getGOTBase() const {
+ uint8_t *getGOTBase() const {
return GOTBase;
}
@@ -433,7 +431,7 @@
sys::MemoryBlock MemBlock = getNewMemoryBlock(16 << 20);
#endif
- unsigned char *MemBase = static_cast<unsigned char*>(MemBlock.base());
+ uint8_t *MemBase = static_cast<uint8_t*>(MemBlock.base());
// Allocate stubs backwards from the base, allocate functions forward
// from the base.
@@ -492,7 +490,7 @@
void DefaultJITMemoryManager::AllocateGOT() {
assert(GOTBase == 0 && "Cannot allocate the got multiple times");
- GOTBase = new unsigned char[sizeof(void*) * 8192];
+ GOTBase = new uint8_t[sizeof(void*) * 8192];
HasGOT = true;
}
@@ -508,12 +506,12 @@
Blocks.clear();
}
-unsigned char *DefaultJITMemoryManager::allocateStub(const GlobalValue* F,
+uint8_t *DefaultJITMemoryManager::allocateStub(const GlobalValue* F,
unsigned StubSize,
unsigned Alignment) {
CurStubPtr -= StubSize;
- CurStubPtr = (unsigned char*)(((intptr_t)CurStubPtr) &
- ~(intptr_t)(Alignment-1));
+ CurStubPtr = (uint8_t*)(((intptr_t)CurStubPtr) &
+ ~(intptr_t)(Alignment-1));
if (CurStubPtr < StubBase) {
// FIXME: allocate a new block
fprintf(stderr, "JIT ran out of memory for function stubs!\n");
More information about the llvm-commits
mailing list