[vmkit-commits] [vmkit] r61450 - in /vmkit/trunk: ./ include/mvm/ include/mvm/Threads/ lib/JnJVM/LLVMRuntime/ lib/JnJVM/VMCore/ lib/Mvm/CommonThread/ lib/Mvm/GCMmap2/ lib/Mvm/Runtime/ tools/vtoffset/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Sat Dec 27 07:42:24 PST 2008
Author: geoffray
Date: Sat Dec 27 09:42:21 2008
New Revision: 61450
URL: http://llvm.org/viewvc/llvm-project?rev=61450&view=rev
Log:
- Add a SpinLock implementation, based on the LLVM cas functions.
- Caches for interface methods in Java use the spin lock.
- Add tracer and finalizer support in static compilation
- Make native VTs extern instead of class static, so that LLVM code
can reference them.
- Separate what should be llc-native compiled and llc-cppgen
compiled.
Added:
vmkit/trunk/lib/Mvm/Runtime/LLVMAssembly.ll
Modified:
vmkit/trunk/Makefile.rules
vmkit/trunk/include/mvm/JIT.h
vmkit/trunk/include/mvm/Threads/Locks.h
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-multi-mmap.ll
vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single-mmap.ll
vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h
vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h
vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
vmkit/trunk/lib/Mvm/GCMmap2/gcthread.cpp
vmkit/trunk/lib/Mvm/Runtime/JIT.cpp
vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll
vmkit/trunk/lib/Mvm/Runtime/Makefile
vmkit/trunk/tools/vtoffset/VTOffset.cpp
Modified: vmkit/trunk/Makefile.rules
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.rules?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/Makefile.rules (original)
+++ vmkit/trunk/Makefile.rules Sat Dec 27 09:42:21 2008
@@ -14,6 +14,23 @@
clean-local::
- $(Verb) $(RM) -f LLVMRuntime.inc LLVMRuntime.gen.ll
+ $(Verb) $(RM) -f LLVMRuntime.inc LLVMRuntime.gen.ll LLVMRuntime.bc
+
+endif
+
+ifdef VMKIT_ASSEMBLY
+
+.PRECIOUS: LLVMAssembly.s
+
+LLVMAssembly.s : $(LLVMAS) $(LLC) $(VMKIT_ASSEMBLY)
+
+LLVMAssembly.s : LLVMAssembly.ll
+ $(Echo) "Building LLVM assembly with $(VMKIT_ASSEMBLY)"
+ $(Verb) $(LLVMAS) -f $(<F) -o - | $(LLC) -f -o $@
+ $(Verb) $(MKDIR) $(BuildMode)
+ $(Verb) $(GAS) $@ -o $(BuildMode)/LLVMAssembly.o
+
+clean-local::
+ $(Verb) $(RM) -f LLVMAssembly.s LLVMAssembly.bc
endif
Modified: vmkit/trunk/include/mvm/JIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/JIT.h (original)
+++ vmkit/trunk/include/mvm/JIT.h Sat Dec 27 09:42:21 2008
@@ -170,47 +170,9 @@
static const llvm::Function* getCodeFromPointer(void* addr);
static void addMethodInfo(void* end, const llvm::Function* F);
- static uint8 (*llvm_atomic_cmp_swap_i8) (uint8* ptr, uint8 cmp,
- uint8 val);
- static uint16 (*llvm_atomic_cmp_swap_i16) (uint16* ptr, uint16 cmp,
- uint16 val);
- static uint32 (*llvm_atomic_cmp_swap_i32) (uint32* ptr, uint32 cmp,
- uint32 val);
- static uint64 (*llvm_atomic_cmp_swap_i64) (uint64* ptr, uint64 cmp,
- uint64 val);
};
-// TODO: find what macro for gcc < 4.2
-
-#define __sync_bool_compare_and_swap_32(ptr, cmp, val) \
- (mvm::MvmModule::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), \
- (uint32)(val)) == (uint32)(cmp))
-
-#if (__WORDSIZE == 64)
-
-#define __sync_bool_compare_and_swap(ptr, cmp, val) \
- (mvm::MvmModule::llvm_atomic_cmp_swap_i64((uint64*)(ptr), (uint64)(cmp), \
- (uint64)(val)) == (uint64)(cmp))
-
-#define __sync_val_compare_and_swap(ptr, cmp,val) \
- mvm::MvmModule::llvm_atomic_cmp_swap_i64((uint64*)(ptr), (uint64)(cmp), \
- (uint64)(val))
-
-
-#else
-
-
-
-#define __sync_bool_compare_and_swap(ptr, cmp, val) \
- (mvm::MvmModule::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), \
- (uint32)(val)) == (uint32)(cmp))
-
-#define __sync_val_compare_and_swap(ptr, cmp,val) \
- mvm::MvmModule::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), \
- (uint32)(val))
-#endif
-
} // end namespace mvm
#endif // MVM_JIT_H
Modified: vmkit/trunk/include/mvm/Threads/Locks.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Locks.h?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/Threads/Locks.h (original)
+++ vmkit/trunk/include/mvm/Threads/Locks.h Sat Dec 27 09:42:21 2008
@@ -12,59 +12,132 @@
#include <pthread.h>
-#include "mvm/JIT.h"
#include "mvm/Threads/Thread.h"
namespace mvm {
+extern "C" uint8 llvm_atomic_cmp_swap_i8(uint8* ptr, uint8 cmp,
+ uint8 val);
+extern "C" uint16 llvm_atomic_cmp_swap_i16(uint16* ptr, uint16 cmp,
+ uint16 val);
+extern "C" uint32 llvm_atomic_cmp_swap_i32(uint32* ptr, uint32 cmp,
+ uint32 val);
+extern "C" uint64 llvm_atomic_cmp_swap_i64(uint64* ptr, uint64 cmp,
+ uint64 val);
+
+// TODO: find what macro for gcc < 4.2
+
+#define __sync_bool_compare_and_swap_32(ptr, cmp, val) \
+ mvm::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), \
+ (uint32)(val)) == (uint32)(cmp)
+
+#if (__WORDSIZE == 64)
+
+#define __sync_bool_compare_and_swap(ptr, cmp, val) \
+ mvm::llvm_atomic_cmp_swap_i64((uint64*)(ptr), (uint64)(cmp), \
+ (uint64)(val)) == (uint64)(cmp)
+
+#define __sync_val_compare_and_swap(ptr, cmp,val) \
+ mvm::llvm_atomic_cmp_swap_i64((uint64*)(ptr), (uint64)(cmp), \
+ (uint64)(val))
+
+
+#else
+
+
+
+#define __sync_bool_compare_and_swap(ptr, cmp, val) \
+ mvm::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), \
+ (uint32)(val)) == (uint32)(cmp)
+
+#define __sync_val_compare_and_swap(ptr, cmp,val) \
+ mvm::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), \
+ (uint32)(val))
+#endif
+
+
class Cond;
class LockNormal;
class LockRecursive;
class Thread;
+/// Lock - This class is an abstract class for declaring recursive and normal
+/// locks.
+///
class Lock {
friend class Cond;
protected:
+ /// owner - Which thread is currently holding the lock?
+ ///
mvm::Thread* owner;
+
+ /// internalLock - The lock implementation of the platform.
+ ///
pthread_mutex_t internalLock;
public:
+
+ /// Lock - Creates a lock, recursive if rec is true.
+ ///
Lock(bool rec);
+ /// ~Lock - Give it a home.
+ ///
virtual ~Lock();
+ /// lock - Acquire the lock.
+ ///
virtual void lock() = 0;
+
+ /// unlock - Release the lock.
+ ///
virtual void unlock() = 0;
+ /// selfOwner - Is the current thread holding the lock?
+ ///
bool selfOwner();
+
+ /// getOwner - Get the thread that is holding the lock.
+ ///
mvm::Thread* getOwner();
};
+/// LockNormal - A non-recursive lock.
class LockNormal : public Lock {
public:
LockNormal() : Lock(false) {}
+
virtual void lock();
virtual void unlock();
};
-
+
+/// LockRecursive - A recursive lock.
class LockRecursive : public Lock {
private:
+
+ /// n - Number of times the lock has been locked.
+ ///
int n;
public:
- LockRecursive() : Lock(true) {
- n = 0;
- }
+ LockRecursive() : Lock(true) { n = 0; }
virtual void lock();
virtual void unlock();
- int recursionCount() {
- return n;
- }
+ /// recursionCount - Get the number of times the lock has been locked.
+ ///
+ int recursionCount() { return n; }
+
+ /// unlockAll - Unlock the lock, releasing it the number of times it is held.
+ /// Return the number of times the lock has been locked.
+ ///
int unlockAll();
+
+ /// lockAll - Acquire the lock count times.
+ ///
void lockAll(int count);
};
@@ -140,8 +213,8 @@
} else {
uintptr_t currentLock = lock & ThinMask;
uintptr_t val =
- (uintptr_t)__sync_val_compare_and_swap((uintptr_t)&lock, currentLock,
- (id + 1));
+ (uintptr_t)__sync_val_compare_and_swap((uintptr_t)&lock, currentLock,
+ (id + 1));
if (val != currentLock) {
if (val & FatMask) {
end:
@@ -169,8 +242,8 @@
currentLock = lock & ThinMask;
uintptr_t test =
- (uintptr_t)__sync_val_compare_and_swap((uintptr_t)&lock, currentLock,
- val);
+ (uintptr_t)__sync_val_compare_and_swap((uintptr_t)&lock,
+ currentLock, val);
if (test != currentLock) goto loop;
obj->acquire();
}
@@ -228,6 +301,38 @@
}
};
+
+/// SpinLock - This class implements a spin lock. A spin lock is OK to use
+/// when it is held during short period of times. It is CPU expensive
+/// otherwise.
+class SpinLock {
+public:
+
+ /// locked - Is the spin lock locked?
+ ///
+ uint8 locked;
+
+ /// SpinLock - Initialize the lock as not being held.
+ ///
+ SpinLock() { locked = 0; }
+
+
+ /// acquire - Acquire the spin lock, doing an active loop. When the lock
+ /// is already held, yield the processor.
+ ///
+ void acquire() {
+ uint32 count = 0;
+ while (!(llvm_atomic_cmp_swap_i8(&locked, 0, 1)))
+ mvm::Thread::yield(&count);
+ }
+
+ /// release - Release the spin lock. This must be called by the thread
+ /// holding it.
+ ///
+ void release() { locked = 0; }
+};
+
+
} // end namespace mvm
#endif // MVM_LOCKS_H
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Sat Dec 27 09:42:21 2008
@@ -26,7 +26,7 @@
;;; The Enveloppe type, which contains the first cache and all the info
;;; to lookup in the constant pool.
-%Enveloppe = type { %CacheNode*, %UTF8*, %UTF8*, i8*, i8*, %CacheNode }
+%Enveloppe = type { %CacheNode*, %UTF8*, %UTF8*, i8, %JavaClass*, %CacheNode }
;;; The task class mirror.
;;; Field 1: The class state
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-multi-mmap.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-multi-mmap.ll?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-multi-mmap.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-multi-mmap.ll Sat Dec 27 09:42:21 2008
@@ -4,3 +4,5 @@
declare void @MarkAndTrace(%JavaObject*, i8*)
declare void @JavaObjectTracer(%JavaObject*, i8*)
+declare void @JavaArrayTracer(%JavaObject*, i8*)
+declare void @ArrayObjectTracer(%JavaObject*, i8*)
Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single-mmap.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single-mmap.ll?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single-mmap.ll (original)
+++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single-mmap.ll Sat Dec 27 09:42:21 2008
@@ -4,3 +4,5 @@
declare void @MarkAndTrace(%JavaObject*)
declare void @JavaObjectTracer(%JavaObject*)
+declare void @JavaArrayTracer(%JavaObject*)
+declare void @ArrayObjectTracer(%JavaObject*)
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Sat Dec 27 09:42:21 2008
@@ -50,10 +50,6 @@
class JavaArray : public TJavaArray<void*> {
public:
- /// VT - The virtual table of Java arrays of primitive types (e.g. int,
- /// double).
- static VirtualTable *VT;
-
/// MaxArraySize - The maximum size a Java array can have. Allocating an
/// array with a bigger size than MaxArraySize raises an out of memory
/// error.
@@ -98,9 +94,6 @@
/// they have to trace all objects in the array.
class ArrayObject : public TJavaArray<JavaObject*> {
public:
- /// VT - The virtual table of arrays of objects.
- static VirtualTable *VT;
-
/// tracer - The tracer method of Java arrays of objects. This method will
/// trace all objects in the array.
virtual void TRACER;
@@ -159,16 +152,19 @@
/// UTF8ToAsciiz - Allocates a C string with the contents of this UTF8.
char* UTF8ToAsciiz() const;
+ /// printString - Allocates a C string with the contents of this UTF8.
char* printString() const {
return UTF8ToAsciiz();
}
+ /// equals - Are the two UTF8s equals?
bool equals(const UTF8* other) const {
if (other == this) return true;
else if (size != other->size) return false;
else return !memcmp(elements, other->elements, size * sizeof(uint16));
}
+ /// lessThan - strcmp-like function for UTF8s, used by hash tables.
bool lessThan(const UTF8* other) const {
if (size < other->size) return true;
else if (size > other->size) return false;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Sat Dec 27 09:42:21 2008
@@ -81,12 +81,11 @@
/// cacheLock - The linked list may be modified by concurrent thread. This
/// lock ensures that the list stays consistent.
///
- mvm::LockNormal cacheLock;
+ mvm::SpinLock cacheLock;
- /// allocator - Reference to the allocator in order to know where to allocate
- /// cache nodes.
+ /// classDef - The class that is defining the enveloppe.
///
- mvm::BumpPtrAllocator* allocator;
+ Class* classDef;
/// bootCache - The first cache allocated for the enveloppe.
///
@@ -100,17 +99,16 @@
/// so as the resolution process knows which interface method the
/// invokeinterface bytecode refers to.
///
- Enveloppe(mvm::BumpPtrAllocator& Alloc, const UTF8* name, const UTF8* sign) :
+ Enveloppe(Class* C, const UTF8* name, const UTF8* sign) :
bootCache(this) {
- initialise(Alloc, name, sign);
+ initialise(C, name, sign);
}
/// initialise - Initialises the enveloppe, and allocates the first cache.
///
- void initialise(mvm::BumpPtrAllocator& Alloc, const UTF8* name,
- const UTF8* sign) {
- allocator = &Alloc;
+ void initialise(Class* C, const UTF8* name, const UTF8* sign) {
+ classDef = C;
firstCache = &bootCache;
methodName = name;
methodSign = sign;
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sat Dec 27 09:42:21 2008
@@ -43,6 +43,9 @@
Class* ClassArray::SuperArray;
Class** ClassArray::InterfacesArray;
+extern void* JavaArrayVT[];
+extern void* ArrayObjectVT[];
+
Attribut::Attribut(const UTF8* name, uint32 length,
uint32 offset) {
@@ -332,7 +335,7 @@
uint32 primSize = cl->isPrimitive() ?
cl->asPrimitiveClass()->primSize : sizeof(JavaObject*);
- VirtualTable* VT = cl->isPrimitive() ? JavaArray::VT : ArrayObject::VT;
+ VirtualTable* VT = cl->isPrimitive() ? JavaArrayVT : ArrayObjectVT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + n * primSize;
JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size, VT);
res->initialise(this);
@@ -345,7 +348,7 @@
uint32 primSize = cl->isPrimitive() ?
cl->asPrimitiveClass()->primSize : sizeof(JavaObject*);
- VirtualTable* VT = cl->isPrimitive() ? JavaArray::VT : ArrayObject::VT;
+ VirtualTable* VT = cl->isPrimitive() ? JavaArrayVT : ArrayObjectVT;
uint32 size = sizeof(JavaObject) + sizeof(ssize_t) + n * primSize;
JavaArray* res = (JavaArray*)allocator.Allocate(size);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sat Dec 27 09:42:21 2008
@@ -21,6 +21,11 @@
using namespace jnjvm;
+
+void* JavaArrayVT[12 + VT_SIZE];
+void* ArrayObjectVT[12 + VT_SIZE];
+void* JavaObjectVT[12 + VT_SIZE];
+
static void initialiseVT() {
# define INIT(X) { \
@@ -44,9 +49,8 @@
#define INIT(X) { \
X fake; \
void* V = ((void**)(void*)(&fake))[0]; \
- X::VT = (VirtualTable*)malloc(12 * sizeof(void*) + VT_SIZE); \
- memcpy(X::VT, V, VT_SIZE); \
- ((void**)X::VT)[0] = 0; }
+ memcpy(X##VT, V, VT_SIZE); \
+ ((void**)X##VT)[0] = 0; }
INIT(JavaObject);
INIT(JavaArray);
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sat Dec 27 09:42:21 2008
@@ -2031,8 +2031,7 @@
*(new (compilingClass->classLoader->allocator) Enveloppe()) :
compilingMethod->enveloppes[nbEnveloppes++];
if (!inlining)
- enveloppe.initialise(compilingClass->classLoader->allocator, name,
- signature->keyName);
+ enveloppe.initialise(compilingClass, name, signature->keyName);
Value* llvmEnv = module->getEnveloppe(&enveloppe);
#else
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Sat Dec 27 09:42:21 2008
@@ -126,7 +126,6 @@
public:
- static VirtualTable* VT;
/// classOf - The class of this object.
///
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Sat Dec 27 09:42:21 2008
@@ -36,7 +36,7 @@
"Class not ready in a virtual lookup.");
#endif
- enveloppe->cacheLock.lock();
+ enveloppe->cacheLock.acquire();
CacheNode* rcache = 0;
CacheNode* tmp = enveloppe->firstCache;
CacheNode* last = tmp;
@@ -65,7 +65,9 @@
// Are we the first cache?
if (cache != &(enveloppe->bootCache)) {
- rcache = new(*(enveloppe->allocator)) CacheNode(enveloppe);
+ mvm::BumpPtrAllocator& alloc =
+ enveloppe->classDef->classLoader->allocator;
+ rcache = new(alloc) CacheNode(enveloppe);
} else {
rcache = cache;
}
@@ -82,7 +84,7 @@
rcache->next = f;
}
- enveloppe->cacheLock.unlock();
+ enveloppe->cacheLock.release();
return rcache->methPtr;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Sat Dec 27 09:42:21 2008
@@ -33,6 +33,10 @@
llvm::Constant* JnjvmModule::PrimitiveArrayVT;
llvm::Constant* JnjvmModule::ReferenceArrayVT;
+extern void* JavaArrayVT[];
+extern void* ArrayObjectVT[];
+extern void* JavaObjectVT[];
+
#ifdef WITH_TRACER
const llvm::FunctionType* JnjvmModule::MarkAndTraceType = 0;
#endif
@@ -290,9 +294,13 @@
res = ConstantExpr::getCast(Instruction::BitCast, varGV, VTType);
virtualTables.insert(std::make_pair(classDef, res));
-
+
+ Function* Finalizer = ((Function**)classDef->virtualVT)[0];
+ LLVMClassInfo* LCI = getClassInfo((Class*)classDef);
+ Function* Tracer = LCI->getVirtualTracer();
Constant* C = CreateConstantFromVT(classDef->virtualVT,
- classDef->virtualTableSize);
+ classDef->virtualTableSize, Finalizer,
+ Tracer);
varGV->setInitializer(C);
return res;
@@ -376,7 +384,7 @@
assert(super->virtualVT && "Super does not have a VT!");
memcpy(VT, super->virtualVT, cl->super->virtualTableSize * sizeof(void*));
} else {
- VT = JavaObject::VT;
+ VT = JavaObjectVT;
}
return VT;
}
@@ -463,7 +471,8 @@
dyn_cast<StructType>(JavaObjectType->getContainedType(0));
std::vector<Constant*> Elmts;
-
+
+ // virtual table
if (cl->isClass()) {
Elmts.push_back(getVirtualTable(cl->asClass()));
} else {
@@ -475,11 +484,14 @@
}
}
+ // classof
Constant* Cl = getNativeClass(cl);
Constant* ClGEPs[2] = { constantZero, constantZero };
Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2);
Elmts.push_back(Cl);
+
+ // lock
Elmts.push_back(Constant::getNullValue(ptrType));
return ConstantStruct::get(STy, Elmts);
@@ -493,6 +505,7 @@
std::vector<Constant*> Elmts;
+ // JavaObject
Elmts.push_back(CreateConstantForJavaObject(cl));
// signers
@@ -564,8 +577,8 @@
Elmts.push_back(getUTF8(val->methodName));
Elmts.push_back(getUTF8(val->methodSign));
- Elmts.push_back(Constant::getNullValue(ptrType));
- Elmts.push_back(Constant::getNullValue(ptrType));
+ Elmts.push_back(Constant::getNullValue(Type::Int8Ty));
+ Elmts.push_back(getNativeClass(val->classDef));
Elmts.push_back(firstCache);
return ConstantStruct::get(STy, Elmts);
@@ -1082,24 +1095,30 @@
}
}
-Constant* JnjvmModule::CreateConstantFromVT(VirtualTable* VT, uint32 size) {
+Constant* JnjvmModule::CreateConstantFromVT(VirtualTable* VT, uint32 size,
+ Function* Finalizer,
+ Function* Tracer) {
const ArrayType* ATy = dyn_cast<ArrayType>(VTType->getContainedType(0));
const PointerType* PTy = dyn_cast<PointerType>(ATy->getContainedType(0));
ATy = ArrayType::get(PTy, size);
ConstantPointerNull* N = ConstantPointerNull::get(PTy);
std::vector<Constant*> Elemts;
-
- Elemts.push_back(N); // Destructor
+
+ // Destructor
+ Elemts.push_back(Finalizer ?
+ ConstantExpr::getCast(Instruction::BitCast, Finalizer, PTy) : N);
Elemts.push_back(N); // Delete
- Elemts.push_back(N); // Tracer
+
+ // Tracer
+ Elemts.push_back(Tracer ?
+ ConstantExpr::getCast(Instruction::BitCast, Tracer, PTy) : N);
Elemts.push_back(N); // Printer
Elemts.push_back(N); // Hashcode
for (uint32 i = VT_NB_FUNCS; i < size; ++i) {
Function* F = ((Function**)VT)[i];
- Constant* C = ConstantExpr::getCast(Instruction::BitCast, F, PTy);
- Elemts.push_back(C);
+ Elemts.push_back(ConstantExpr::getCast(Instruction::BitCast, F, PTy));
}
Constant* Array = ConstantArray::get(ATy, Elemts);
@@ -1113,7 +1132,7 @@
#ifdef WITHOUT_VTABLE
mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator;
VT = (VirtualTable*)allocator.Allocate(VT_SIZE);
- memcpy(VT, JavaObject::VT, VT_SIZE);
+ memcpy(VT, JavaObjectVT, VT_SIZE);
#else
if (cl->super) {
cl->virtualTableSize = cl->super->virtualTableSize;
@@ -1152,8 +1171,8 @@
((void**)VT)[0] = EE->getPointerToFunction(func);
}
}
- }
#endif
+ }
if (staticCompilation) {
((void**)VT)[meth.offset] = func;
@@ -1167,27 +1186,14 @@
if (!(cl->super)) {
uint32 size = (cl->virtualTableSize - VT_NB_FUNCS) * sizeof(void*);
#define COPY(CLASS) \
- memcpy((void*)((uintptr_t)CLASS::VT + VT_SIZE), \
+ memcpy((void*)((uintptr_t)CLASS + VT_SIZE), \
(void*)((uintptr_t)VT + VT_SIZE), size);
- COPY(JavaArray)
- COPY(ArrayObject)
+ COPY(JavaArrayVT)
+ COPY(ArrayObjectVT)
#undef COPY
- if (staticCompilation) {
- Constant* C = CreateConstantFromVT(JavaArray::VT, cl->virtualTableSize);
- ((GlobalVariable*)PrimitiveArrayVT)->setInitializer(C);
- PrimitiveArrayVT = ConstantExpr::getCast(Instruction::BitCast,
- PrimitiveArrayVT, VTType);
-
-
- C = CreateConstantFromVT(ArrayObject::VT, cl->virtualTableSize);
- ((GlobalVariable*)ReferenceArrayVT)->setInitializer(C);
- ReferenceArrayVT = ConstantExpr::getCast(Instruction::BitCast,
- ReferenceArrayVT, VTType);
- }
-
}
#endif
@@ -1783,18 +1789,18 @@
ATy = ArrayType::get(PTy, 16);
PrimitiveArrayVT = new GlobalVariable(ATy, true,
GlobalValue::ExternalLinkage,
- 0, "PrimitiveArrayVT", this);
+ 0, "JavaArrayVT", this);
ReferenceArrayVT = new GlobalVariable(ATy, true,
GlobalValue::ExternalLinkage,
- 0, "ReferenceArrayVT", this);
+ 0, "ArrayObjectVT", this);
} else {
PrimitiveArrayVT = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty,
- uint64(JavaArray::VT)),
+ uint64(JavaArrayVT)),
VTType);
ReferenceArrayVT = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty,
- uint64(ArrayObject::VT)),
+ uint64(ArrayObjectVT)),
VTType);
}
@@ -1935,6 +1941,8 @@
#ifdef WITH_TRACER
MarkAndTraceFunction = module->getFunction("MarkAndTrace");
JavaObjectTracerFunction = module->getFunction("JavaObjectTracer");
+ JavaArrayTracerFunction = module->getFunction("JavaArrayTracer");
+ ArrayObjectTracerFunction = module->getFunction("ArrayObjectTracer");
#endif
#ifndef WITHOUT_VTABLE
Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Sat Dec 27 09:42:21 2008
@@ -276,6 +276,8 @@
llvm::Function* MarkAndTraceFunction;
static const llvm::FunctionType* MarkAndTraceType;
llvm::Function* JavaObjectTracerFunction;
+ llvm::Function* JavaArrayTracerFunction;
+ llvm::Function* ArrayObjectTracerFunction;
#endif
llvm::Function* GetSJLJBufferFunction;
@@ -415,7 +417,9 @@
static llvm::Module* initialModule;
//--------------- Static compiler specific functions -----------------------//
- llvm::Constant* CreateConstantFromVT(VirtualTable* VT, uint32 size);
+ llvm::Constant* CreateConstantFromVT(VirtualTable* VT, uint32 size,
+ llvm::Function* Finalizer,
+ llvm::Function* Tracer);
llvm::Constant* CreateConstantFromUTF8(const UTF8* val);
llvm::Constant* CreateConstantFromEnveloppe(Enveloppe* val);
llvm::Constant* CreateConstantFromCacheNode(CacheNode* CN);
Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Sat Dec 27 09:42:21 2008
@@ -27,9 +27,6 @@
#define INIT(X) VirtualTable* X::VT = 0
- INIT(JavaArray);
- INIT(ArrayObject);
- INIT(JavaObject);
INIT(JavaThread);
INIT(Jnjvm);
INIT(JnjvmBootstrapLoader);
Modified: vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctlock.cpp Sat Dec 27 09:42:21 2008
@@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
+#include <cassert>
+
#include "mvm/Threads/Cond.h"
#include "mvm/Threads/Locks.h"
#include "mvm/Threads/Thread.h"
Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Sat Dec 27 09:42:21 2008
@@ -12,10 +12,13 @@
#include "mvm/Threads/Locks.h"
#include "mvm/Threads/Thread.h"
+#include <cassert>
#include <csignal>
+#include <cstdio>
#include <ctime>
#include <pthread.h>
#include <sys/mman.h>
+#include <unistd.h>
using namespace mvm;
Modified: vmkit/trunk/lib/Mvm/GCMmap2/gcthread.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gcthread.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/GCMmap2/gcthread.cpp (original)
+++ vmkit/trunk/lib/Mvm/GCMmap2/gcthread.cpp Sat Dec 27 09:42:21 2008
@@ -7,6 +7,7 @@
//
//===----------------------------------------------------------------------===//
+#include <cassert>
#include "gccollector.h"
using namespace mvm;
Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Sat Dec 27 09:42:21 2008
@@ -79,21 +79,6 @@
module.setDataLayout(str);
mvm::llvm_runtime::makeLLVMModuleContents(&module);
- llvm_atomic_cmp_swap_i8 = (uint8 (*)(uint8*, uint8, uint8))
- (uintptr_t)executionEngine->getPointerToFunction(
- module.getFunction("runtime.llvm.atomic.cmp.swap.i8"));
- llvm_atomic_cmp_swap_i16 = (uint16 (*)(uint16*, uint16, uint16))
- (uintptr_t)executionEngine->getPointerToFunction(
- module.getFunction("runtime.llvm.atomic.cmp.swap.i16"));
- llvm_atomic_cmp_swap_i32 = (uint32 (*)(uint32*, uint32, uint32))
- (uintptr_t)executionEngine->getPointerToFunction(
- module.getFunction("runtime.llvm.atomic.cmp.swap.i32"));
-#if ((!defined(__ppc__) && !defined(__PPC__)) || defined(__ppc64__))
- llvm_atomic_cmp_swap_i64 = (uint64 (*)(uint64*, uint64, uint64))
- (uintptr_t)executionEngine->getPointerToFunction(
- module.getFunction("runtime.llvm.atomic.cmp.swap.i64"));
-#endif
-
// Type declaration
ptrType = PointerType::getUnqual(Type::Int8Ty);
ptr32Type = PointerType::getUnqual(Type::Int32Ty);
@@ -272,16 +257,6 @@
mvm::MvmMemoryManager *MvmModule::memoryManager;
-uint8 (*MvmModule::llvm_atomic_cmp_swap_i8) (uint8* ptr, uint8 cmp,
- uint8 val);
-uint16 (*MvmModule::llvm_atomic_cmp_swap_i16) (uint16* ptr, uint16 cmp,
- uint16 val);
-uint32 (*MvmModule::llvm_atomic_cmp_swap_i32) (uint32* ptr, uint32 cmp,
- uint32 val);
-uint64 (*MvmModule::llvm_atomic_cmp_swap_i64) (uint64* ptr, uint64 cmp,
- uint64 val);
-
-
uint64 MvmModule::getTypeSize(const llvm::Type* type) {
return executionEngine->getTargetData()->getABITypeSize(type);
}
Added: vmkit/trunk/lib/Mvm/Runtime/LLVMAssembly.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/LLVMAssembly.ll?rev=61450&view=auto
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/LLVMAssembly.ll (added)
+++ vmkit/trunk/lib/Mvm/Runtime/LLVMAssembly.ll Sat Dec 27 09:42:21 2008
@@ -0,0 +1,36 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Atomic ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+declare i8 @llvm.atomic.cmp.swap.i8.p0i8(i8*, i8, i8) nounwind
+declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16*, i16, i16) nounwind
+declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32*, i32, i32) nounwind
+declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64*, i64, i64) nounwind
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;Helper functions for gcc < 4.2 ;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+define i8 @llvm_atomic_cmp_swap_i8(i8* %ptr, i8 %cmp, i8 %swap)
+nounwind {
+ %A = call i8 @llvm.atomic.cmp.swap.i8.p0i8( i8* %ptr, i8 %cmp, i8 %swap)
+ ret i8 %A
+}
+
+define i16 @llvm_atomic_cmp_swap_i16(i16* %ptr, i16 %cmp, i16 %swap)
+nounwind {
+ %A = call i16 @llvm.atomic.cmp.swap.i16.p0i16( i16* %ptr, i16 %cmp, i16 %swap)
+ ret i16 %A
+}
+
+define i32 @llvm_atomic_cmp_swap_i32(i32* %ptr, i32 %cmp, i32 %swap)
+nounwind {
+ %A = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 %cmp, i32 %swap)
+ ret i32 %A
+}
+
+define i64 @llvm_atomic_cmp_swap_i64(i64* %ptr, i64 %cmp, i64 %swap)
+nounwind {
+ %A = call i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* %ptr, i64 %cmp, i64 %swap)
+ ret i64 %A
+}
Modified: vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll (original)
+++ vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Sat Dec 27 09:42:21 2008
@@ -73,31 +73,3 @@
declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16*, i16, i16) nounwind
declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32*, i32, i32) nounwind
declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64*, i64, i64) nounwind
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;Helper functions for gcc < 4.2 ;;;;;;;;;;;;;;;;;;;;;;;;
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-define i8 @runtime.llvm.atomic.cmp.swap.i8(i8* %ptr, i8 %cmp, i8 %swap)
-nounwind {
- %A = call i8 @llvm.atomic.cmp.swap.i8.p0i8( i8* %ptr, i8 %cmp, i8 %swap)
- ret i8 %A
-}
-
-define i16 @runtime.llvm.atomic.cmp.swap.i16(i16* %ptr, i16 %cmp, i16 %swap)
-nounwind {
- %A = call i16 @llvm.atomic.cmp.swap.i16.p0i16( i16* %ptr, i16 %cmp, i16 %swap)
- ret i16 %A
-}
-
-define i32 @runtime.llvm.atomic.cmp.swap.i32(i32* %ptr, i32 %cmp, i32 %swap)
-nounwind {
- %A = call i32 @llvm.atomic.cmp.swap.i32.p0i32(i32* %ptr, i32 %cmp, i32 %swap)
- ret i32 %A
-}
-
-define i64 @runtime.llvm.atomic.cmp.swap.i64(i64* %ptr, i64 %cmp, i64 %swap)
-nounwind {
- %A = call i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* %ptr, i64 %cmp, i64 %swap)
- ret i64 %A
-}
Modified: vmkit/trunk/lib/Mvm/Runtime/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Makefile?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/Makefile (original)
+++ vmkit/trunk/lib/Mvm/Runtime/Makefile Sat Dec 27 09:42:21 2008
@@ -12,6 +12,9 @@
LIBRARYNAME = Mvm
VMKIT_RUNTIME = $(PROJ_SRC_DIR)/LLVMRuntime.ll
-BUILT_SOURCES = LLVMRuntime.inc
+VMKIT_ASSEMBLY = $(PROJ_SRC_DIR)/LLVMAssembly.ll
+BUILT_SOURCES = LLVMRuntime.inc LLVMAssembly.s
+
+SOURCES = LLVMAssembly.s $(notdir $(wildcard $(PROJ_SRC_DIR)/*.cpp))
include $(LEVEL)/Makefile.common
Modified: vmkit/trunk/tools/vtoffset/VTOffset.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vtoffset/VTOffset.cpp?rev=61450&r1=61449&r2=61450&view=diff
==============================================================================
--- vmkit/trunk/tools/vtoffset/VTOffset.cpp (original)
+++ vmkit/trunk/tools/vtoffset/VTOffset.cpp Sat Dec 27 09:42:21 2008
@@ -71,7 +71,7 @@
printf("ptr[0] = %d, ptr[1]= %d, ptr[2] = %d ptr[3] = %d ptr[4] = %d ptr[5] = %d\n", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
printf("0 = \n");
ptr[0](&t);
- //ptr[1](&t); // This should be ~gc
+ //ptr[1](&t); // operator delete
printf("2 = \n");
ptr[2](&t);
printf("3 = \n");
@@ -88,7 +88,7 @@
printf("ptr[0] = %d, ptr[1]= %d, ptr[2] = %d ptr[3] = %d ptr[4] = %d ptr[5] = %d\n", ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5]);
ptr[0](&t);
printf("End\n");
- //ptr[1](&t); // This should be ~gc
+ //ptr[1](&t); // operator delete
ptr[2](&t);
ptr[3](&t);
ptr[4](&t);
More information about the vmkit-commits
mailing list