From nicolas.geoffray at lip6.fr Mon Dec 1 00:20:36 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 01 Dec 2008 08:20:36 -0000 Subject: [vmkit-commits] [vmkit] r60342 - in /vmkit/trunk: include/mvm/VirtualMachine.h lib/JnJVM/VMCore/JavaJIT.cpp lib/JnJVM/VMCore/JnjvmClassLoader.cpp Message-ID: <200812010820.mB18Ka1k013454@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 1 02:20:36 2008 New Revision: 60342 URL: http://llvm.org/viewvc/llvm-project?rev=60342&view=rev Log: Fix SERVICE build. Modified: vmkit/trunk/include/mvm/VirtualMachine.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Modified: vmkit/trunk/include/mvm/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=60342&r1=60341&r2=60342&view=diff ============================================================================== --- vmkit/trunk/include/mvm/VirtualMachine.h (original) +++ vmkit/trunk/include/mvm/VirtualMachine.h Mon Dec 1 02:20:36 2008 @@ -55,6 +55,8 @@ uint64_t gcTriggered; uint64_t executionTime; uint64_t numThreads; + CompilationUnit* CU; + void stopService(); #endif mvm::Allocator gcAllocator; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60342&r1=60341&r2=60342&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Dec 1 02:20:36 2008 @@ -1008,7 +1008,7 @@ module->constantFour, "", currentBlock); - Isolate = new LoadInst(IsolatePtr, "", currentBlock); + Isolate = new LoadInst(Isolate, "", currentBlock); Isolate = new BitCastInst(Isolate, module->ptrPtrType, "", currentBlock); Value* Status = GetElementPtrInst::Create(Isolate, module->constantOne, "", currentBlock); @@ -1025,6 +1025,7 @@ BranchInst::Create(endExceptionBlock, currentBlock); currentBlock = continueBlock; + } #endif Value* cmp = CallInst::Create(module->CompareExceptionFunction, cl, "", @@ -1057,7 +1058,6 @@ node->addIncoming(exc, cur->nativeHandler); } #if defined(SERVICE) - JnjvmClassLoader* loader = compilingClass->classLoader;; Value* threadId = 0; Value* OldIsolateID = 0; Value* IsolateIDPtr = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=60342&r1=60341&r2=60342&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Dec 1 02:20:36 2008 @@ -254,7 +254,7 @@ /// a new one each time a class loader is allocated. if (isolate->appClassLoader) { isolate = gc_new(Jnjvm)(bootstrapLoader); - + isolate->CU = this; mvm::Thread* th = mvm::Thread::get(); mvm::VirtualMachine* OldVM = th->MyVM; th->MyVM = isolate; From nicolas.geoffray at lip6.fr Mon Dec 1 01:02:49 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 01 Dec 2008 09:02:49 -0000 Subject: [vmkit-commits] [vmkit] r60345 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaString.cpp JavaString.h Jnjvm.cpp Message-ID: <200812010902.mB192nt1021284@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 1 03:02:47 2008 New Revision: 60345 URL: http://llvm.org/viewvc/llvm-project?rev=60345&view=rev Log: Create a new VT for vm-allocated Strings, so that these strings have a detructor. Strings allocated by the application do not have a destructor. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaString.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=60345&r1=60344&r2=60345&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Mon Dec 1 03:02:47 2008 @@ -17,10 +17,15 @@ using namespace jnjvm; +VirtualTable* JavaString::internStringVT = 0; JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) { UserClass* cl = vm->upcalls->newString; JavaString* res = (JavaString*)cl->doNew(vm); + + // It's a hashed string, set the destructor so that the string + // removes itself from the vm string map. + res->setVirtualTable(internStringVT); // No need to call the Java function: both the Java function and // this function do the same thing. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.h?rev=60345&r1=60344&r2=60345&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.h Mon Dec 1 03:02:47 2008 @@ -32,6 +32,8 @@ static void stringDestructor(JavaString*); char* strToAsciiz(); const UTF8* strToUTF8(Jnjvm* vm); + + static VirtualTable* internStringVT; }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60345&r1=60344&r2=60345&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Dec 1 03:02:47 2008 @@ -745,18 +745,24 @@ cl->initialiseClass(this); // If a string belongs to the vm hashmap, we must remove it when - // it's destroyed. So we change the destructor of java.lang.String - // to perform this action. - LOAD_CLASS(upcalls->newString); - uintptr_t* ptr = ((uintptr_t*)upcalls->newString->getVirtualVT()); - ptr[VT_DESTRUCTOR_OFFSET] = (uintptr_t)JavaString::stringDestructor; - + // it's destroyed. So we define a new VT for strings that will be + // placed in the hashmap. This VT will have its destructor set so + // that the string is removed when deallocated. + upcalls->newString->resolveClass(); + void* stringVT = ((void*)upcalls->newString->getVirtualVT()); + uint32 size = upcalls->newString->virtualTableSize * sizeof(void*); + JavaString::internStringVT = bootstrapLoader->allocator.Allocate(size); + memcpy(JavaString::internStringVT, stringVT, size); + ((void**)(JavaString::internStringVT))[VT_DESTRUCTOR_OFFSET] = + (void*)(uintptr_t)JavaString::stringDestructor; + upcalls->newString->initialiseClass(this); + // To make classes non GC-allocated, we have to bypass the tracer // functions of java.lang.Class, java.lang.reflect.Field, // java.lang.reflect.Method and java.lang.reflect.constructor. The new // tracer functions trace the classloader instead of the class/field/method. LOAD_CLASS(upcalls->newClass); - ptr = ((uintptr_t*)upcalls->newClass->getVirtualVT()); + uintptr_t* ptr = ((uintptr_t*)upcalls->newClass->getVirtualVT()); ptr[VT_TRACER_OFFSET] = (uintptr_t)JavaObjectClass::staticTracer; LOAD_CLASS(upcalls->newConstructor); From nicolas.geoffray at lip6.fr Mon Dec 1 01:47:33 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 01 Dec 2008 09:47:33 -0000 Subject: [vmkit-commits] [vmkit] r60346 - /vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Message-ID: <200812010947.mB19lXfA025965@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 1 03:47:31 2008 New Revision: 60346 URL: http://llvm.org/viewvc/llvm-project?rev=60346&view=rev Log: Fix include. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=60346&r1=60345&r2=60346&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Mon Dec 1 03:47:31 2008 @@ -8,7 +8,7 @@ // //===----------------------------------------------------------------------===// -#include +#include #include "mvm/JIT.h" #include "mvm/Threads/Thread.h" From nicolas.geoffray at lip6.fr Mon Dec 1 01:51:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 01 Dec 2008 09:51:29 -0000 Subject: [vmkit-commits] [vmkit] r60347 - /vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp Message-ID: <200812010951.mB19pT4W026159@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 1 03:51:29 2008 New Revision: 60347 URL: http://llvm.org/viewvc/llvm-project?rev=60347&view=rev Log: Fix includes. Modified: vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp Modified: vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp?rev=60347&r1=60346&r2=60347&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp Mon Dec 1 03:51:29 2008 @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// -#include -#include +#include +#include #include "mvm/GC/GC.h" #include "gccollector.h" From nicolas.geoffray at lip6.fr Mon Dec 1 04:30:07 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 01 Dec 2008 12:30:07 -0000 Subject: [vmkit-commits] [vmkit] r60350 - in /vmkit/trunk: include/mvm/VirtualMachine.h lib/JnJVM/VMCore/JavaThread.cpp lib/JnJVM/VMCore/JavaThread.h lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/Jnjvm.h lib/JnJVM/VMCore/JnjvmClassLoader.cpp lib/Mvm/GCMmap2/gccollector.h Message-ID: <200812011230.mB1CU8ch031245@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 1 06:30:05 2008 New Revision: 60350 URL: http://llvm.org/viewvc/llvm-project?rev=60350&view=rev Log: More fixes for SERVICE execution. Modified: vmkit/trunk/include/mvm/VirtualMachine.h vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h Modified: vmkit/trunk/include/mvm/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/include/mvm/VirtualMachine.h (original) +++ vmkit/trunk/include/mvm/VirtualMachine.h Mon Dec 1 06:30:05 2008 @@ -56,7 +56,10 @@ uint64_t executionTime; uint64_t numThreads; CompilationUnit* CU; - void stopService(); + virtual void stopService() {} + + uint64_t memoryLimit; + uint64_t executionLimit; #endif mvm::Allocator gcAllocator; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Mon Dec 1 06:30:05 2008 @@ -16,6 +16,7 @@ #include "JavaJIT.h" #include "JavaObject.h" #include "JavaThread.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" @@ -37,6 +38,11 @@ interruptFlag = 0; state = StateRunning; pendingException = 0; +#ifdef SERVICE + if (isolate->upcalls->newThrowable) { + ServiceException = isolate->upcalls->newThrowable->doNew(isolate); + } +#endif } JavaThread::~JavaThread() {} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Mon Dec 1 06:30:05 2008 @@ -105,6 +105,10 @@ print(buf); return buf->contents()->cString(); } + +#ifdef SERVICE + JavaObject* ServiceException; +#endif private: virtual void internalClearException() { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Dec 1 06:30:05 2008 @@ -751,10 +751,12 @@ upcalls->newString->resolveClass(); void* stringVT = ((void*)upcalls->newString->getVirtualVT()); uint32 size = upcalls->newString->virtualTableSize * sizeof(void*); - JavaString::internStringVT = bootstrapLoader->allocator.Allocate(size); - memcpy(JavaString::internStringVT, stringVT, size); - ((void**)(JavaString::internStringVT))[VT_DESTRUCTOR_OFFSET] = - (void*)(uintptr_t)JavaString::stringDestructor; + if (!JavaString::internStringVT) { + JavaString::internStringVT = bootstrapLoader->allocator.Allocate(size); + memcpy(JavaString::internStringVT, stringVT, size); + ((void**)(JavaString::internStringVT))[VT_DESTRUCTOR_OFFSET] = + (void*)(uintptr_t)JavaString::stringDestructor; + } upcalls->newString->initialiseClass(this); // To make classes non GC-allocated, we have to bypass the tracer @@ -888,6 +890,10 @@ vm->loadBootstrap(); +#ifdef SERVICE + thread->ServiceException = vm->upcalls->newThrowable->doNew(vm); +#endif + ClArgumentsInfo& info = vm->argumentsInfo; if (info.agents.size()) { @@ -920,7 +926,7 @@ #include -extern void terminationHandler(int, siginfo_t*, void*); +extern void terminationHandler(int); static void serviceCPUMonitor(mvm::Thread* th) { while (true) { @@ -944,16 +950,22 @@ argumentsInfo.argv = argumentsInfo.argv + pos - 1; argumentsInfo.argc = argumentsInfo.argc - pos + 1; - - bootstrapThread = new JavaThread(0, 0, this); - bootstrapThread->start((void (*)(mvm::Thread*))mainJavaStart); #ifdef SERVICE - mvm::Thread* th = new JavaThread(0, 0, this); - th->start(serviceCPUMonitor); struct sigaction sa; - sa.sa_sigaction = terminationHandler; + sigset_t mask; + sigfillset(&mask); + sigaction(SIGUSR1, 0, &sa); + sa.sa_mask = mask; + sa.sa_handler = terminationHandler; + sa.sa_flags |= SA_RESTART; sigaction(SIGUSR1, &sa, NULL); + + mvm::Thread* th = new JavaThread(0, 0, this); + th->start(serviceCPUMonitor); #endif + + bootstrapThread = new JavaThread(0, 0, this); + bootstrapThread->start((void (*)(mvm::Thread*))mainJavaStart); } else { threadSystem.nonDaemonThreads = 0; } @@ -986,6 +998,11 @@ IsolateLock.unlock(); #endif +#ifdef SERVICE + memoryLimit = ~0; + executionLimit = ~0; +#endif + } Jnjvm::~Jnjvm() { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Dec 1 06:30:05 2008 @@ -332,6 +332,10 @@ static mvm::LockNormal IsolateLock; #endif +#ifdef SERVICE + virtual void stopService(); +#endif + }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Dec 1 06:30:05 2008 @@ -254,6 +254,7 @@ /// a new one each time a class loader is allocated. if (isolate->appClassLoader) { isolate = gc_new(Jnjvm)(bootstrapLoader); + isolate->memoryLimit = 4000000; isolate->CU = this; mvm::Thread* th = mvm::Thread::get(); mvm::VirtualMachine* OldVM = th->MyVM; Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h?rev=60350&r1=60349&r2=60350&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h Mon Dec 1 06:30:05 2008 @@ -157,7 +157,19 @@ #endif collect_unprotect(); } - + +#ifdef SERVICE + if (threads->get_nb_threads()) { + VirtualMachine* vm = mvm::Thread::get()->MyVM; + if (vm->memoryUsed + n > vm->memoryLimit) { + fprintf(stderr, "Limite atteinte, tue le bundle\n"); + unlock(); + vm->stopService(); + return 0; + } + } +#endif + register GCChunkNode *header = allocator->alloc_chunk(n, 1, current_mark & 1); #ifdef SERVICE if (threads->get_nb_threads()) { From nicolas.geoffray at lip6.fr Mon Dec 1 04:35:18 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 01 Dec 2008 12:35:18 -0000 Subject: [vmkit-commits] [vmkit] r60351 - /vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Message-ID: <200812011235.mB1CZIM0031389@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 1 06:35:17 2008 New Revision: 60351 URL: http://llvm.org/viewvc/llvm-project?rev=60351&view=rev Log: Fix exceptions throw in static initializers: use JavaThread::throwException instead of the 'throw' keyword. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60351&r1=60350&r2=60351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Dec 1 06:35:17 2008 @@ -161,7 +161,7 @@ setOwnerClass(0); broadcastClass(); release(); - throw exc; + JavaThread::throwException(exc); } } @@ -251,7 +251,7 @@ setOwnerClass(0); broadcastClass(); release(); - throw exc; + JavaThread::throwException(exc); } } From nicolas.geoffray at lip6.fr Tue Dec 2 06:39:49 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 14:39:49 -0000 Subject: [vmkit-commits] [vmkit] r60410 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200812021439.mB2EdoHO027934@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 08:39:43 2008 New Revision: 60410 URL: http://llvm.org/viewvc/llvm-project?rev=60410&view=rev Log: Add type names to dynamically created llvm::Modules. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=60410&r1=60409&r2=60410&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 2 08:39:43 2008 @@ -1283,6 +1283,22 @@ #endif GetLockFunction = module->getFunction("getLock"); + + addTypeName("JavaObject", JavaObjectType); + addTypeName("JavaArray", JavaArrayType); + addTypeName("JavaCommonClass", JavaCommonClassType); + addTypeName("JavaClass", JavaClassType); + addTypeName("ArrayUInt8", JavaArrayUInt8Type); + addTypeName("ArraySInt8", JavaArraySInt8Type); + addTypeName("ArrayUInt16", JavaArrayUInt16Type); + addTypeName("ArraySInt16", JavaArraySInt16Type); + addTypeName("ArraySInt32", JavaArraySInt32Type); + addTypeName("ArrayLong", JavaArrayLongType); + addTypeName("ArrayFloat", JavaArrayFloatType); + addTypeName("ArrayDouble", JavaArrayDoubleType); + addTypeName("ArrayObject", JavaArrayObjectType); + addTypeName("CacheNode", CacheNodeType); + addTypeName("Enveloppe", EnveloppeType); } void LLVMAssessorInfo::initialise() { From nicolas.geoffray at lip6.fr Tue Dec 2 06:40:45 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 14:40:45 -0000 Subject: [vmkit-commits] [vmkit] r60411 - /vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Message-ID: <200812021440.mB2Eejtj027975@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 08:40:44 2008 New Revision: 60411 URL: http://llvm.org/viewvc/llvm-project?rev=60411&view=rev Log: Constant pool lookups are (fakely) readnone. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=60411&r1=60410&r2=60411&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Tue Dec 2 08:40:44 2008 @@ -23,19 +23,19 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; enveloppeLookup - Find the enveloppe for the current user class. -declare i8* @enveloppeLookup(%JavaClass*, i32, ...) +declare i8* @enveloppeLookup(%JavaClass*, i32, ...) readnone ;;; stringLookup - Find the isolate-specific string at the given offset in the ;;; constant pool. -declare i8* @stringLookup(%JavaClass*, i32, ...) +declare i8* @stringLookup(%JavaClass*, i32, ...) readnone ;;; staticCtpLookup - Find the user constant pool at the given offset in the ;;; constant pool. -declare i8* @staticCtpLookup(%JavaClass*, i32, ...) +declare i8* @staticCtpLookup(%JavaClass*, i32, ...) readnone ;;; specialCtpLookup - Find the user constant pool at the given offset in the ;;; constant pool. -declare i8** @specialCtpLookup(i8**, i32, i8**) +declare i8** @specialCtpLookup(i8**, i32, i8**) readnone ;;; getCtpCacheNode - Get the constant pool cache of a cache node. This is a ;;; constant call because the cache node never changes. From nicolas.geoffray at lip6.fr Tue Dec 2 06:43:57 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 14:43:57 -0000 Subject: [vmkit-commits] [vmkit] r60412 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Message-ID: <200812021443.mB2Ehwev028067@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 08:43:52 2008 New Revision: 60412 URL: http://llvm.org/viewvc/llvm-project?rev=60412&view=rev Log: Remove unknown characters. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60412&r1=60411&r2=60412&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 2 08:43:52 2008 @@ -678,7 +678,7 @@ new StoreInst(NewIsolate, IsolatePtr, currentBlock); #if DEBUG - Value* GEP[2] = { OldIsolate, NewIsolate }; + Value* GEP[2] = { OldIsolate, NewIsolate }; CallInst::Create(module->ServiceCallStartFunction, GEP, GEP + 2, "", currentBlock); #endif @@ -754,7 +754,7 @@ new StoreInst(OldIsolate, IsolatePtr, currentBlock); #if DEBUG - Value* GEP[2] = { OldIsolate, NewIsolate }; + Value* GEP[2] = { OldIsolate, NewIsolate }; CallInst::Create(module->ServiceCallStopFunction, GEP, GEP + 2, "", currentBlock); #endif From nicolas.geoffray at lip6.fr Tue Dec 2 08:09:59 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 16:09:59 -0000 Subject: [vmkit-commits] [vmkit] r60417 - in /vmkit/trunk/lib/JnJVM: LLVMRuntime/runtime-default.ll VMCore/JavaJIT.cpp VMCore/JavaRuntimeJIT.cpp VMCore/JnjvmModule.cpp VMCore/JnjvmModule.h VMCore/LowerConstantCalls.cpp Message-ID: <200812021610.mB2GA2lx030596@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 10:09:36 2008 New Revision: 60417 URL: http://llvm.org/viewvc/llvm-project?rev=60417&view=rev Log: Inline strings and java/lang/Class objects as much as possible. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp 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/LowerConstantCalls.cpp 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=60417&r1=60416&r2=60417&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Tue Dec 2 10:09:36 2008 @@ -150,9 +150,15 @@ declare i1 @instantiationOfArray(%JavaCommonClass*, %JavaCommonClass*) readnone ;;; getClassDelegatee - Returns the java/lang/Class representation of the -;;; class. +;;; class. This method is lowered to the GEP to the class delegatee in +;;; the common class. declare %JavaObject* @getClassDelegatee(%JavaCommonClass*) readnone +;;; jnjvmRuntimeDelegatee - Returns the java/lang/Class representation of the +;;; class. This method is called if the class delegatee has not been created +;;; yet. +declare %JavaObject* @jnjvmRuntimeDelegatee(%JavaCommonClass*) readnone + ;;; getArrayClass - Get the array user class of the user class. declare %JavaCommonClass* @getArrayClass(%JavaCommonClass*, %JavaCommonClass**) readnone Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60417&r1=60416&r2=60417&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 2 10:09:36 2008 @@ -1124,11 +1124,26 @@ uint8 type = ctpInfo->typeAt(index); if (type == JavaConstantPool::ConstantString) { -#if defined(ISOLATE) || defined(ISOLATE_SHARING) +#if defined(ISOLATE) + if (compilingClass->classLoader != + compilingClass->classLoader->bootstrapLoader) { + const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); + JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8); + + Value* val = module->getString(str, currentBlock); + push(val, false); + } else { + + // Lookup the constant pool cache + Value* val = getConstantPoolAt(index, module->StringLookupFunction, + module->JavaObjectType, 0, false); + push(val, false); + } +#elif defined(ISOLATE_SHARING) // Lookup the constant pool cache Value* val = getConstantPoolAt(index, module->StringLookupFunction, module->JavaObjectType, 0, false); - push(val, false); + push(val, false); #else const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=60417&r1=60416&r2=60417&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Dec 2 10:09:36 2008 @@ -314,7 +314,7 @@ return cl; } -extern "C" JavaObject* getClassDelegatee(UserCommonClass* cl) { +extern "C" JavaObject* jnjvmRuntimeDelegatee(UserCommonClass* cl) { Jnjvm* vm = JavaThread::get()->getJVM(); return cl->getClassDelegatee(vm); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=60417&r1=60416&r2=60417&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 2 10:09:36 2008 @@ -1210,6 +1210,7 @@ module->getFunction("getObjectSizeFromClass"); GetClassDelegateeFunction = module->getFunction("getClassDelegatee"); + RuntimeDelegateeFunction = module->getFunction("jnjvmRuntimeDelegatee"); InstanceOfFunction = module->getFunction("instanceOf"); IsAssignableFromFunction = module->getFunction("isAssignableFrom"); ImplementsFunction = module->getFunction("implements"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=60417&r1=60416&r2=60417&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Tue Dec 2 10:09:36 2008 @@ -314,6 +314,7 @@ #endif llvm::Function* GetClassDelegateeFunction; + llvm::Function* RuntimeDelegateeFunction; llvm::Function* ArrayLengthFunction; llvm::Function* GetVTFunction; llvm::Function* GetClassFunction; Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=60417&r1=60416&r2=60417&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Dec 2 10:09:36 2008 @@ -101,6 +101,45 @@ } #endif +#ifdef ISOLATE +static Value* getDelegatee(JnjvmModule* module, Value* Arg, Instruction* CI) { + Value* GEP[2] = { module->constantZero, + module->constantTwo }; + Value* TCMArray = GetElementPtrInst::Create(Arg, GEP, GEP + 2, "", CI); + + Value* threadId = CallInst::Create(module->llvm_frameaddress, + module->constantZero, "", CI); + threadId = new PtrToIntInst(threadId, module->pointerSizeType, "", CI); + threadId = BinaryOperator::CreateAnd(threadId, module->constantThreadIDMask, + "", CI); + + threadId = new IntToPtrInst(threadId, module->ptr32Type, "", CI); + + Value* IsolateID = GetElementPtrInst::Create(threadId, module->constantThree, + "", CI); + IsolateID = new LoadInst(IsolateID, "", CI); + + Value* GEP2[2] = { module->constantZero, IsolateID }; + + Value* TCM = GetElementPtrInst::Create(TCMArray, GEP2, GEP2 + 2, "", + CI); + return new LoadInst(TCM, "", CI); +} +#else +static Value* getDelegatee(JnjvmModule* module, Value* Arg, Instruction* CI) { + Value* GEP[2] = { module->constantZero, + module->constantTwo }; + Value* TCMArray = GetElementPtrInst::Create(Arg, GEP, GEP + 2, "", CI); + + Value* GEP2[2] = { module->constantZero, module->constantZero }; + + Value* TCM = GetElementPtrInst::Create(TCMArray, GEP2, GEP2 + 2, "", + CI); + return new LoadInst(TCM, "", CI); + +} +#endif + bool LowerConstantCalls::runOnFunction(Function& F) { JnjvmModule* module = (JnjvmModule*)F.getParent(); bool Changed = false; @@ -324,6 +363,29 @@ #else abort(); #endif + } else if (V == module->GetClassDelegateeFunction) { + Changed = true; + BasicBlock* NBB = II->getParent()->splitBasicBlock(II); + I->getParent()->getTerminator()->eraseFromParent(); + Value* Del = getDelegatee(module, Call.getArgument(0), CI); + Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, Del, + module->JavaObjectNullConstant, "", CI); + + BasicBlock* NoDelegatee = BasicBlock::Create("No delegatee", &F); + BasicBlock* DelegateeOK = BasicBlock::Create("Delegatee OK", &F); + BranchInst::Create(NoDelegatee, DelegateeOK, cmp, CI); + PHINode* phi = PHINode::Create(module->JavaObjectType, "", DelegateeOK); + phi->addIncoming(Del, CI->getParent()); + + Value* Res = CallInst::Create(module->RuntimeDelegateeFunction, + Call.getArgument(0), "", NoDelegatee); + BranchInst::Create(DelegateeOK, NoDelegatee); + phi->addIncoming(Res, NoDelegatee); + + CI->replaceAllUsesWith(phi); + CI->eraseFromParent(); + BranchInst::Create(NBB, DelegateeOK); + break; } else if (V == module->InitialisationCheckFunction) { Changed = true; From nicolas.geoffray at lip6.fr Tue Dec 2 08:30:03 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 16:30:03 -0000 Subject: [vmkit-commits] [vmkit] r60419 - /vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Message-ID: <200812021630.mB2GU5Va031525@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 10:29:46 2008 New Revision: 60419 URL: http://llvm.org/viewvc/llvm-project?rev=60419&view=rev Log: Update the equivalent command line of std-compile-opts. Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=60419&r1=60418&r2=60419&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Tue Dec 2 10:29:46 2008 @@ -339,10 +339,11 @@ } // This is equivalent to: -// opt -simplifycfg -mem2reg -instcombine -jump-threading -scalarrepl -// -instcombine -condprop -simplifycfg -reassociate -licm essai.bc -// -loop-unswitch -indvars -loop-unroll -instcombine -gvn -sccp -// -simplifycfg -instcombine -condprop -dse -adce -simplifycfg +// opt -simplifycfg -mem2reg -instcombine -jump-threading -simplifycfg +// -scalarrepl -instcombine -condprop -simplifycfg -predsimplify +// -reassociate -licm -loop-unswitch -indvars -loop-deletion -loop-unroll +// -instcombine -gvn -sccp -simplifycfg -instcombine -condprop -dse -adce +// -simplifycfg // void CompilationUnit::AddStandardCompilePasses() { // TODO: enable this when From nicolas.geoffray at lip6.fr Tue Dec 2 09:10:34 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 17:10:34 -0000 Subject: [vmkit-commits] [vmkit] r60424 - /vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp Message-ID: <200812021710.mB2HAYY9000404@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 11:10:33 2008 New Revision: 60424 URL: http://llvm.org/viewvc/llvm-project?rev=60424&view=rev Log: New file, bundle termination, only used in a SERVICE environment. Added: vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp Added: vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp?rev=60424&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp (added) +++ vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp Tue Dec 2 11:10:33 2008 @@ -0,0 +1,160 @@ +#ifdef SERVICE + +#include "llvm/ExecutionEngine/ExecutionEngine.h" +#include "llvm/Target/TargetJITInfo.h" + +#include "../lib/ExecutionEngine/JIT/JIT.h" + +#include "JavaThread.h" +#include "JavaJIT.h" +#include "Jnjvm.h" +#include "mvm/VirtualMachine.h" +#include "mvm/Threads/Cond.h" +#include "mvm/Threads/Locks.h" +#include "mvm/JIT.h" + +#include "signal.h" + +#include "execinfo.h" + +using namespace jnjvm; + +static void* StackTrace[256]; + +// PrintStackTrace - In the case of a program crash or fault, print out a stack +// trace so that the user has an indication of why and where we died. +// +// On glibc systems we have the 'backtrace' function, which works nicely, but +// doesn't demangle symbols. +static void PrintStackTrace() { + // Use backtrace() to output a backtrace on Linux systems with glibc. + int depth = backtrace(StackTrace, 256); + backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO); +} + + + +static void throwStoppedBundleException() { + void** addr = (void**)__builtin_frame_address(0); + fprintf(stderr, "in stopped %p\n", addr); + JavaJIT::printBacktrace(); + PrintStackTrace(); + fprintf(stderr, "OK\n"); + JavaThread* th = JavaThread::get(); + th->throwException(th->ServiceException); +} + + +static JnjvmClassLoader* stoppedBundle; +static mvm::LockNormal lock; +static mvm::Cond cond; +static mvm::Thread* initiator; + + +#if defined(__MACH__) && !defined(__i386__) +#define FRAME_IP(fp) (fp[2]) +#else +#define FRAME_IP(fp) (fp[1]) +#endif + + +void terminationHandler(int) { + void** addr = (void**)__builtin_frame_address(0); + void* baseSP = mvm::Thread::get()->baseSP; + while (addr && addr < baseSP && addr < addr[0]) { + addr = (void**)addr[0]; + void** ptr = (void**)FRAME_IP(addr); + JavaMethod* meth = JavaJIT::IPToJavaMethod(ptr); + if (meth) { + if (meth->classDef->classLoader == stoppedBundle) { + fprintf(stderr, "Je change %p!\n", FRAME_IP(addr)); + JavaJIT::printBacktrace(); + FRAME_IP(addr) = (void**)(uintptr_t)throwStoppedBundleException; + } + } + } + + addr = (void**)__builtin_frame_address(0); + while (addr && addr < baseSP && addr < addr[0]) { + addr = (void**)addr[0]; + void** ptr = (void**)FRAME_IP(addr); + JavaMethod* meth = JavaJIT::IPToJavaMethod(ptr); + if (meth) { + if (meth->classDef->classLoader != stoppedBundle) { + JavaThread* th = JavaThread::get(); + th->lock.lock(); + th->interruptFlag = 1; + + // here we could also raise a signal for interrupting I/O + if (th->state == JavaThread::StateWaiting) { + th->state = JavaThread::StateInterrupted; + th->varcond.signal(); + } + + th->lock.unlock(); + + } + break; + } + } + + if (mvm::Thread::get() != initiator) { + lock.lock(); + while (stoppedBundle) + cond.wait(&lock); + lock.unlock(); + } else { + fprintf(stderr, "Je suis l'initiateur, je quitte\n"); + } +} + + + +void Jnjvm::stopService() { + + JnjvmClassLoader* bundle = (JnjvmClassLoader*)CU; + bundle->getIsolate()->status = 1; + stoppedBundle = bundle; + mvm::Thread* th = mvm::Thread::get(); + th->MyVM->memoryLimit = ~0; + initiator = th; + fprintf(stderr, "I am %p\n", th); + for(mvm::Thread* cur = (mvm::Thread*)th->next(); cur != th; + cur = (mvm::Thread*)cur->next()) { + mvm::VirtualMachine* executingVM = cur->MyVM; + assert(executingVM && "Thread with no VM!"); + fprintf(stderr, "Killing th %p\n", cur); + uint32 res = cur->kill(SIGUSR1); + assert(res == 0); + + } + + fprintf(stderr, "Doing it\n"); + // I have to do it too! + terminationHandler(0); + fprintf(stderr, "OK! bon ben moi je m'en vais\n"); + /* + llvm::TargetJITInfo& TJI = ((llvm::JIT*)mvm::MvmModule::executionEngine)->getJITInfo(); + for (ClassMap::iterator i = bundle->getClasses()->map.begin(), e = bundle->getClasses()->map.end(); + i!= e; ++i) { + Class* cl = i->second->asClass(); + + if (cl) { + for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) { + if (cl->virtualMethods[i].code) { + TJI.replaceMachineCodeForFunction(cl->virtualMethods[i].code, (void*)(uintptr_t)throwStoppedBundleException); + } + } + + for (uint32 i = 0; i < cl->nbStaticMethods; ++i) { + if (cl->staticMethods[i].code) { + TJI.replaceMachineCodeForFunction(cl->staticMethods[i].code, (void*)(uintptr_t)throwStoppedBundleException); + } + } + } + } + stoppedBundle = 0; + cond.broadcast();*/ +} + +#endif From nicolas.geoffray at lip6.fr Tue Dec 2 15:32:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 02 Dec 2008 23:32:26 -0000 Subject: [vmkit-commits] [vmkit] r60445 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200812022332.mB2NWQNR013364@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 2 17:32:25 2008 New Revision: 60445 URL: http://llvm.org/viewvc/llvm-project?rev=60445&view=rev Log: Remove the loaded value if it is not needed, in GetStaticInstance. Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=60445&r1=60444&r2=60445&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Dec 2 17:32:25 2008 @@ -347,10 +347,14 @@ ConstantInt* C = (ConstantInt*)CE->getOperand(0); Class* cl = (Class*)C->getZExtValue(); - + + Instruction* R = dyn_cast(Call.getArgument(0)); Value* Replace = module->getStaticInstance(cl, CI); CI->replaceAllUsesWith(Replace); CI->eraseFromParent(); + + if (R && !R->getNumUses()) R->eraseFromParent(); + #elif defined(ISOLATE) Value* TCM = getTCM(module, Call.getArgument(0), CI); From nicolas.geoffray at lip6.fr Wed Dec 3 04:16:58 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 03 Dec 2008 12:16:58 -0000 Subject: [vmkit-commits] [vmkit] r60481 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200812031216.mB3CGx2M013635@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 3 06:16:52 2008 New Revision: 60481 URL: http://llvm.org/viewvc/llvm-project?rev=60481&view=rev Log: Remove null checks of the "this" parameter. Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=60481&r1=60480&r2=60481&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Wed Dec 3 06:16:52 2008 @@ -142,12 +142,25 @@ bool LowerConstantCalls::runOnFunction(Function& F) { JnjvmModule* module = (JnjvmModule*)F.getParent(); + JavaMethod* meth = LLVMMethodInfo::get(&F); bool Changed = false; for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; BI++) { BasicBlock *Cur = BI; for (BasicBlock::iterator II = Cur->begin(), IE = Cur->end(); II != IE;) { Instruction *I = II; II++; + + if (ICmpInst* Cmp = dyn_cast(I)) { + if (isVirtual(meth->access)) { + if (Cmp->getOperand(1) == module->JavaObjectNullConstant && + Cmp->getOperand(0) == F.arg_begin()) { + Cmp->replaceAllUsesWith(ConstantInt::getFalse()); + Cmp->eraseFromParent(); + continue; + } + } + } + CallSite Call = CallSite::get(I); Instruction* CI = Call.getInstruction(); if (CI) { From nicolas.geoffray at lip6.fr Thu Dec 4 05:36:01 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 04 Dec 2008 13:36:01 -0000 Subject: [vmkit-commits] [vmkit] r60536 - /vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp Message-ID: <200812041336.mB4Da1B8005710@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 4 07:35:59 2008 New Revision: 60536 URL: http://llvm.org/viewvc/llvm-project?rev=60536&view=rev Log: don't allocate objects of more than a page size on stack. Modified: vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp Modified: vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp?rev=60536&r1=60535&r2=60536&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp Thu Dec 4 07:35:59 2008 @@ -16,6 +16,7 @@ #include "llvm/Support/Debug.h" #include +#include "unistd.h" #include "mvm/GC/GC.h" @@ -26,9 +27,11 @@ class VISIBILITY_HIDDEN EscapeAnalysis : public FunctionPass { public: static char ID; + uint64_t pageSize; EscapeAnalysis(Function* alloc = 0) : FunctionPass((intptr_t)&ID) { Allocator = alloc; + pageSize = getpagesize(); } virtual bool runOnFunction(Function &F); @@ -112,10 +115,12 @@ if (CE) { ConstantInt* C = (ConstantInt*)CE->getOperand(0); VirtualTable* Table = (VirtualTable*)C->getZExtValue(); + ConstantInt* CI = dyn_cast(Size); // If the class has a finalize method, do not stack allocate the object. - if (!((void**)Table)[0]) { + if (!((void**)Table)[0] && CI) { std::map visited; - if (!(escapes(Alloc, visited))) { + uint64_t NSize = CI->getZExtValue(); + if (NSize < pageSize && !(escapes(Alloc, visited))) { AllocaInst* AI = new AllocaInst(Type::Int8Ty, Size, "", Alloc); BitCastInst* BI = new BitCastInst(AI, Alloc->getType(), "", Alloc); DOUT << "escape" << Alloc->getParent()->getParent()->getName() << "\n"; From nicolas.geoffray at lip6.fr Thu Dec 4 06:22:46 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 04 Dec 2008 14:22:46 -0000 Subject: [vmkit-commits] [vmkit] r60537 - /vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h Message-ID: <200812041422.mB4EMkYc007331@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 4 08:22:41 2008 New Revision: 60537 URL: http://llvm.org/viewvc/llvm-project?rev=60537&view=rev Log: [SERVICE] Also look at a v limit in realloc. Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h?rev=60537&r1=60536&r2=60537&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h Thu Dec 4 08:22:41 2008 @@ -162,7 +162,7 @@ if (threads->get_nb_threads()) { VirtualMachine* vm = mvm::Thread::get()->MyVM; if (vm->memoryUsed + n > vm->memoryLimit) { - fprintf(stderr, "Limite atteinte, tue le bundle\n"); + _since_last_collection += n; unlock(); vm->stopService(); return 0; @@ -216,6 +216,18 @@ collect_unprotect(); } +#ifdef SERVICE + if (threads->get_nb_threads()) { + VirtualMachine* vm = mvm::Thread::get()->MyVM; + if (vm->memoryUsed + (n - old_sz) > vm->memoryLimit) { + _since_last_collection += (n - old_sz); + unlock(); + vm->stopService(); + return 0; + } + } +#endif + GCChunkNode *res = allocator->realloc_chunk(desc, node, n); #ifdef SERVICE From nicolas.geoffray at lip6.fr Thu Dec 4 06:29:27 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 04 Dec 2008 14:29:27 -0000 Subject: [vmkit-commits] [vmkit] r60538 - /vmkit/trunk/include/mvm/Threads/Thread.h Message-ID: <200812041429.mB4ETRsY007552@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 4 08:29:27 2008 New Revision: 60538 URL: http://llvm.org/viewvc/llvm-project?rev=60538&view=rev Log: [SERVICE] Add a stopping service field to the thread, so that it knows which service is being killed when signaled. Modified: vmkit/trunk/include/mvm/Threads/Thread.h Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=60538&r1=60537&r2=60538&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Thu Dec 4 08:29:27 2008 @@ -123,6 +123,8 @@ public: virtual ~Thread() {} + virtual void TRACER {} + /// clearException - Clear any pending exception of the current thread. static void clearException() { @@ -135,7 +137,11 @@ void* operator new(size_t sz); void (*routine)(mvm::Thread*); - + +#ifdef SERVICE + VirtualMachine* stoppingService; +#endif + }; From nicolas.geoffray at lip6.fr Thu Dec 4 06:30:56 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 04 Dec 2008 14:30:56 -0000 Subject: [vmkit-commits] [vmkit] r60539 - in /vmkit/trunk/lib/JnJVM/VMCore: BundleTermination.cpp JavaClass.cpp JavaThread.cpp JavaThread.h Jnjvm.cpp Jnjvm.h JnjvmClassLoader.cpp VirtualTables.cpp Message-ID: <200812041430.mB4EUvX8007607@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 4 08:30:56 2008 New Revision: 60539 URL: http://llvm.org/viewvc/llvm-project?rev=60539&view=rev Log: [SERVICE] Better support for service termination. Modified: vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp Thu Dec 4 08:30:56 2008 @@ -15,125 +15,108 @@ #include "signal.h" -#include "execinfo.h" - using namespace jnjvm; -static void* StackTrace[256]; +#if defined(__MACH__) && !defined(__i386__) +#define FRAME_IP(fp) (fp[2]) +#else +#define FRAME_IP(fp) (fp[1]) +#endif -// PrintStackTrace - In the case of a program crash or fault, print out a stack -// trace so that the user has an indication of why and where we died. -// -// On glibc systems we have the 'backtrace' function, which works nicely, but -// doesn't demangle symbols. -static void PrintStackTrace() { - // Use backtrace() to output a backtrace on Linux systems with glibc. - int depth = backtrace(StackTrace, 256); - backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO); -} +static void throwInlineStoppedBundleException() { + void** addr = (void**)__builtin_frame_address(0); + JavaThread* th = JavaThread::get(); + FRAME_IP(addr) = (void**)th->replacedEIPs[--th->eipIndex]; + th->throwException(th->ServiceException); +} static void throwStoppedBundleException() { - void** addr = (void**)__builtin_frame_address(0); - fprintf(stderr, "in stopped %p\n", addr); - JavaJIT::printBacktrace(); - PrintStackTrace(); - fprintf(stderr, "OK\n"); JavaThread* th = JavaThread::get(); th->throwException(th->ServiceException); } -static JnjvmClassLoader* stoppedBundle; static mvm::LockNormal lock; static mvm::Cond cond; -static mvm::Thread* initiator; - - -#if defined(__MACH__) && !defined(__i386__) -#define FRAME_IP(fp) (fp[2]) -#else -#define FRAME_IP(fp) (fp[1]) -#endif - +static mvm::Thread* initiator = 0; +static bool Finished = true; void terminationHandler(int) { void** addr = (void**)__builtin_frame_address(0); - void* baseSP = mvm::Thread::get()->baseSP; + mvm::Thread* th = mvm::Thread::get(); + JnjvmClassLoader* stoppedBundle = + (JnjvmClassLoader*)(th->stoppingService->CU); + void* baseSP = th->baseSP; + bool inStack = false; while (addr && addr < baseSP && addr < addr[0]) { addr = (void**)addr[0]; void** ptr = (void**)FRAME_IP(addr); JavaMethod* meth = JavaJIT::IPToJavaMethod(ptr); if (meth) { if (meth->classDef->classLoader == stoppedBundle) { - fprintf(stderr, "Je change %p!\n", FRAME_IP(addr)); - JavaJIT::printBacktrace(); - FRAME_IP(addr) = (void**)(uintptr_t)throwStoppedBundleException; + inStack = true; + JavaThread* th = JavaThread::get(); + th->replacedEIPs[th->eipIndex++] = FRAME_IP(addr); + FRAME_IP(addr) = (void**)(uintptr_t)throwInlineStoppedBundleException; } } } - - addr = (void**)__builtin_frame_address(0); - while (addr && addr < baseSP && addr < addr[0]) { - addr = (void**)addr[0]; - void** ptr = (void**)FRAME_IP(addr); - JavaMethod* meth = JavaJIT::IPToJavaMethod(ptr); - if (meth) { - if (meth->classDef->classLoader != stoppedBundle) { - JavaThread* th = JavaThread::get(); - th->lock.lock(); - th->interruptFlag = 1; - // here we could also raise a signal for interrupting I/O - if (th->state == JavaThread::StateWaiting) { - th->state = JavaThread::StateInterrupted; - th->varcond.signal(); - } + // If the malicious bundle is in the stack, interrupt the thread. + if (inStack) { + JavaThread* th = JavaThread::get(); + th->lock.lock(); + th->interruptFlag = 1; + + // here we could also raise a signal for interrupting I/O + if (th->state == JavaThread::StateWaiting) { + th->state = JavaThread::StateInterrupted; + th->varcond.signal(); + } - th->lock.unlock(); + th->lock.unlock(); - } - break; - } } if (mvm::Thread::get() != initiator) { lock.lock(); - while (stoppedBundle) + while (!Finished) cond.wait(&lock); lock.unlock(); - } else { - fprintf(stderr, "Je suis l'initiateur, je quitte\n"); } } void Jnjvm::stopService() { - + + lock.lock(); + while (!Finished) + cond.wait(&lock); + + Finished = false; + lock.unlock(); + JnjvmClassLoader* bundle = (JnjvmClassLoader*)CU; bundle->getIsolate()->status = 1; - stoppedBundle = bundle; mvm::Thread* th = mvm::Thread::get(); - th->MyVM->memoryLimit = ~0; + th->stoppingService = this; initiator = th; - fprintf(stderr, "I am %p\n", th); for(mvm::Thread* cur = (mvm::Thread*)th->next(); cur != th; cur = (mvm::Thread*)cur->next()) { mvm::VirtualMachine* executingVM = cur->MyVM; assert(executingVM && "Thread with no VM!"); - fprintf(stderr, "Killing th %p\n", cur); + cur->stoppingService = this; uint32 res = cur->kill(SIGUSR1); assert(res == 0); } - fprintf(stderr, "Doing it\n"); // I have to do it too! terminationHandler(0); - fprintf(stderr, "OK! bon ben moi je m'en vais\n"); - /* + llvm::TargetJITInfo& TJI = ((llvm::JIT*)mvm::MvmModule::executionEngine)->getJITInfo(); for (ClassMap::iterator i = bundle->getClasses()->map.begin(), e = bundle->getClasses()->map.end(); i!= e; ++i) { @@ -153,8 +136,11 @@ } } } - stoppedBundle = 0; - cond.broadcast();*/ + + lock.lock(); + Finished = true; + cond.broadcast(); + lock.unlock(); } #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Thu Dec 4 08:30:56 2008 @@ -357,6 +357,13 @@ void* JavaMethod::compiledPtr() { if (code != 0) return code; else { +#ifdef SERVICE + Jnjvm *vm = classDef->classLoader->getIsolate(); + if (vm && vm->status == 0) { + JavaThread* th = JavaThread::get(); + th->throwException(th->ServiceException); + } +#endif classDef->acquire(); if (code == 0) { code = Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Thu Dec 4 08:30:56 2008 @@ -39,13 +39,19 @@ state = StateRunning; pendingException = 0; #ifdef SERVICE + eipIndex = 0; + replacedEIPs = new void*[100]; if (isolate->upcalls->newThrowable) { ServiceException = isolate->upcalls->newThrowable->doNew(isolate); } #endif } -JavaThread::~JavaThread() {} +JavaThread::~JavaThread() { +#ifdef SERVICE + delete replacedEIPs; +#endif +} // We define these here because gcc compiles the 'throw' keyword // differently, whether these are defined in a file or not. Since many Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Thu Dec 4 08:30:56 2008 @@ -44,7 +44,11 @@ void print(mvm::PrintBuffer *buf) const; virtual void TRACER; - JavaThread() {} + JavaThread() { +#ifdef SERVICE + replacedEIPs = 0; +#endif + } ~JavaThread(); JavaThread(JavaObject* thread, JavaObject* vmThread, Jnjvm* isolate); @@ -108,7 +112,13 @@ #ifdef SERVICE JavaObject* ServiceException; + void** replacedEIPs; + uint32_t eipIndex; #endif + + static bool isJavaThread(mvm::Thread* th) { + return ((void**)th)[0] == VT; + } private: virtual void internalClearException() { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Dec 4 08:30:56 2008 @@ -933,9 +933,14 @@ sleep(1); for(mvm::Thread* cur = (mvm::Thread*)th->next(); cur != th; cur = (mvm::Thread*)cur->next()) { - mvm::VirtualMachine* executingVM = cur->MyVM; - assert(executingVM && "Thread with no VM!"); - ++executingVM->executionTime; + if (JavaThread::isJavaThread(cur)) { + JavaThread* th = (JavaThread*)cur; + if (!(th->StateWaiting)) { + mvm::VirtualMachine* executingVM = cur->MyVM; + assert(executingVM && "Thread with no VM!"); + ++executingVM->executionTime; + } + } } } } @@ -1001,6 +1006,8 @@ #ifdef SERVICE memoryLimit = ~0; executionLimit = ~0; + parent = this; + status = 1; #endif } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Dec 4 08:30:56 2008 @@ -334,6 +334,8 @@ #ifdef SERVICE virtual void stopService(); + Jnjvm* parent; + uint32 status; #endif }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Dec 4 08:30:56 2008 @@ -255,6 +255,7 @@ if (isolate->appClassLoader) { isolate = gc_new(Jnjvm)(bootstrapLoader); isolate->memoryLimit = 4000000; + isolate->parent = I->parent; isolate->CU = this; mvm::Thread* th = mvm::Thread::get(); mvm::VirtualMachine* OldVM = th->MyVM; Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=60539&r1=60538&r2=60539&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Thu Dec 4 08:30:56 2008 @@ -114,6 +114,9 @@ void JavaThread::TRACER { javaThread->MARK_AND_TRACE; if (pendingException) pendingException->MARK_AND_TRACE; +#ifdef SERVICE + ServiceException->MARK_AND_TRACE; +#endif } void Jnjvm::TRACER { @@ -141,12 +144,16 @@ TRACE_VECTOR(JavaString*, gc_allocator, bootstrapLoader->strings); - if (bootstrapThread) { - bootstrapThread->CALL_TRACER; - for (JavaThread* th = (JavaThread*)bootstrapThread->next(); - th != bootstrapThread; th = (JavaThread*)th->next()) - th->CALL_TRACER; + mvm::Thread* th = th->get(); + th->CALL_TRACER; + for (mvm::Thread* cur = (mvm::Thread*)th->next(); cur != th; + cur = (mvm::Thread*)cur->next()) { + cur->CALL_TRACER; } + +#ifdef SERVICE + parent->MARK_AND_TRACE; +#endif } void JnjvmClassLoader::TRACER { From nicolas.geoffray at lip6.fr Thu Dec 4 16:02:42 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 05 Dec 2008 00:02:42 -0000 Subject: [vmkit-commits] [vmkit] r60567 - in /vmkit/trunk: include/mvm/VirtualMachine.h lib/JnJVM/VMCore/BundleTermination.cpp lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/Jnjvm.h lib/Mvm/GCMmap2/gccollector.cpp lib/Mvm/GCMmap2/gccollector.h lib/Mvm/GCMmap2/gcthread.h Message-ID: <200812050002.mB502hNt026478@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 4 18:02:42 2008 New Revision: 60567 URL: http://llvm.org/viewvc/llvm-project?rev=60567&view=rev Log: [SERVICE] Better support for resource policies. Modified: vmkit/trunk/include/mvm/VirtualMachine.h vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h vmkit/trunk/lib/Mvm/GCMmap2/gcthread.h Modified: vmkit/trunk/include/mvm/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/include/mvm/VirtualMachine.h (original) +++ vmkit/trunk/include/mvm/VirtualMachine.h Thu Dec 4 18:02:42 2008 @@ -26,6 +26,19 @@ /// defines what a VM should be. /// class VirtualMachine : public mvm::Object { +protected: + + VirtualMachine() { +#ifdef SERVICE + memoryLimit = ~0; + executionLimit = ~0; + GCLimit = ~0; + threadLimit = ~0; + parent = this; + status = 1; + _since_last_collection = 4*1024*1024; +#endif + } public: /// runApplication - Run an application. The application name is in @@ -50,7 +63,6 @@ #endif #ifdef SERVICE - size_t status; uint64_t memoryUsed; uint64_t gcTriggered; uint64_t executionTime; @@ -60,6 +72,12 @@ uint64_t memoryLimit; uint64_t executionLimit; + uint64_t threadLimit; + uint64_t GCLimit; + + int _since_last_collection; + VirtualMachine* parent; + uint32 status; #endif mvm::Allocator gcAllocator; Modified: vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/BundleTermination.cpp Thu Dec 4 18:02:42 2008 @@ -117,21 +117,24 @@ // I have to do it too! terminationHandler(0); - llvm::TargetJITInfo& TJI = ((llvm::JIT*)mvm::MvmModule::executionEngine)->getJITInfo(); - for (ClassMap::iterator i = bundle->getClasses()->map.begin(), e = bundle->getClasses()->map.end(); - i!= e; ++i) { + llvm::TargetJITInfo& TJI = + ((llvm::JIT*)mvm::MvmModule::executionEngine)->getJITInfo(); + for (ClassMap::iterator i = bundle->getClasses()->map.begin(), + e = bundle->getClasses()->map.end(); i!= e; ++i) { Class* cl = i->second->asClass(); if (cl) { for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) { if (cl->virtualMethods[i].code) { - TJI.replaceMachineCodeForFunction(cl->virtualMethods[i].code, (void*)(uintptr_t)throwStoppedBundleException); + TJI.replaceMachineCodeForFunction(cl->virtualMethods[i].code, + (void*)(uintptr_t)throwStoppedBundleException); } } for (uint32 i = 0; i < cl->nbStaticMethods; ++i) { if (cl->staticMethods[i].code) { - TJI.replaceMachineCodeForFunction(cl->staticMethods[i].code, (void*)(uintptr_t)throwStoppedBundleException); + TJI.replaceMachineCodeForFunction(cl->staticMethods[i].code, + (void*)(uintptr_t)throwStoppedBundleException); } } } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Dec 4 18:02:42 2008 @@ -976,7 +976,7 @@ } } -Jnjvm::Jnjvm(JnjvmBootstrapLoader* loader) { +Jnjvm::Jnjvm(JnjvmBootstrapLoader* loader) : VirtualMachine() { classpath = getenv("CLASSPATH"); if (!classpath) classpath = "."; @@ -1003,13 +1003,6 @@ IsolateLock.unlock(); #endif -#ifdef SERVICE - memoryLimit = ~0; - executionLimit = ~0; - parent = this; - status = 1; -#endif - } Jnjvm::~Jnjvm() { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Dec 4 18:02:42 2008 @@ -334,8 +334,6 @@ #ifdef SERVICE virtual void stopService(); - Jnjvm* parent; - uint32 status; #endif }; Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp Thu Dec 4 18:02:42 2008 @@ -39,7 +39,11 @@ void GCCollector::do_collect() { //printf("----- do collect -----\n"); GCChunkNode *cur; +#ifdef SERVICE + mvm::Thread::get()->MyVM->_since_last_collection = _collect_freq_auto; +#else _since_last_collection = _collect_freq_auto; +#endif current_mark++; Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gccollector.h Thu Dec 4 18:02:42 2008 @@ -135,7 +135,12 @@ static inline void maybeCollect() { if(_enable_auto && - (_since_last_collection <= (_collect_freq_auto - _collect_freq_maybe))) +#ifdef SERVICE + (mvm::Thread::get()->MyVM->_since_last_collection <= (_collect_freq_auto - _collect_freq_maybe)) +#else + (_since_last_collection <= (_collect_freq_auto - _collect_freq_maybe)) +#endif + ) collect(); } @@ -147,30 +152,40 @@ return res; #else lock(); - - _since_last_collection -= n; - if(_enable_auto && (_since_last_collection <= 0)) { -#ifdef SERVICE - if (threads->get_nb_threads()) { - mvm::Thread::get()->MyVM->gcTriggered++; - } -#endif - collect_unprotect(); - } - + #ifdef SERVICE if (threads->get_nb_threads()) { VirtualMachine* vm = mvm::Thread::get()->MyVM; + vm->_since_last_collection -= n; + if (_enable_auto && (vm->_since_last_collection <= 0)) { + vm->gcTriggered++; + if (vm->gcTriggered > vm->GCLimit) { + vm->_since_last_collection += n; + unlock(); + vm->stopService(); + return 0; + } + collect_unprotect(); + } + if (vm->memoryUsed + n > vm->memoryLimit) { - _since_last_collection += n; + vm->_since_last_collection += n; unlock(); vm->stopService(); return 0; } + } else { +#endif + + _since_last_collection -= n; + if(_enable_auto && (_since_last_collection <= 0)) { + collect_unprotect(); + } +#ifdef SERVICE } #endif - register GCChunkNode *header = allocator->alloc_chunk(n, 1, current_mark & 1); + #ifdef SERVICE if (threads->get_nb_threads()) { VirtualMachine* vm = mvm::Thread::get()->MyVM; @@ -204,27 +219,36 @@ gcfatal("%p isn't a avalid object", ptr); size_t old_sz = node->nbb(); - - _since_last_collection -= (n - old_sz); - - if(_enable_auto && (_since_last_collection <= 0)) { -#ifdef SERVICE - if (threads->get_nb_threads()) { - mvm::Thread::get()->MyVM->gcTriggered++; - } -#endif - collect_unprotect(); - } - #ifdef SERVICE if (threads->get_nb_threads()) { VirtualMachine* vm = mvm::Thread::get()->MyVM; + vm->_since_last_collection -= (n - old_sz); + if (_enable_auto && (vm->_since_last_collection <= 0)) { + if (vm->gcTriggered + 1 > vm->GCLimit) { + unlock(); + vm->stopService(); + return 0; + } + vm->gcTriggered++; + collect_unprotect(); + } + if (vm->memoryUsed + (n - old_sz) > vm->memoryLimit) { - _since_last_collection += (n - old_sz); + vm->_since_last_collection += (n - old_sz); unlock(); vm->stopService(); return 0; } + } else { +#endif + + _since_last_collection -= (n - old_sz); + + if(_enable_auto && (_since_last_collection <= 0)) { + collect_unprotect(); + } + +#ifdef SERVICE } #endif Modified: vmkit/trunk/lib/Mvm/GCMmap2/gcthread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gcthread.h?rev=60567&r1=60566&r2=60567&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gcthread.h (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gcthread.h Thu Dec 4 18:02:42 2008 @@ -125,14 +125,18 @@ inline void inject(mvm::Thread* th) { lock(); +#ifdef SERVICE + if (th->MyVM->numThreads + 1 > th->MyVM->threadLimit) { + unlock(); + th->MyVM->stopService(); + } + th->MyVM->numThreads++; +#endif if (base) th->append(base); else base = th; _nb_threads++; -#ifdef SERVICE - th->MyVM->numThreads++; -#endif unlock(); } }; From nicolas.geoffray at lip6.fr Tue Dec 9 02:03:39 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 09 Dec 2008 10:03:39 -0000 Subject: [vmkit-commits] [vmkit] r60756 - /vmkit/trunk/include/debug.h Message-ID: <200812091003.mB9A3fbh004916@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 9 04:03:28 2008 New Revision: 60756 URL: http://llvm.org/viewvc/llvm-project?rev=60756&view=rev Log: Debug output to stderr. Modified: vmkit/trunk/include/debug.h Modified: vmkit/trunk/include/debug.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/debug.h?rev=60756&r1=60755&r2=60756&view=diff ============================================================================== --- vmkit/trunk/include/debug.h (original) +++ vmkit/trunk/include/debug.h Tue Dec 9 04:03:28 2008 @@ -49,16 +49,14 @@ #ifdef WITH_COLOR #define PRINT_DEBUG(symb, level, color, ...) \ if (symb > level) { \ - printf("%s%s%s", ESC, color, END); \ - printf(__VA_ARGS__); \ - printf("%s%s%s", ESC, COLOR_NORMAL, END); \ - fflush(stdout); \ + fprintf(stderr, "%s%s%s", ESC, color, END); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "%s%s%s", ESC, COLOR_NORMAL, END); \ } #else #define PRINT_DEBUG(symb, level, color, ...) \ if (symb > level) { \ - printf(__VA_ARGS__); \ - fflush(stdout); \ + fprintf(stderr, __VA_ARGS__); \ } #endif From nicolas.geoffray at lip6.fr Tue Dec 9 02:04:22 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 09 Dec 2008 10:04:22 -0000 Subject: [vmkit-commits] [vmkit] r60757 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200812091004.mB9A4MN2004958@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 9 04:04:21 2008 New Revision: 60757 URL: http://llvm.org/viewvc/llvm-project?rev=60757&view=rev Log: Fix compilation warning on x64. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=60757&r1=60756&r2=60757&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 9 04:04:21 2008 @@ -1167,14 +1167,22 @@ void JnjvmModule::printStats() { fprintf(stderr, "----------------- Info from the module -----------------\n"); - fprintf(stderr, "Number of native classes : %d\n", nativeClasses.size()); - fprintf(stderr, "Number of Java classes : %d\n", javaClasses.size()); - fprintf(stderr, "Number of virtual tables : %d\n", virtualTables.size()); - fprintf(stderr, "Number of static instances : %d\n", staticInstances.size()); - fprintf(stderr, "Number of constant pools : %d\n", constantPools.size()); - fprintf(stderr, "Number of strings : %d\n", strings.size()); - fprintf(stderr, "Number of enveloppes : %d\n", enveloppes.size()); - fprintf(stderr, "Number of native functions : %d\n", nativeFunctions.size()); + fprintf(stderr, "Number of native classes : %llu\n", + (unsigned long long int) nativeClasses.size()); + fprintf(stderr, "Number of Java classes : %llu\n", + (unsigned long long int) javaClasses.size()); + fprintf(stderr, "Number of virtual tables : %llu\n", + (unsigned long long int) virtualTables.size()); + fprintf(stderr, "Number of static instances : %llu\n", + (unsigned long long int) staticInstances.size()); + fprintf(stderr, "Number of constant pools : %llu\n", + (unsigned long long int) constantPools.size()); + fprintf(stderr, "Number of strings : %llu\n", + (unsigned long long int) strings.size()); + fprintf(stderr, "Number of enveloppes : %llu\n", + (unsigned long long int) enveloppes.size()); + fprintf(stderr, "Number of native functions : %llu\n", + (unsigned long long int) nativeFunctions.size()); } From nicolas.geoffray at lip6.fr Tue Dec 9 05:55:43 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 09 Dec 2008 13:55:43 -0000 Subject: [vmkit-commits] [vmkit] r60762 - in /vmkit/trunk: include/mvm/Threads/Locks.h include/mvm/Threads/Thread.h lib/JnJVM/Classpath/ClasspathReflect.h lib/JnJVM/VMCore/Jnjvm.cpp lib/Mvm/CommonThread/ctthread.cpp Message-ID: <200812091355.mB9Dth9X012260@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 9 07:55:36 2008 New Revision: 60762 URL: http://llvm.org/viewvc/llvm-project?rev=60762&view=rev Log: Implement thread termination by relying on the GC to run the thread destructor. Modified: vmkit/trunk/include/mvm/Threads/Locks.h vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Modified: vmkit/trunk/include/mvm/Threads/Locks.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Locks.h?rev=60762&r1=60761&r2=60762&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Locks.h (original) +++ vmkit/trunk/include/mvm/Threads/Locks.h Tue Dec 9 07:55:36 2008 @@ -133,7 +133,7 @@ lock |= 1; } else if ((lock & ThinMask) == id) { if ((lock & ThinCountMask) == ThinCountMask) { - overflowThinLock(); + overflowThinLock(O); } else { ++lock; } Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=60762&r1=60761&r2=60762&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 9 07:55:36 2008 @@ -135,6 +135,8 @@ static const uint64_t IDMask = 0x7FF00000; void* operator new(size_t sz); + + void operator delete(void* obj); void (*routine)(mvm::Thread*); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h?rev=60762&r1=60761&r2=60762&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Tue Dec 9 07:55:36 2008 @@ -93,6 +93,20 @@ }; +class JavaObjectVMThread : public JavaObject { +private: + JavaObject* thread; + bool running; + JavaObject* vmdata; + +public: + static void staticDestructor(JavaObjectVMThread* obj) { + mvm::Thread* th = (mvm::Thread*)obj->vmdata; + delete th; + } + +}; + } #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=60762&r1=60761&r2=60762&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 9 07:55:36 2008 @@ -780,6 +780,10 @@ ptr = ((uintptr_t*)upcalls->newField->getVirtualVT()); ptr[VT_TRACER_OFFSET] = (uintptr_t)JavaObjectField::staticTracer; + LOAD_CLASS(upcalls->newVMThread); + ptr = ((uintptr_t*)upcalls->newVMThread->getVirtualVT()); + ptr[VT_DESTRUCTOR_OFFSET] = (uintptr_t)JavaObjectVMThread::staticDestructor; + LOAD_CLASS(upcalls->newStackTraceElement); LOAD_CLASS(upcalls->newVMThrowable); LOAD_CLASS(upcalls->boolClass); Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=60762&r1=60761&r2=60762&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original) +++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Tue Dec 9 07:55:36 2008 @@ -8,6 +8,8 @@ //===----------------------------------------------------------------------===// #include "mvm/VirtualMachine.h" +#include "mvm/Threads/Cond.h" +#include "mvm/Threads/Locks.h" #include "mvm/Threads/Thread.h" #include @@ -65,7 +67,7 @@ uintptr_t baseAddr; uint32 allocPtr; uint32 used[NR_THREADS]; - LockNormal lock; + LockNormal stackLock; StackThreadManager() { baseAddr = 0; @@ -103,19 +105,21 @@ } uintptr_t allocate() { + stackLock.lock(); uint32 start = allocPtr; - bool found = false; - uint32 myAllocPtr = allocPtr; + uint32 myIndex = 0; do { - found = __sync_bool_compare_and_swap_32(&used[myAllocPtr], 0, 1); - myAllocPtr++; - if (myAllocPtr == NR_THREADS) myAllocPtr = 0; - } while (myAllocPtr != start && !found); + if (!used[allocPtr]) { + used[allocPtr] = 1; + myIndex = allocPtr; + } + if (++allocPtr == NR_THREADS) allocPtr = 0; + } while (!myIndex && allocPtr != start); + + stackLock.unlock(); - if (found) { - allocPtr = myAllocPtr; - return baseAddr + (myAllocPtr - 1) * STACK_SIZE; - } + if (myIndex) + return baseAddr + myIndex * STACK_SIZE; return 0; } @@ -127,6 +131,7 @@ /// machine specific. StackThreadManager TheStackManager; + /// internalThreadStart - The initial function called by a thread. Sets some /// thread specific data, registers the thread to the GC and calls the /// given routine of th. @@ -164,5 +169,20 @@ /// Thread objects can not exceed a page. void* Thread::operator new(size_t sz) { assert(sz < (size_t)getpagesize() && "Thread local data too big"); - return (void*)TheStackManager.allocate(); + void* res = (void*)TheStackManager.allocate(); + // Give it a second chance. + if (!res) { + Collector::collect(); + res = (void*)TheStackManager.allocate(); + } + return res; +} + +/// operator delete - Remove the stack of the thread from the list of stacks +/// in use. +void Thread::operator delete(void* th) { + Thread* Th = (Thread*)th; + uintptr_t index = ((uintptr_t)Th->baseSP & Thread::IDMask); + index = (index & ~TheStackManager.baseAddr) >> 20; + TheStackManager.used[index] = 0; } From nicolas.geoffray at lip6.fr Tue Dec 9 07:14:11 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 09 Dec 2008 15:14:11 -0000 Subject: [vmkit-commits] [vmkit] r60768 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200812091514.mB9FEBKt015074@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 9 09:14:11 2008 New Revision: 60768 URL: http://llvm.org/viewvc/llvm-project?rev=60768&view=rev Log: Optimize the GetArrayClass function. Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=60768&r1=60767&r2=60768&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Dec 9 09:14:11 2008 @@ -18,7 +18,7 @@ #include "mvm/JIT.h" #include "JnjvmModule.h" - +#include using namespace llvm; namespace jnjvm { @@ -36,14 +36,19 @@ "Lower Constant calls"); -static ConstantExpr* getClass(JnjvmModule* Mod, CallSite& Call) { +static ConstantExpr* getClass(JnjvmModule* Mod, Value* obj) { ConstantExpr* CE = 0; if (Mod->isStaticCompiling()) { - LoadInst* LI = dyn_cast(Call.getArgument(0)); + LoadInst* LI = dyn_cast(obj); if (!LI) { - PHINode* node = dyn_cast(Call.getArgument(0)); + PHINode* node = dyn_cast(obj); if (node) { LI = dyn_cast(node->getIncomingValue(0)); + } else { + GetElementPtrInst* GEP = dyn_cast(obj); + if (GEP) { + return getClass(Mod, GEP->getOperand(0)); + } } } @@ -52,10 +57,10 @@ CE = dyn_cast(GV->getInitializer()); } } else { - CE = dyn_cast(Call.getArgument(0)); + CE = dyn_cast(obj); if (!CE) { // It has to be a phi for intialization check. - PHINode* node = dyn_cast(Call.getArgument(0)); + PHINode* node = dyn_cast(obj); if (node) CE = dyn_cast(node->getIncomingValue(0)); } } @@ -154,9 +159,9 @@ if (isVirtual(meth->access)) { if (Cmp->getOperand(1) == module->JavaObjectNullConstant && Cmp->getOperand(0) == F.arg_begin()) { + Changed = true; Cmp->replaceAllUsesWith(ConstantInt::getFalse()); - Cmp->eraseFromParent(); - continue; + break; } } } @@ -200,7 +205,7 @@ } else if (V == module->GetVTFromClassFunction) { Changed = true; - ConstantExpr* CE = getClass(module, Call); + ConstantExpr* CE = getClass(module, Call.getArgument(0)); if (CE) { ConstantInt* C = (ConstantInt*)CE->getOperand(0); Class* cl = (Class*)C->getZExtValue(); @@ -223,7 +228,7 @@ } else if (V == module->GetObjectSizeFromClassFunction) { Changed = true; - ConstantExpr* CE = getClass(module, Call); + ConstantExpr* CE = getClass(module, Call.getArgument(0)); if (CE) { ConstantInt* C = (ConstantInt*)CE->getOperand(0); Class* cl = (Class*)C->getZExtValue(); @@ -355,7 +360,7 @@ } else if (V == module->GetStaticInstanceFunction) { Changed = true; #if !defined(ISOLATE_SHARING) && !defined(ISOLATE) - ConstantExpr* CE = getClass(module, Call); + ConstantExpr* CE = getClass(module, Call.getArgument(0)); assert(CE && "Wrong use of GetStaticInstanceFunction"); ConstantInt* C = (ConstantInt*)CE->getOperand(0); @@ -565,7 +570,7 @@ // Check if we have already proceed this call. if (Call.getArgument(1) == nullValue) { Changed = true; - ConstantExpr* CE = getClass(module, Call); + ConstantExpr* CE = getClass(module, Call.getArgument(0)); if (CE) { ConstantInt* C = (ConstantInt*)CE->getOperand(0); Class* cl = (Class*)C->getZExtValue(); @@ -575,8 +580,17 @@ UserCommonClass* dcl = JCL->constructArray(arrayName); Value* valCl = module->getNativeClass(dcl, CI); + + Instruction* V = dyn_cast(Call.getArgument(0)); CI->replaceAllUsesWith(valCl); CI->eraseFromParent(); + + if (V) { + Instruction* Op = dyn_cast(V->getOperand(0)); + if (!V->getNumUses()) V->eraseFromParent(); + if (Op && !Op->getNumUses()) Op->eraseFromParent(); + } + continue; } } From nicolas.geoffray at lip6.fr Tue Dec 9 10:07:54 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 09 Dec 2008 18:07:54 -0000 Subject: [vmkit-commits] [vmkit] r60773 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200812091807.mB9I7tJl020744@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 9 12:07:54 2008 New Revision: 60773 URL: http://llvm.org/viewvc/llvm-project?rev=60773&view=rev Log: Remove iostream. Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=60773&r1=60772&r2=60773&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Dec 9 12:07:54 2008 @@ -18,7 +18,7 @@ #include "mvm/JIT.h" #include "JnjvmModule.h" -#include + using namespace llvm; namespace jnjvm { From nicolas.geoffray at lip6.fr Tue Dec 9 10:09:43 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 09 Dec 2008 18:09:43 -0000 Subject: [vmkit-commits] [vmkit] r60774 - /vmkit/trunk/lib/N3/VMCore/VMCache.cpp Message-ID: <200812091809.mB9I9hEb020810@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 9 12:09:43 2008 New Revision: 60774 URL: http://llvm.org/viewvc/llvm-project?rev=60774&view=rev Log: Remove iostream. Modified: vmkit/trunk/lib/N3/VMCore/VMCache.cpp Modified: vmkit/trunk/lib/N3/VMCore/VMCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMCache.cpp?rev=60774&r1=60773&r2=60774&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMCache.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMCache.cpp Tue Dec 9 12:09:43 2008 @@ -7,7 +7,6 @@ // //===----------------------------------------------------------------------===// -#include #include #include "llvm/DerivedTypes.h" From nicolas.geoffray at lip6.fr Wed Dec 10 05:50:10 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 10 Dec 2008 13:50:10 -0000 Subject: [vmkit-commits] [vmkit] r60835 - /vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Message-ID: <200812101350.mBADoFIc001974@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 10 07:49:37 2008 New Revision: 60835 URL: http://llvm.org/viewvc/llvm-project?rev=60835&view=rev Log: Remove useless include. Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=60835&r1=60834&r2=60835&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Wed Dec 10 07:49:37 2008 @@ -10,7 +10,6 @@ #include "mvm/Object.h" #include "JavaArray.h" -#include "JavaCache.h" #include "JavaClass.h" #include "JavaObject.h" #include "JavaThread.h" From nicolas.geoffray at lip6.fr Wed Dec 10 05:53:44 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 10 Dec 2008 13:53:44 -0000 Subject: [vmkit-commits] [vmkit] r60836 - in /vmkit/trunk/lib/JnJVM: LLVMRuntime/runtime-default.ll LLVMRuntime/runtime-isolate.ll LLVMRuntime/runtime-single.ll VMCore/JavaCache.cpp VMCore/JavaCache.h VMCore/JavaConstantPool.cpp VMCore/JavaConstantPool.h VMCore/JavaJIT.cpp VMCore/JavaRuntimeJIT.cpp Message-ID: <200812101354.mBADs2ax002086@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 10 07:53:05 2008 New Revision: 60836 URL: http://llvm.org/viewvc/llvm-project?rev=60836&view=rev Log: Inline the first cache inside the enveloppe. And an enveloppe now references name and sign, not the constant pool it belongs to. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp 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=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Wed Dec 10 07:53:05 2008 @@ -21,9 +21,12 @@ %ArrayUInt32 = type { %JavaObject, i8*, [0 x i32] } %ArrayUInt8 = type { %JavaObject, i8*, [0 x i8] } +;;; The CacheNode type. The first field is the last called method. +%CacheNode = type { i8*, %JavaCommonClass*, %CacheNode*, %Enveloppe* } + ;;; The Enveloppe type, which contains the first cache and all the info ;;; to lookup in the constant pool. -%Enveloppe = type { %CacheNode*, i8**, i8*, i32 } +%Enveloppe = type { %CacheNode*, %UTF8*, i8*, i8*, %CacheNode } ;;; The task class mirror. ;;; Field 1: The class state Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Wed Dec 10 07:53:05 2008 @@ -14,10 +14,6 @@ i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*, void (i8*)* } -;;; The CacheNode type. The second field is the last called method. The -;;; last field is for multi vm environment. -%CacheNode = type { i8*, %JavaCommonClass*, %CacheNode*, %Enveloppe*, i8** } - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll Wed Dec 10 07:53:05 2008 @@ -12,6 +12,3 @@ i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*, void (i8*)* } - -;;; The CacheNode type. The second field is the last called method. -%CacheNode = type { i8*, %JavaCommonClass*, %CacheNode*, %Enveloppe*} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Wed Dec 10 07:53:05 2008 @@ -25,32 +25,3 @@ #include "types.h" using namespace jnjvm; - -Enveloppe::~Enveloppe() { - CacheNode* cache = firstCache; - CacheNode* next = firstCache; - mvm::BumpPtrAllocator& allocator = ctpInfo->classDef->classLoader->allocator; - while(next) { - next = cache->next; - cache->~CacheNode(); - allocator.Deallocate(cache); - cache = next; - } -} - -CacheNode::CacheNode(Enveloppe* E) { - lastCible = 0; - methPtr = 0; - next = 0; - enveloppe = E; -#ifdef ISOLATE_SHARING - definingCtp = 0; -#endif -} - -void Enveloppe::initialise(UserConstantPool* ctp, uint32 i) { - mvm::BumpPtrAllocator& allocator = ctp->classDef->classLoader->allocator; - firstCache = new(allocator) CacheNode(this); - ctpInfo = ctp; - index = i; -} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Wed Dec 10 07:53:05 2008 @@ -33,8 +33,9 @@ namespace jnjvm { class Enveloppe; +class Signdef; class UserClass; -class UserConstantPool; +class UTF8; /// CacheNode - A {class, method pointer} pair. class CacheNode : public mvm::PermanentObject { @@ -52,49 +53,69 @@ /// enveloppe - The container to which this class belongs to. Enveloppe* enveloppe; -#ifdef ISOLATE_SHARING - ///definingClass - The class that defined the method being called. - /// - UserConstantPool* definingCtp; -#endif - /// CacheNode - Creates a CacheNode with empty values. - CacheNode(Enveloppe* E); + CacheNode(Enveloppe* E) { + lastCible = 0; + methPtr = 0; + next = 0; + enveloppe = E; + } }; /// Enveloppe - A reference to the linked list of CacheNode. class Enveloppe : public mvm::PermanentObject { public: - /// ~Enveloppe - Deletes all CacheNode in the linked list. - ~Enveloppe(); - /// firstCache - The first entry in the linked list, hence the last /// class occurence for a given invokeinterface call. + /// CacheNode *firstCache; + + /// methodName - The name of the method to be called. + /// + const UTF8* methodName; - /// ctpInfo - The constant pool info that owns the invokeinterface - /// bytecode. This is used to resolve the interface call at its first - /// occurence. - UserConstantPool* ctpInfo; + /// methodSign - The signature of the method to be called. + /// + Signdef* methodSign; /// cacheLock - The linked list may be modified by concurrent thread. This /// lock ensures that the list stays consistent. + /// mvm::LockNormal cacheLock; - /// index - The index in the constant pool of the interface method. - uint32 index; + /// allocator - Reference to the allocator in order to know where to allocate + /// cache nodes. + /// + mvm::BumpPtrAllocator* allocator; + + /// bootCache - The first cache allocated for the enveloppe. + /// + CacheNode bootCache; - /// Enveloppe - Allocates the linked list with the given constant pool info - /// at the given index, so as the resolution process knows which interface - /// method the invokeinterface bytecode references. - Enveloppe(UserConstantPool* info, uint32 index) { - initialise(info, index); - } + /// Evenloppe - Default constructor. Does nothing. + /// + Enveloppe() : bootCache(this) {} - Enveloppe() {} + /// Enveloppe - Allocates the linked list with the given name and signature + /// so as the resolution process knows which interface method the + /// invokeinterface bytecode refers to. + /// + Enveloppe(mvm::BumpPtrAllocator& Alloc, const UTF8* name, Signdef* sign) : + bootCache(this) { + + initialise(Alloc, name, sign); + } - void initialise(UserConstantPool* info, uint32 index); + /// initialise - Initialises the enveloppe, and allocates the first cache. + /// + void initialise(mvm::BumpPtrAllocator& Alloc, const UTF8* name, + Signdef* sign) { + allocator = &Alloc; + firstCache = &bootCache; + methodName = name; + methodSign = sign; + } }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Wed Dec 10 07:53:05 2008 @@ -447,15 +447,18 @@ } -Signdef* JavaConstantPool::infoOfInterfaceOrVirtualMethod(uint32 index) { +Signdef* JavaConstantPool::infoOfInterfaceOrVirtualMethod(uint32 index, + const UTF8*& name) { uint8 id = typeAt(index); if (id != ConstantMethodref && id != ConstantInterfaceMethodref) JavaThread::get()->getJVM()->classFormatError( "bad constant pool number for method at entry %d", index); - Signdef* sign = resolveNameAndSign(ctpDef[index] & 0xFFFF); - + sint32 entry = ctpDef[index]; + sint32 ntIndex = entry & 0xFFFF; + Signdef* sign = resolveNameAndSign(ntIndex); + name = UTF8At(ctpDef[ntIndex] >> 16); return sign; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Wed Dec 10 07:53:05 2008 @@ -187,7 +187,7 @@ /// infoOfInterfaceOrVirtualMethod - Get the signature of the method /// referenced at the given entry. - Signdef* infoOfInterfaceOrVirtualMethod(uint32 index); + Signdef* infoOfInterfaceOrVirtualMethod(uint32 index, const UTF8*& name); /// infoOfStaticOrSpecialMethod - Get the JIT representation of a /// non-virtual method. Also returns its signature and the Jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Dec 10 07:53:05 2008 @@ -77,7 +77,8 @@ } #if !defined(WITHOUT_VTABLE) - Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index); + const UTF8* name = 0; + Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index, name); Typedef* retTypedef = signature->ret; std::vector args; // size = [signature->nbIn + 3]; LLVMSignatureInfo* LSI = module->getSignatureInfo(signature); @@ -1972,7 +1973,8 @@ // Do the usual JavaConstantPool* ctpInfo = compilingClass->ctpInfo; - Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index); + const UTF8* name = 0; + Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index, name); LLVMSignatureInfo* LSI = module->getSignatureInfo(signature); const llvm::FunctionType* virtualType = LSI->getVirtualType(); @@ -2001,7 +2003,8 @@ *(new (compilingClass->classLoader->allocator) Enveloppe()) : compilingMethod->enveloppes[nbEnveloppes++]; if (!inlining) - enveloppe.initialise(compilingClass->ctpInfo, index); + enveloppe.initialise(compilingClass->classLoader->allocator, name, + signature); Value* llvmEnv = module->getEnveloppe(&enveloppe, currentBlock); #else Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=60836&r1=60835&r2=60836&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Wed Dec 10 07:53:05 2008 @@ -28,14 +28,8 @@ extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) { Enveloppe* enveloppe = cache->enveloppe; - UserConstantPool* ctpInfo = enveloppe->ctpInfo; UserCommonClass* ocl = obj->classOf; - UserCommonClass* cl = 0; - const UTF8* utf8 = 0; - Signdef* sign = 0; - uint32 index = enveloppe->index; - ctpInfo->resolveMethod(index, cl, utf8, sign); #ifndef SERVICE assert((obj->classOf->isClass() && obj->classOf->asClass()->isInitializing()) && @@ -60,24 +54,24 @@ if (!rcache) { UserClass* methodCl = 0; UserClass* lookup = ocl->isArray() ? ocl->super : ocl->asClass(); - JavaMethod* dmeth = lookup->lookupMethod(utf8, sign->keyName, false, true, - &methodCl); + JavaMethod* dmeth = lookup->lookupMethod(enveloppe->methodName, + enveloppe->methodSign->keyName, + false, true, &methodCl); + #if !defined(ISOLATE_SHARING) && !defined(SERVICE) assert(dmeth->classDef->isInitializing() && "Class not ready in a virtual lookup."); #endif - if (cache->methPtr) { - JnjvmClassLoader* loader = ctpInfo->classDef->classLoader; - rcache = new(loader->allocator) CacheNode(enveloppe); + + // Are we the first cache? + if (cache != &(enveloppe->bootCache)) { + rcache = new(*(enveloppe->allocator)) CacheNode(enveloppe); } else { rcache = cache; } rcache->methPtr = dmeth->compiledPtr(); rcache->lastCible = (UserClass*)ocl; -#ifdef ISOLATE_SHARING - rcache->definingCtp = methodCl->getConstantPool(); -#endif } From nicolas.geoffray at lip6.fr Wed Dec 10 05:55:39 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 10 Dec 2008 13:55:39 -0000 Subject: [vmkit-commits] [vmkit] r60837 - /vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Message-ID: <200812101355.mBADtfwH002141@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 10 07:55:20 2008 New Revision: 60837 URL: http://llvm.org/viewvc/llvm-project?rev=60837&view=rev Log: Remove this file (forgot to do that in r60836). Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=60836&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (removed) @@ -1,27 +0,0 @@ -//===------ JavaCache.cpp - Inline cache for virtual calls -----------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "mvm/JIT.h" -#include "mvm/Object.h" -#include "mvm/PrintBuffer.h" -#include "mvm/Threads/Locks.h" - -#include "JavaCache.h" -#include "JavaClass.h" -#include "JavaConstantPool.h" -#include "JavaJIT.h" -#include "JavaThread.h" -#include "JavaTypes.h" -#include "Jnjvm.h" - -#include "types.h" - -using namespace jnjvm; From nicolas.geoffray at lip6.fr Thu Dec 11 02:52:11 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 11 Dec 2008 10:52:11 -0000 Subject: [vmkit-commits] [vmkit] r60874 - in /vmkit/trunk/lib/JnJVM: LLVMRuntime/runtime-default.ll VMCore/JavaCache.h VMCore/JavaJIT.cpp VMCore/JavaRuntimeJIT.cpp Message-ID: <200812111052.mBBAqFo7017929@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 11 04:51:34 2008 New Revision: 60874 URL: http://llvm.org/viewvc/llvm-project?rev=60874&view=rev Log: User the UTF8 sign instead of the Signdef directly. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp 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=60874&r1=60873&r2=60874&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Thu Dec 11 04:51:34 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*, i8*, i8*, %CacheNode } +%Enveloppe = type { %CacheNode*, %UTF8*, %UTF8*, i8*, i8*, %CacheNode } ;;; The task class mirror. ;;; Field 1: The class state Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=60874&r1=60873&r2=60874&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Thu Dec 11 04:51:34 2008 @@ -33,7 +33,6 @@ namespace jnjvm { class Enveloppe; -class Signdef; class UserClass; class UTF8; @@ -77,7 +76,7 @@ /// methodSign - The signature of the method to be called. /// - Signdef* methodSign; + const UTF8* methodSign; /// cacheLock - The linked list may be modified by concurrent thread. This /// lock ensures that the list stays consistent. @@ -93,7 +92,7 @@ /// CacheNode bootCache; - /// Evenloppe - Default constructor. Does nothing. + /// Enveloppe - Default constructor. Does nothing. /// Enveloppe() : bootCache(this) {} @@ -101,7 +100,7 @@ /// so as the resolution process knows which interface method the /// invokeinterface bytecode refers to. /// - Enveloppe(mvm::BumpPtrAllocator& Alloc, const UTF8* name, Signdef* sign) : + Enveloppe(mvm::BumpPtrAllocator& Alloc, const UTF8* name, const UTF8* sign) : bootCache(this) { initialise(Alloc, name, sign); @@ -110,7 +109,7 @@ /// initialise - Initialises the enveloppe, and allocates the first cache. /// void initialise(mvm::BumpPtrAllocator& Alloc, const UTF8* name, - Signdef* sign) { + const UTF8* sign) { allocator = &Alloc; firstCache = &bootCache; methodName = name; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60874&r1=60873&r2=60874&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Dec 11 04:51:34 2008 @@ -2004,7 +2004,7 @@ compilingMethod->enveloppes[nbEnveloppes++]; if (!inlining) enveloppe.initialise(compilingClass->classLoader->allocator, name, - signature); + signature->keyName); Value* llvmEnv = module->getEnveloppe(&enveloppe, currentBlock); #else Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=60874&r1=60873&r2=60874&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Dec 11 04:51:34 2008 @@ -55,7 +55,7 @@ UserClass* methodCl = 0; UserClass* lookup = ocl->isArray() ? ocl->super : ocl->asClass(); JavaMethod* dmeth = lookup->lookupMethod(enveloppe->methodName, - enveloppe->methodSign->keyName, + enveloppe->methodSign, false, true, &methodCl); #if !defined(ISOLATE_SHARING) && !defined(SERVICE) From nicolas.geoffray at lip6.fr Thu Dec 11 06:00:54 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 11 Dec 2008 14:00:54 -0000 Subject: [vmkit-commits] [vmkit] r60876 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathConstructor.cpp Classpath/ClasspathMethod.cpp VMCore/JavaJIT.cpp VMCore/JavaMetaJIT.cpp VMCore/JavaTypes.cpp VMCore/JavaTypes.h VMCore/JnjvmClassLoader.cpp VMCore/JnjvmModule.cpp VMCore/NativeUtil.cpp Message-ID: <200812111400.mBBE0xnl023842@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 11 08:00:46 2008 New Revision: 60876 URL: http://llvm.org/viewvc/llvm-project?rev=60876&view=rev Log: Inline the arguments of a signdef in the signdef object itself. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Thu Dec 11 08:00:46 2008 @@ -8,7 +8,7 @@ // //===----------------------------------------------------------------------===// -#include +#include #include "types.h" @@ -80,14 +80,14 @@ JavaMethod* meth = (JavaMethod*)_meth; JavaArray* args = (JavaArray*)_args; sint32 nbArgs = args ? args->size : 0; - sint32 size = meth->getSignature()->args.size(); + Signdef* sign = meth->getSignature(); + sint32 size = sign->nbArguments; // Allocate a buffer to store the arguments. uintptr_t buf = (uintptr_t)alloca(size * sizeof(uint64)); // Record the beginning of the buffer. void* startBuf = (void*)buf; - sint32 index = 0; if (nbArgs == size) { UserCommonClass* _cl = NativeUtil::resolvedImplClass(vm, Clazz, false); UserClass* cl = _cl->asClass(); @@ -95,12 +95,11 @@ cl->initialiseClass(vm); JavaObject* res = cl->doNew(vm); JavaObject** ptr = (JavaObject**)(void*)(args->elements); - Signdef* sign = meth->getSignature(); + Typedef* const* arguments = sign->getArgumentsType(); // Store the arguments, unboxing primitives if necessary. - for (std::vector::iterator i = sign->args.begin(), - e = sign->args.end(); i != e; ++i, ++index) { - NativeUtil::decapsulePrimitive(vm, buf, ptr[index], *i); + for (sint32 i = 0; i < size; ++i) { + NativeUtil::decapsulePrimitive(vm, buf, ptr[i], arguments[i]); } JavaObject* excp = 0; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Thu Dec 11 08:00:46 2008 @@ -8,7 +8,7 @@ // //===----------------------------------------------------------------------===// -#include +#include #include "types.h" @@ -62,7 +62,8 @@ JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; - return (jclass)NativeUtil::getClassType(loader, meth->getSignature()->ret); + Typedef* ret = meth->getSignature()->getReturnType(); + return (jclass)NativeUtil::getClassType(loader, ret); } @@ -89,12 +90,12 @@ JavaMethod* meth = (JavaMethod*)_meth; JavaArray* args = (JavaArray*)_args; sint32 nbArgs = args ? args->size : 0; - sint32 size = meth->getSignature()->args.size(); + Signdef* sign = meth->getSignature(); + sint32 size = sign->nbArguments; JavaObject* obj = (JavaObject*)_obj; uintptr_t buf = (uintptr_t)alloca(size * sizeof(uint64)); void* _buf = (void*)buf; - sint32 index = 0; if (nbArgs == size) { UserCommonClass* _cl = NativeUtil::resolvedImplClass(vm, Cl, false); UserClass* cl = (UserClass*)_cl; @@ -116,11 +117,10 @@ cl->initialiseClass(vm); } - Signdef* sign = meth->getSignature(); - JavaObject** ptr = (JavaObject**)(void*)(args->elements); - for (std::vector::iterator i = sign->args.begin(), - e = sign->args.end(); i != e; ++i, ++index) { - NativeUtil::decapsulePrimitive(vm, buf, ptr[index], *i); + JavaObject** ptr = (JavaObject**)(void*)(args->elements); + Typedef* const* arguments = sign->getArgumentsType(); + for (sint32 i = 0; i < size; ++i) { + NativeUtil::decapsulePrimitive(vm, buf, ptr[i], arguments[i]); } JavaObject* exc = 0; @@ -152,7 +152,7 @@ } \ JavaObject* res = 0; - Typedef* retType = sign->ret; + Typedef* retType = sign->getReturnType(); if (retType->isPrimitive()) { PrimitiveTypedef* prim = (PrimitiveTypedef*)retType; if (prim->isVoid()) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Dec 11 08:00:46 2008 @@ -79,12 +79,12 @@ #if !defined(WITHOUT_VTABLE) const UTF8* name = 0; Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index, name); - Typedef* retTypedef = signature->ret; + Typedef* retTypedef = signature->getReturnType(); std::vector args; // size = [signature->nbIn + 3]; LLVMSignatureInfo* LSI = module->getSignatureInfo(signature); const llvm::FunctionType* virtualType = LSI->getVirtualType(); FunctionType::param_iterator it = virtualType->param_end(); - makeArgs(it, index, args, signature->args.size() + 1); + makeArgs(it, index, args, signature->nbArguments + 1); const llvm::Type* retType = virtualType->getReturnType(); JITVerifyNull(args[0]); @@ -466,8 +466,9 @@ #else uint32 max = args.size(); #endif - std::vector::iterator type = - compilingMethod->getSignature()->args.begin(); + Signdef* sign = compilingMethod->getSignature(); + Typedef* const* arguments = sign->getArgumentsType(); + uint32 type = 0; std::vector::iterator i = args.begin(); if (isVirtual(compilingMethod->access)) { @@ -480,7 +481,7 @@ for (;count < max; ++i, ++index, ++count, ++type) { - const Typedef* cur = *type; + const Typedef* cur = arguments[type]; const Type* curType = (*i)->getType(); if (curType == Type::Int64Ty){ @@ -588,8 +589,9 @@ uint32 max = func->arg_size(); #endif Function::arg_iterator i = func->arg_begin(); - std::vector::iterator type = - compilingMethod->getSignature()->args.begin(); + Signdef* sign = compilingMethod->getSignature(); + Typedef* const* arguments = sign->getArgumentsType(); + uint32 type = 0; if (isVirtual(compilingMethod->access)) { new StoreInst(i, objectLocals[0], false, currentBlock); @@ -600,7 +602,7 @@ for (;count < max; ++i, ++index, ++count, ++type) { - const Typedef* cur = *type; + const Typedef* cur = arguments[type]; const llvm::Type* curType = i->getType(); if (curType == Type::Int64Ty){ @@ -1505,7 +1507,7 @@ std::vector args; FunctionType::param_iterator it = virtualType->param_end(); - makeArgs(it, index, args, signature->args.size() + 1); + makeArgs(it, index, args, signature->nbArguments + 1); JITVerifyNull(args[0]); #if defined(ISOLATE_SHARING) @@ -1545,7 +1547,7 @@ const llvm::Type* retType = virtualType->getReturnType(); if (retType != Type::VoidTy) { - push(val, signature->ret->isUnsigned()); + push(val, signature->getReturnType()->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { push(module->constantZero, false); } @@ -1566,7 +1568,7 @@ std::vector args; // size = [signature->nbIn + 2]; FunctionType::param_iterator it = staticType->param_end(); - makeArgs(it, index, args, signature->args.size()); + makeArgs(it, index, args, signature->nbArguments); ctpInfo->markAsStaticCall(index); JnjvmBootstrapLoader* loader = compilingClass->classLoader->bootstrapLoader; @@ -1616,7 +1618,7 @@ const llvm::Type* retType = staticType->getReturnType(); if (retType != Type::VoidTy) { - push(val, signature->ret->isUnsigned()); + push(val, signature->getReturnType()->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { push(module->constantZero, false); } @@ -1983,7 +1985,7 @@ std::vector args; // size = [signature->nbIn + 3]; FunctionType::param_iterator it = virtualType->param_end(); - makeArgs(it, index, args, signature->args.size() + 1); + makeArgs(it, index, args, signature->nbArguments + 1); const llvm::Type* retType = virtualType->getReturnType(); BasicBlock* endBlock = createBasicBlock("end virtual invoke"); @@ -2072,7 +2074,7 @@ currentBlock = endBlock; if (node) { - push(node, signature->ret->isUnsigned()); + push(node, signature->getReturnType()->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { push(module->constantZero, false); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Thu Dec 11 08:00:46 2008 @@ -52,28 +52,28 @@ #define readArgs(buf, signature, ap) \ - for (std::vector::iterator i = signature->args.begin(), \ - e = signature->args.end(); i!= e; i++) { \ - const Typedef* type = *i;\ - if (type->isPrimitive()){\ + Typedef* const* arguments = signature->getArgumentsType(); \ + for (uint32 i = 0; i < signature->nbArguments; ++i) { \ + const Typedef* type = arguments[i];\ + if (type->isPrimitive()) {\ const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;\ - if (prim->isLong()){\ + if (prim->isLong()) {\ ((sint64*)buf)[0] = va_arg(ap, sint64);\ } else if (prim->isInt()){ \ ((sint32*)buf)[0] = va_arg(ap, sint32);\ - } else if (prim->isChar()){ \ + } else if (prim->isChar()) { \ ((uint32*)buf)[0] = va_arg(ap, uint32);\ - } else if (prim->isShort()){ \ + } else if (prim->isShort()) { \ ((uint32*)buf)[0] = va_arg(ap, uint32);\ - } else if (prim->isByte()){ \ + } else if (prim->isByte()) { \ ((uint32*)buf)[0] = va_arg(ap, uint32);\ - } else if (prim->isBool()){ \ + } else if (prim->isBool()) { \ ((uint32*)buf)[0] = va_arg(ap, uint32);\ - } else if (prim->isFloat()){\ + } else if (prim->isFloat()) {\ ((float*)buf)[0] = (float)va_arg(ap, double);\ - } else if (prim->isDouble()){\ + } else if (prim->isDouble()) {\ ((double*)buf)[0] = va_arg(ap, double);\ - } else{\ + } else {\ fprintf(stderr, "Can't happen");\ abort();\ }\ @@ -94,7 +94,7 @@ } \ verifyNull(obj); \ Signdef* sign = getSignature(); \ - uintptr_t buf = (uintptr_t)alloca(sign->args.size() * sizeof(uint64)); \ + uintptr_t buf = (uintptr_t)alloca(sign->nbArguments * sizeof(uint64)); \ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = (((void***)obj)[0])[offset];\ @@ -109,7 +109,7 @@ \ verifyNull(obj);\ Signdef* sign = getSignature(); \ - uintptr_t buf = (uintptr_t)alloca(sign->args.size() * sizeof(uint64)); \ + uintptr_t buf = (uintptr_t)alloca(sign->nbArguments * sizeof(uint64)); \ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ @@ -123,7 +123,7 @@ } \ \ Signdef* sign = getSignature(); \ - uintptr_t buf = (uintptr_t)alloca(sign->args.size() * sizeof(uint64)); \ + uintptr_t buf = (uintptr_t)alloca(sign->nbArguments * sizeof(uint64)); \ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Thu Dec 11 08:00:46 2008 @@ -23,74 +23,6 @@ using namespace jnjvm; - - -static void typeError(const UTF8* name, short int l) { - if (l != 0) { - JavaThread::get()->getJVM()-> - unknownError("wrong type %d in %s", l, name->printString()); - } else { - JavaThread::get()->getJVM()-> - unknownError("wrong type %s", name->printString()); - } -} - - -static bool analyseIntern(const UTF8* name, uint32 pos, uint32 meth, - uint32& ret) { - short int cur = name->elements[pos]; - switch (cur) { - case I_PARD : - ret = pos + 1; - return true; - case I_BOOL : - ret = pos + 1; - return false; - case I_BYTE : - ret = pos + 1; - return false; - case I_CHAR : - ret = pos + 1; - return false; - case I_SHORT : - ret = pos + 1; - return false; - case I_INT : - ret = pos + 1; - return false; - case I_FLOAT : - ret = pos + 1; - return false; - case I_DOUBLE : - ret = pos + 1; - return false; - case I_LONG : - ret = pos + 1; - return false; - case I_VOID : - ret = pos + 1; - return false; - case I_TAB : - if (meth == 1) { - pos++; - } else { - while (name->elements[++pos] == I_TAB) {} - analyseIntern(name, pos, 1, pos); - } - ret = pos; - return false; - case I_REF : - if (meth != 2) { - while (name->elements[++pos] != I_END_REF) {} - } - ret = pos + 1; - return false; - default : - typeError(name, cur); - } - return false; -} - void PrimitiveTypedef::tPrintBuf(mvm::PrintBuffer* buf) const { prim->name->print(buf); } @@ -119,12 +51,12 @@ return loader->loadName(pseudoAssocClassName, false, true); } -void Typedef::humanPrintArgs(const std::vector* args, - mvm::PrintBuffer* buf) { +void Signdef::humanPrintArgs(mvm::PrintBuffer* buf) const { buf->write("("); - for (uint32 i = 0; i < args->size(); i++) { - args->at(i)->tPrintBuf(buf); - if (i != args->size() - 1) { + Typedef* const* arguments = getArgumentsType(); + for (uint32 i = 0; i < nbArguments; i++) { + arguments[i]->tPrintBuf(buf); + if (i != nbArguments - 1) { buf->write(", "); } } @@ -134,58 +66,41 @@ const char* Signdef::printString() const { mvm::PrintBuffer *buf= mvm::PrintBuffer::alloc(); buf->write("Signature<"); - ret->tPrintBuf(buf); + getReturnType()->tPrintBuf(buf); buf->write("..."); - Typedef::humanPrintArgs(&args, buf); + humanPrintArgs(buf); buf->write(">"); return buf->contents()->cString(); } void Signdef::printWithSign(CommonClass* cl, const UTF8* name, - mvm::PrintBuffer* buf) { - ret->tPrintBuf(buf); + mvm::PrintBuffer* buf) const { + getReturnType()->tPrintBuf(buf); buf->write(" "); CommonClass::printClassName(cl->name, buf); buf->write("::"); name->print(buf); - Typedef::humanPrintArgs(&args, buf); + humanPrintArgs(buf); } -Signdef::Signdef(const UTF8* name, JnjvmClassLoader* loader) { - Signdef* res = this; - std::vector buf; - uint32 len = (uint32)name->size; - uint32 pos = 1; - uint32 pred = 0; - - while (pos < len) { - pred = pos; - bool end = analyseIntern(name, pos, 0, pos); - if (end) break; - else { - buf.push_back(loader->constructType(name->extract(loader->hashUTF8, pred, pos))); - } - } +Signdef::Signdef(const UTF8* name, JnjvmClassLoader* loader, + std::vector& args, Typedef* ret) { - if (pos == len) { - typeError(name, 0); + arguments[0] = ret; + Typedef** myArgs = &(arguments[1]); + nbArguments = args.size(); + uint32 index = 0; + for (std::vector::iterator i = args.begin(), e = args.end(); + i != e; ++i) { + myArgs[index++] = *i; } - - analyseIntern(name, pos, 0, pred); - - if (pred != len) { - typeError(name, 0); - } - - res->args = buf; - res->ret = loader->constructType(name->extract(loader->hashUTF8, pos, pred)); - res->initialLoader = loader; - res->keyName = name; - res->_virtualCallBuf = 0; - res->_staticCallBuf = 0; - res->_virtualCallAP = 0; - res->_staticCallAP = 0; - res->JInfo = 0; + initialLoader = loader; + keyName = name; + JInfo = 0; + _virtualCallBuf = 0; + _staticCallBuf = 0; + _virtualCallAP = 0; + _staticCallAP = 0; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h Thu Dec 11 08:00:46 2008 @@ -76,11 +76,6 @@ /// const UTF8* keyName; - /// humanPrintArgs - Prints the list of typedef in a human readable form. - /// - static void humanPrintArgs(const std::vector*, - mvm::PrintBuffer* buf); - /// tPrintBuf - Prints the name of the class this Typedef represents. /// virtual void tPrintBuf(mvm::PrintBuffer* buf) const = 0; @@ -279,14 +274,6 @@ public: - /// args - The arguments as Typedef of this signature. - /// - std::vector args; - - /// ret - The Typedef return of this signature. - /// - Typedef* ret; - /// initialLoader - The loader that first loaded this typedef. /// JnjvmClassLoader* initialLoader; @@ -302,12 +289,22 @@ /// printWithSign - Print the signature of a method with the method's class /// and name. /// - void printWithSign(CommonClass* cl, const UTF8* name, mvm::PrintBuffer* buf); + void printWithSign(CommonClass* cl, const UTF8* name, + mvm::PrintBuffer* buf) const; /// Signdef - Create a new Signdef. /// - Signdef(const UTF8* name, JnjvmClassLoader* loader); + Signdef(const UTF8* name, JnjvmClassLoader* loader, + std::vector& args, Typedef* ret); + /// operator new - Redefines the new operator of this class to allocate + /// the arguments in the object itself. + /// + void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, + sint32 size) { + return allocator.Allocate(sizeof(Signdef) + size * sizeof(Typedef)); + } + //===----------------------------------------------------------------------===// // @@ -375,6 +372,33 @@ "Invalid concrete type or multiple inheritence for getInfo"); return static_cast(JInfo); } + + /// nbArguments - The number of arguments in the signature. + /// + uint32 nbArguments; + + /// getReturnType - Get the type of the return of this signature. + /// + Typedef* getReturnType() const { + return arguments[0]; + } + + /// getArgumentsType - Get the list of arguments of this signature. + /// + Typedef* const* getArgumentsType() const { + return &(arguments[1]); + } + +private: + /// humanPrintArgs - Prints the list of typedef in a human readable form. + /// + void humanPrintArgs(mvm::PrintBuffer* buf) const; + + /// arguments - The list of arguments of the signature. First is the return + /// type. + /// + Typedef* arguments[1]; + }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Dec 11 08:00:46 2008 @@ -255,6 +255,7 @@ if (isolate->appClassLoader) { isolate = gc_new(Jnjvm)(bootstrapLoader); isolate->memoryLimit = 4000000; + isolate->threadLimit = 10; isolate->parent = I->parent; isolate->CU = this; mvm::Thread* th = mvm::Thread::get(); @@ -601,11 +602,104 @@ return res; } +static void typeError(const UTF8* name, short int l) { + if (l != 0) { + JavaThread::get()->getJVM()-> + unknownError("wrong type %d in %s", l, name->printString()); + } else { + JavaThread::get()->getJVM()-> + unknownError("wrong type %s", name->printString()); + } +} + + +static bool analyseIntern(const UTF8* name, uint32 pos, uint32 meth, + uint32& ret) { + short int cur = name->elements[pos]; + switch (cur) { + case I_PARD : + ret = pos + 1; + return true; + case I_BOOL : + ret = pos + 1; + return false; + case I_BYTE : + ret = pos + 1; + return false; + case I_CHAR : + ret = pos + 1; + return false; + case I_SHORT : + ret = pos + 1; + return false; + case I_INT : + ret = pos + 1; + return false; + case I_FLOAT : + ret = pos + 1; + return false; + case I_DOUBLE : + ret = pos + 1; + return false; + case I_LONG : + ret = pos + 1; + return false; + case I_VOID : + ret = pos + 1; + return false; + case I_TAB : + if (meth == 1) { + pos++; + } else { + while (name->elements[++pos] == I_TAB) {} + analyseIntern(name, pos, 1, pos); + } + ret = pos; + return false; + case I_REF : + if (meth != 2) { + while (name->elements[++pos] != I_END_REF) {} + } + ret = pos + 1; + return false; + default : + typeError(name, cur); + } + return false; +} + Signdef* JnjvmClassLoader::constructSign(const UTF8* name) { javaSignatures->lock.lock(); Signdef* res = javaSignatures->lookup(name); if (res == 0) { - res = new(allocator) Signdef(name, this); + std::vector buf; + uint32 len = (uint32)name->size; + uint32 pos = 1; + uint32 pred = 0; + + while (pos < len) { + pred = pos; + bool end = analyseIntern(name, pos, 0, pos); + if (end) break; + else { + buf.push_back(constructType(name->extract(hashUTF8, pred, pos))); + } + } + + if (pos == len) { + typeError(name, 0); + } + + analyseIntern(name, pos, 0, pred); + + if (pred != len) { + typeError(name, 0); + } + + Typedef* ret = constructType(name->extract(hashUTF8, pos, pred)); + + res = new(allocator, buf.size()) Signdef(name, this, buf, ret); + javaSignatures->hash(name, res); } javaSignatures->lock.unlock(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Thu Dec 11 08:00:46 2008 @@ -739,12 +739,13 @@ // Lock here because we are called by arbitrary code llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector llvmArgs; - unsigned int size = signature->args.size(); + uint32 size = signature->nbArguments; + Typedef* const* arguments = signature->getArgumentsType(); llvmArgs.push_back(JnjvmModule::JavaObjectType); for (uint32 i = 0; i < size; ++i) { - Typedef* type = signature->args.at(i); + Typedef* type = arguments[i]; LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); llvmArgs.push_back(LAI.llvmType); } @@ -753,7 +754,8 @@ llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); + LLVMAssessorInfo& LAI = + JnjvmModule::getTypedefInfo(signature->getReturnType()); virtualType = FunctionType::get(LAI.llvmType, llvmArgs, false); } return virtualType; @@ -764,10 +766,11 @@ // Lock here because we are called by arbitrary code llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector llvmArgs; - unsigned int size = signature->args.size(); + uint32 size = signature->nbArguments; + Typedef* const* arguments = signature->getArgumentsType(); for (uint32 i = 0; i < size; ++i) { - Typedef* type = signature->args.at(i); + Typedef* type = arguments[i]; LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); llvmArgs.push_back(LAI.llvmType); } @@ -776,7 +779,8 @@ llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); + LLVMAssessorInfo& LAI = + JnjvmModule::getTypedefInfo(signature->getReturnType()); staticType = FunctionType::get(LAI.llvmType, llvmArgs, false); } return staticType; @@ -787,13 +791,14 @@ // Lock here because we are called by arbitrary code llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector llvmArgs; - unsigned int size = signature->args.size(); + uint32 size = signature->nbArguments; + Typedef* const* arguments = signature->getArgumentsType(); llvmArgs.push_back(mvm::MvmModule::ptrType); // JNIEnv llvmArgs.push_back(JnjvmModule::JavaObjectType); // Class for (uint32 i = 0; i < size; ++i) { - Typedef* type = signature->args.at(i); + Typedef* type = arguments[i]; LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); llvmArgs.push_back(LAI.llvmType); } @@ -802,7 +807,8 @@ llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); + LLVMAssessorInfo& LAI = + JnjvmModule::getTypedefInfo(signature->getReturnType()); nativeType = FunctionType::get(LAI.llvmType, llvmArgs, false); } return nativeType; @@ -834,11 +840,11 @@ Args.push_back(obj); } ptr = i; - - for (std::vector::iterator i = signature->args.begin(), - e = signature->args.end(); i!= e; ++i) { - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(*i); + Typedef* const* arguments = signature->getArgumentsType(); + for (uint32 i = 0; i < signature->nbArguments; ++i) { + + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(arguments[i]); Value* val = new BitCastInst(ptr, LAI.llvmTypePtr, "", currentBlock); Value* arg = new LoadInst(val, "", currentBlock); Args.push_back(arg); @@ -886,9 +892,9 @@ } ap = i; - for (std::vector::iterator i = signature->args.begin(), - e = signature->args.end(); i!= e; i++) { - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(*i); + Typedef* const* arguments = signature->getArgumentsType(); + for (uint32 i = 0; i < signature->nbArguments; ++i) { + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(arguments[i]); Args.push_back(new VAArgInst(ap, LAI.llvmType, "", currentBlock)); } @@ -937,7 +943,8 @@ Args2.push_back(getVirtualPtrType()); Args2.push_back(JnjvmModule::JavaObjectType); Args2.push_back(JnjvmModule::ptrType); - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); + LLVMAssessorInfo& LAI = + JnjvmModule::getTypedefInfo(signature->getReturnType()); virtualBufType = FunctionType::get(LAI.llvmType, Args2, false); } return virtualBufType; @@ -951,7 +958,8 @@ Args.push_back(JnjvmModule::ConstantPoolType); // ctp Args.push_back(getStaticPtrType()); Args.push_back(JnjvmModule::ptrType); - LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); + LLVMAssessorInfo& LAI = + JnjvmModule::getTypedefInfo(signature->getReturnType()); staticBufType = FunctionType::get(LAI.llvmType, Args, false); } return staticBufType; Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=60876&r1=60875&r2=60876&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Thu Dec 11 08:00:46 2008 @@ -350,14 +350,13 @@ ArrayObject* NativeUtil::getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth) { Jnjvm* vm = JavaThread::get()->getJVM(); - std::vector& args = meth->getSignature()->args; + Signdef* sign = meth->getSignature(); + Typedef* const* arguments = sign->getArgumentsType(); ArrayObject* res = - (ArrayObject*)vm->upcalls->classArrayClass->doNew(args.size(), vm); + (ArrayObject*)vm->upcalls->classArrayClass->doNew(sign->nbArguments, vm); - sint32 index = 0; - for (std::vector::iterator i = args.begin(), e = args.end(); - i != e; ++i, ++index) { - res->elements[index] = getClassType(loader, (*i)); + for (uint32 index = 0; index < sign->nbArguments; ++index) { + res->elements[index] = getClassType(loader, arguments[index]); } return res; From nicolas.geoffray at lip6.fr Thu Dec 11 07:51:53 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 11 Dec 2008 15:51:53 -0000 Subject: [vmkit-commits] [vmkit] r60877 - /vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Message-ID: <200812111551.mBBFpvp9027055@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 11 09:51:30 2008 New Revision: 60877 URL: http://llvm.org/viewvc/llvm-project?rev=60877&view=rev Log: Use gnu.classpath.boot.library.path to set the GNU classpath .so location. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=60877&r1=60876&r2=60877&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Thu Dec 11 09:51:30 2008 @@ -8,7 +8,7 @@ // //===----------------------------------------------------------------------===// -#include +#include #include #include "types.h" @@ -84,7 +84,6 @@ setProperty(vm, prop, "java.vm.vendor", "VVM Project"); setProperty(vm, prop, "java.vm.name", "JnJVM"); setProperty(vm, prop, "java.specification.version", "1.5"); - setProperty(vm, prop, "java.library.path", JCL->libClasspathEnv); setProperty(vm, prop, "java.io.tmpdir", "/tmp"); tmp = getenv("JAVA_COMPILER"); @@ -93,6 +92,8 @@ setProperty(vm, prop, "build.compiler", "gcj"); setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv); + setProperty(vm, prop, "gnu.classpath.boot.library.path", + JCL->libClasspathEnv); setUnameProp(vm, prop); From nicolas.geoffray at lip6.fr Thu Dec 11 09:40:19 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 11 Dec 2008 17:40:19 -0000 Subject: [vmkit-commits] [vmkit] r60882 - /vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Message-ID: <200812111740.mBBHeJX3030729@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 11 11:40:18 2008 New Revision: 60882 URL: http://llvm.org/viewvc/llvm-project?rev=60882&view=rev Log: Doh! Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=60882&r1=60881&r2=60882&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Thu Dec 11 11:40:18 2008 @@ -192,7 +192,7 @@ UserCommonClass* cl = ((JavaObjectClass*)clazz)->getClass(); if (cl->asClass()) { cl->asClass()->resolveClass(); - cl->asClass()->initialiseClass(vm); + if (doClinit) cl->asClass()->initialiseClass(vm); } return cl; } From nicolas.geoffray at lip6.fr Thu Dec 11 11:59:12 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 11 Dec 2008 19:59:12 -0000 Subject: [vmkit-commits] [vmkit] r60893 - /vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Message-ID: <200812111959.mBBJxCVa003906@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 11 13:59:11 2008 New Revision: 60893 URL: http://llvm.org/viewvc/llvm-project?rev=60893&view=rev Log: Fomato. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=60893&r1=60892&r2=60893&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Thu Dec 11 13:59:11 2008 @@ -47,7 +47,7 @@ } } -JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit( +JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit( #ifdef NATIVE_JNI JNIEnv *env, jclass clazz, From nicolas.geoffray at lip6.fr Thu Dec 11 12:00:27 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 11 Dec 2008 20:00:27 -0000 Subject: [vmkit-commits] [vmkit] r60894 - /vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Message-ID: <200812112000.mBBK0RPN004006@zion.cs.uiuc.edu> Author: geoffray Date: Thu Dec 11 14:00:27 2008 New Revision: 60894 URL: http://llvm.org/viewvc/llvm-project?rev=60894&view=rev Log: Implement these ones. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=60894&r1=60893&r2=60894&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Thu Dec 11 14:00:27 2008 @@ -2163,14 +2163,18 @@ void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy) { - assert(0 && "implement me"); + BEGIN_EXCEPTION + + if (isCopy) (*isCopy) = false; + return ((JavaArray*)array)->elements; + + END_EXCEPTION return 0; } void ReleasePrimitiveArrayCritical(JNIEnv *env, jarray array, void *carray, jint mode) { - assert(0 && "implement me"); } From nicolas.geoffray at lip6.fr Fri Dec 12 00:25:27 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 12 Dec 2008 08:25:27 -0000 Subject: [vmkit-commits] [vmkit] r60946 - /vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Message-ID: <200812120825.mBC8PRxf027084@zion.cs.uiuc.edu> Author: geoffray Date: Fri Dec 12 02:25:27 2008 New Revision: 60946 URL: http://llvm.org/viewvc/llvm-project?rev=60946&view=rev Log: Use these functions instead. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=60946&r1=60945&r2=60946&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Fri Dec 12 02:25:27 2008 @@ -2113,14 +2113,11 @@ return 0; } -extern "C" void JavaObjectAquire(JavaObject* obj); -extern "C" void JavaObjectRelease(JavaObject* obj); - jint MonitorEnter(JNIEnv *env, jobject obj) { BEGIN_EXCEPTION - JavaObjectAquire(((JavaObject*)obj)); + ((JavaObject*)obj)->acquire(); return 1; END_EXCEPTION @@ -2132,7 +2129,7 @@ BEGIN_EXCEPTION - JavaObjectRelease((JavaObject*)obj); + ((JavaObject*)obj)->release(); return 1; END_EXCEPTION From nicolas.geoffray at lip6.fr Fri Dec 12 00:27:09 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 12 Dec 2008 08:27:09 -0000 Subject: [vmkit-commits] [vmkit] r60948 - /vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Message-ID: <200812120827.mBC8R9MZ027151@zion.cs.uiuc.edu> Author: geoffray Date: Fri Dec 12 02:27:08 2008 New Revision: 60948 URL: http://llvm.org/viewvc/llvm-project?rev=60948&view=rev Log: Add an assert. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=60948&r1=60947&r2=60948&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Fri Dec 12 02:27:08 2008 @@ -47,6 +47,7 @@ const UTF8* JavaString::strToUTF8(Jnjvm* vm) { const UTF8* utf8 = this->value; + assert(utf8 && "String without an UTF8?"); if (offset || (offset + count <= utf8->size)) { return utf8->extract(vm, offset, offset + count); } else { From nicolas.geoffray at lip6.fr Fri Dec 12 01:13:30 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 12 Dec 2008 09:13:30 -0000 Subject: [vmkit-commits] [vmkit] r60949 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.h JnjvmModule.cpp NativeUtil.cpp Message-ID: <200812120913.mBC9DVCg002387@zion.cs.uiuc.edu> Author: geoffray Date: Fri Dec 12 03:13:29 2008 New Revision: 60949 URL: http://llvm.org/viewvc/llvm-project?rev=60949&view=rev Log: Correct implementation of name mangling in JNI. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=60949&r1=60948&r2=60949&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Dec 12 03:13:29 2008 @@ -1002,8 +1002,7 @@ /// jniConsFromMeth - Construct the JNI name of this method. /// void jniConsFromMeth(char* buf) const; - void jniConsFromMeth2(char* buf) const; - void jniConsFromMeth3(char* buf) const; + void jniConsFromMethOverloaded(char* buf) const; //===----------------------------------------------------------------------===// Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=60949&r1=60948&r2=60949&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Dec 12 03:13:29 2008 @@ -681,9 +681,9 @@ sint32 mnlen = jniConsName->size; sint32 mtlen = jniConsType->size; - char* buf = - (char*)alloca(3 + JNI_NAME_PRE_LEN + mnlen + clen + (mtlen << 1)); - methodDef->jniConsFromMeth3(buf); + char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + + ((mnlen + clen + mtlen) << 1)); + methodDef->jniConsFromMethOverloaded(buf); methodFunction = Function::Create(getFunctionType(), GlobalValue::GhostLinkage, buf, Mod); Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=60949&r1=60948&r2=60949&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Fri Dec 12 03:13:29 2008 @@ -44,39 +44,11 @@ for (sint32 i =0; i < clen; ++i) { cur = jniConsClName->elements[i]; if (cur == '/') ptr[0] = '_'; - else ptr[0] = (uint8)cur; - ++ptr; - } - - ptr[0] = '_'; - ++ptr; - - for (sint32 i =0; i < mnlen; ++i) { - cur = jniConsName->elements[i]; - if (cur == '/') ptr[0] = '_'; - else ptr[0] = (uint8)cur; - ++ptr; - } - - ptr[0] = 0; - - -} - -void JavaMethod::jniConsFromMeth2(char* buf) const { - const UTF8* jniConsClName = classDef->name; - const UTF8* jniConsName = name; - sint32 clen = jniConsClName->size; - sint32 mnlen = jniConsName->size; - - uint32 cur = 0; - char* ptr = &(buf[JNI_NAME_PRE_LEN]); - - memcpy(buf, JNI_NAME_PRE, JNI_NAME_PRE_LEN); - - for (sint32 i =0; i < clen; ++i) { - cur = jniConsClName->elements[i]; - if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } else ptr[0] = (uint8)cur; ++ptr; } @@ -101,7 +73,7 @@ } -void JavaMethod::jniConsFromMeth3(char* buf) const { +void JavaMethod::jniConsFromMethOverloaded(char* buf) const { const UTF8* jniConsClName = classDef->name; const UTF8* jniConsName = name; const UTF8* jniConsType = type; @@ -116,6 +88,11 @@ for (sint32 i =0; i < clen; ++i) { cur = jniConsClName->elements[i]; if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } else ptr[0] = (uint8)cur; ++ptr; } @@ -126,6 +103,11 @@ for (sint32 i =0; i < mnlen; ++i) { cur = jniConsName->elements[i]; if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } else ptr[0] = (uint8)cur; ++ptr; } @@ -165,7 +147,8 @@ } -intptr_t NativeUtil::nativeLookup(CommonClass* cl, JavaMethod* meth, bool& jnjvm) { +intptr_t NativeUtil::nativeLookup(CommonClass* cl, JavaMethod* meth, + bool& jnjvm) { const UTF8* jniConsClName = cl->name; const UTF8* jniConsName = meth->name; const UTF8* jniConsType = meth->type; @@ -173,16 +156,13 @@ sint32 mnlen = jniConsName->size; sint32 mtlen = jniConsType->size; - char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + mnlen + clen + (mtlen << 1)); + char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + + ((mnlen + clen + mtlen) << 1)); meth->jniConsFromMeth(buf); intptr_t res = cl->classLoader->loadInLib(buf, jnjvm); if (!res) { - meth->jniConsFromMeth2(buf); + meth->jniConsFromMethOverloaded(buf); res = cl->classLoader->loadInLib(buf, jnjvm); - if (!res) { - meth->jniConsFromMeth3(buf); - res = cl->classLoader->loadInLib(buf, jnjvm); - } } return res; } From nicolas.geoffray at lip6.fr Fri Dec 12 02:07:19 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 12 Dec 2008 10:07:19 -0000 Subject: [vmkit-commits] [vmkit] r60950 - /vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Message-ID: <200812121007.mBCA7MX6007745@zion.cs.uiuc.edu> Author: geoffray Date: Fri Dec 12 04:06:59 2008 New Revision: 60950 URL: http://llvm.org/viewvc/llvm-project?rev=60950&view=rev Log: Implement some missing JNI functions. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=60950&r1=60949&r2=60950&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Fri Dec 12 04:06:59 2008 @@ -209,8 +209,7 @@ jboolean IsSameObject(JNIEnv *env, jobject ref1, jobject ref2) { - assert(0 && "implement me"); - return 0; + return ref1 == ref2; } @@ -358,9 +357,19 @@ } -jobject CallObjectMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jobject CallObjectMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jobject)meth->invokeJavaObjectVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -391,9 +400,19 @@ } -jboolean CallBooleanMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jboolean CallBooleanMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jboolean)meth->invokeIntVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -410,9 +429,19 @@ return 0; } -jbyte CallByteMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jbyte CallByteMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jbyte)meth->invokeIntVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -430,9 +459,19 @@ } -jchar CallCharMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jchar CallCharMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jchar)meth->invokeIntVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -450,9 +489,19 @@ } -jshort CallShortMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jshort CallShortMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jshort)meth->invokeIntVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -484,9 +533,19 @@ } -jint CallIntMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jint CallIntMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jint)meth->invokeIntVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -505,9 +564,19 @@ } -jlong CallLongMethodV(JNIEnv *env, jobject obj, jmethodID methodID, +jlong CallLongMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jlong)meth->invokeLongVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + return 0; } @@ -541,8 +610,18 @@ jfloat CallFloatMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - assert(0 && "implement me"); - return 0; + + BEGIN_EXCEPTION + + JavaObject* obj = (JavaObject*)_obj; + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); + return (jfloat)meth->invokeFloatVirtualAP(vm, cl, obj, args); + + END_EXCEPTION + + return 0.0f; } @@ -582,7 +661,7 @@ JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); - return meth->invokeDoubleVirtualAP(vm, cl, obj, args); + return (jdouble)meth->invokeDoubleVirtualAP(vm, cl, obj, args); END_EXCEPTION return 0.0; @@ -869,12 +948,11 @@ BEGIN_EXCEPTION - // TODO: find a better place to store the UTF8 Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); return (jfieldID) (cl->asClass() ? - cl->asClass()->lookupField(cl->classLoader->asciizConstructUTF8(name), - cl->classLoader->asciizConstructUTF8(sig), 0, 1, + cl->asClass()->lookupField(vm->asciizToUTF8(name), + vm->asciizToUTF8(sig), 0, 1, 0) : 0); END_EXCEPTION @@ -1128,15 +1206,35 @@ } -jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); +jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, + ...) { + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jobject res = (jobject) meth->invokeJavaObjectStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION return 0; } jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jobject)meth->invokeJavaObjectStaticAP(vm, cl, args); + + END_EXCEPTION return 0; } @@ -1169,7 +1267,15 @@ jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jboolean)meth->invokeIntStaticAP(vm, cl, args); + + END_EXCEPTION return 0; } @@ -1182,14 +1288,34 @@ jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jbyte res = (jbyte) meth->invokeIntStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION return 0; } jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jbyte)meth->invokeIntStaticAP(vm, cl, args); + + END_EXCEPTION return 0; } @@ -1202,14 +1328,33 @@ jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jchar res = (jchar) meth->invokeIntStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION return 0; } jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jchar)meth->invokeIntStaticAP(vm, cl, args); + + END_EXCEPTION return 0; } @@ -1223,14 +1368,34 @@ jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jshort res = (jshort) meth->invokeIntStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION return 0; } jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jshort)meth->invokeIntStaticAP(vm, cl, args); + + END_EXCEPTION return 0; } @@ -1243,14 +1408,34 @@ jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jint res = (jint) meth->invokeIntStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION return 0; } jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jint)meth->invokeIntStaticAP(vm, cl, args); + + END_EXCEPTION + return 0; } @@ -1263,14 +1448,35 @@ jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jlong res = (jlong) meth->invokeLongStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION return 0; } jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); + + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jlong)meth->invokeLongStaticAP(vm, cl, args); + + END_EXCEPTION + return 0; } @@ -1285,15 +1491,36 @@ jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); - return 0; + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jfloat res = (jfloat) meth->invokeFloatStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION + return 0.0f; } jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); - return 0; + + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jfloat)meth->invokeFloatStaticAP(vm, cl, args); + + END_EXCEPTION + + return 0.0f; } @@ -1306,15 +1533,35 @@ jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - assert(0 && "implement me"); - return 0; + + BEGIN_EXCEPTION + + va_list ap; + va_start(ap, methodID); + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + jdouble res = (jdouble) meth->invokeDoubleStaticAP(vm, cl, ap); + va_end(ap); + return res; + + END_EXCEPTION + return 0.0; } jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - assert(0 && "implement me"); - return 0; + BEGIN_EXCEPTION + + JavaMethod* meth = (JavaMethod*)methodID; + Jnjvm* vm = JavaThread::get()->getJVM(); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); + return (jdouble)meth->invokeDoubleStaticAP(vm, cl, args); + + END_EXCEPTION + + return 0.0; } @@ -1366,12 +1613,11 @@ BEGIN_EXCEPTION - // TODO: find a better place to store the UTF8 Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); return (jfieldID) (cl->asClass() ? - cl->asClass()->lookupField(cl->classLoader->asciizConstructUTF8(name), - cl->classLoader->asciizConstructUTF8(sig), + cl->asClass()->lookupField(vm->asciizToUTF8(name), + vm->asciizToUTF8(sig), true, true, 0) : 0); END_EXCEPTION @@ -2007,97 +2253,113 @@ void GetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start, jsize len, jboolean *buf) { - assert(0 && "implement me"); + ArrayUInt8* Array = (ArrayUInt8*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(uint8)); } void GetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len, jbyte *buf) { - assert(0 && "implement me"); + ArraySInt8* Array = (ArraySInt8*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(sint8)); } void GetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len, jchar *buf) { - assert(0 && "implement me"); + ArrayUInt16* Array = (ArrayUInt16*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(uint16)); } void GetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start, jsize len, jshort *buf) { - assert(0 && "implement me"); + ArraySInt16* Array = (ArraySInt16*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(sint16)); } void GetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len, jint *buf) { - assert(0 && "implement me"); + ArraySInt32* Array = (ArraySInt32*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(sint32)); } void GetLongArrayRegion(JNIEnv *env, jlongArray array, jsize start, jsize len, jlong *buf) { - assert(0 && "implement me"); + ArrayLong* Array = (ArrayLong*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(sint64)); } void GetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start, jsize len, jfloat *buf) { - assert(0 && "implement me"); + ArrayFloat* Array = (ArrayFloat*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(float)); } void GetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start, jsize len, jdouble *buf) { - assert(0 && "implement me"); + ArrayDouble* Array = (ArrayDouble*)array; + memcpy(buf, &(Array->elements[start]), len * sizeof(double)); } void SetBooleanArrayRegion(JNIEnv *env, jbooleanArray array, jsize start, jsize len, const jboolean *buf) { - assert(0 && "implement me"); + ArrayUInt8* Array = (ArrayUInt8*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(uint8)); } void SetByteArrayRegion(JNIEnv *env, jbyteArray array, jsize start, jsize len, const jbyte *buf) { - assert(0 && "implement me"); + ArraySInt8* Array = (ArraySInt8*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(sint8)); } void SetCharArrayRegion(JNIEnv *env, jcharArray array, jsize start, jsize len, const jchar *buf) { - assert(0 && "implement me"); + ArrayUInt16* Array = (ArrayUInt16*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(uint16)); } void SetShortArrayRegion(JNIEnv *env, jshortArray array, jsize start, jsize len, const jshort *buf) { - assert(0 && "implement me"); + ArraySInt16* Array = (ArraySInt16*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(sint16)); } void SetIntArrayRegion(JNIEnv *env, jintArray array, jsize start, jsize len, const jint *buf) { - assert(0 && "implement me"); + ArraySInt32* Array = (ArraySInt32*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(sint32)); } void SetLongArrayRegion(JNIEnv* env, jlongArray array, jsize start, jsize len, const jlong *buf) { - assert(0 && "implement me"); + ArrayLong* Array = (ArrayLong*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(sint64)); } void SetFloatArrayRegion(JNIEnv *env, jfloatArray array, jsize start, jsize len, const jfloat *buf) { - assert(0 && "implement me"); + ArrayFloat* Array = (ArrayFloat*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(float)); } void SetDoubleArrayRegion(JNIEnv *env, jdoubleArray array, jsize start, jsize len, const jdouble *buf) { - assert(0 && "implement me"); + ArrayDouble* Array = (ArrayDouble*)array; + memcpy(&(Array->elements[start]), buf, len * sizeof(double)); } From nicolas.geoffray at lip6.fr Sat Dec 13 06:47:56 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 13 Dec 2008 14:47:56 -0000 Subject: [vmkit-commits] [vmkit] r60980 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Message-ID: <200812131447.mBDEluwj010617@zion.cs.uiuc.edu> Author: geoffray Date: Sat Dec 13 08:47:54 2008 New Revision: 60980 URL: http://llvm.org/viewvc/llvm-project?rev=60980&view=rev Log: TABLEDWITCH work on signed values. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=60980&r1=60979&r2=60980&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Sat Dec 13 08:47:54 2008 @@ -1684,13 +1684,13 @@ i += filled; BasicBlock* def = opcodeInfos[tmp + readU4(bytecodes, i)].newBlock; - uint32 low = readU4(bytecodes, i); - uint32 high = readU4(bytecodes, i) + 1; + sint32 low = readS4(bytecodes, i); + sint32 high = readS4(bytecodes, i) + 1; Value* index = pop(); const llvm::Type* type = index->getType(); - for (uint32 cur = low; cur < high; ++cur) { + for (sint32 cur = low; cur < high; ++cur) { Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, ConstantInt::get(type, cur), index, "", currentBlock); From nicolas.geoffray at lip6.fr Mon Dec 15 15:29:42 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 15 Dec 2008 23:29:42 -0000 Subject: [vmkit-commits] [vmkit] r61057 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200812152329.mBFNTgMh005338@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 15 17:29:38 2008 New Revision: 61057 URL: http://llvm.org/viewvc/llvm-project?rev=61057&view=rev Log: Don't forget to erase the replaced instruction. Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=61057&r1=61056&r2=61057&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Mon Dec 15 17:29:38 2008 @@ -161,6 +161,7 @@ Cmp->getOperand(0) == F.arg_begin()) { Changed = true; Cmp->replaceAllUsesWith(ConstantInt::getFalse()); + Cmp->eraseFromParent(); break; } } From nicolas.geoffray at lip6.fr Tue Dec 16 07:54:53 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 16 Dec 2008 15:54:53 -0000 Subject: [vmkit-commits] [vmkit] r61089 - /vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Message-ID: <200812161554.mBGFsr9u014684@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 16 09:54:46 2008 New Revision: 61089 URL: http://llvm.org/viewvc/llvm-project?rev=61089&view=rev Log: Implement putObjectVolatile. Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=61089&r1=61088&r2=61089&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Tue Dec 16 09:54:46 2008 @@ -252,4 +252,18 @@ return __sync_bool_compare_and_swap(ptr, expect, update); } +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile( +#ifdef NATIVE_JNI +JNIEnv *env, +#endif +jobject unsafe, jobject obj, jlong offset, jobject value) { + + jobject *ptr; + + ptr = (jobject *) (((uint8 *) obj) + offset); + + *ptr = value; + +} + } From nicolas.geoffray at lip6.fr Wed Dec 17 00:46:00 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 17 Dec 2008 09:46:00 +0100 Subject: [vmkit-commits] [vmkit] r60980 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp In-Reply-To: <200812131447.mBDEluwj010617@zion.cs.uiuc.edu> References: <200812131447.mBDEluwj010617@zion.cs.uiuc.edu> Message-ID: <4948BC48.2050201@lip6.fr> Note: this patch makes the _222_mpegaudio benchmark work with vmkit. Nicolas Geoffray wrote: > Author: geoffray > Date: Sat Dec 13 08:47:54 2008 > New Revision: 60980 > > URL: http://llvm.org/viewvc/llvm-project?rev=60980&view=rev > Log: > TABLEDWITCH work on signed values. > > > Modified: > vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp > > Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp > URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=60980&r1=60979&r2=60980&view=diff > > ============================================================================== > --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) > +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Sat Dec 13 08:47:54 2008 > @@ -1684,13 +1684,13 @@ > i += filled; > BasicBlock* def = opcodeInfos[tmp + readU4(bytecodes, i)].newBlock; > > - uint32 low = readU4(bytecodes, i); > - uint32 high = readU4(bytecodes, i) + 1; > + sint32 low = readS4(bytecodes, i); > + sint32 high = readS4(bytecodes, i) + 1; > > Value* index = pop(); > > const llvm::Type* type = index->getType(); > - for (uint32 cur = low; cur < high; ++cur) { > + for (sint32 cur = low; cur < high; ++cur) { > Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, > ConstantInt::get(type, cur), index, > "", currentBlock); > > > _______________________________________________ > vmkit-commits mailing list > vmkit-commits at cs.uiuc.edu > http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits > From nicolas.geoffray at lip6.fr Wed Dec 17 02:16:43 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 17 Dec 2008 10:16:43 -0000 Subject: [vmkit-commits] [vmkit] r61130 - /vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Message-ID: <200812171016.mBHAGmL0024714@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 17 04:16:18 2008 New Revision: 61130 URL: http://llvm.org/viewvc/llvm-project?rev=61130&view=rev Log: Add "C" functions for external VTs. Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=61130&r1=61129&r2=61130&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Wed Dec 17 04:16:18 2008 @@ -54,6 +54,21 @@ if (l) l->MARK_AND_TRACE; } +#ifdef MULTIPLE_GC +extern "C" void ArrayObjectTracer(ArrayObject* obj, Collector* GC) { +#else +extern "C" void ArrayObjectTracer(ArrayObject* obj) { +#endif + obj->CALL_TRACER; +} + +#ifdef MULTIPLE_GC +extern "C" void JavaArrayTracer(JavaArray* obj, Collector* GC) { +#else +extern "C" void JavaArrayTracer(JavaArray* obj) { +#endif +} + void JavaArray::TRACER {} #define TRACE_VECTOR(type,alloc,name) { \ From nicolas.geoffray at lip6.fr Wed Dec 17 02:17:38 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 17 Dec 2008 10:17:38 -0000 Subject: [vmkit-commits] [vmkit] r61131 - /vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Message-ID: <200812171017.mBHAHeTc024779@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 17 04:17:32 2008 New Revision: 61131 URL: http://llvm.org/viewvc/llvm-project?rev=61131&view=rev Log: Cleanup. Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=61131&r1=61130&r2=61131&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Wed Dec 17 04:17:32 2008 @@ -101,12 +101,7 @@ lock.unlock(); } - - virtual void print(mvm::PrintBuffer* buf) const { - buf->write("Hashtable<>"); - } - - virtual ~LockedMap() {} + ~LockedMap() {} }; class UTF8Map : public mvm::PermanentObject { From nicolas.geoffray at lip6.fr Wed Dec 17 05:47:41 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 17 Dec 2008 13:47:41 -0000 Subject: [vmkit-commits] [vmkit] r61132 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JavaJIT.h JavaJITOpcodes.cpp LowerConstantCalls.cpp Message-ID: <200812171347.mBHDlh2b002632@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 17 07:47:32 2008 New Revision: 61132 URL: http://llvm.org/viewvc/llvm-project?rev=61132&view=rev Log: Testing on ConstantExpr in the lower constant calls pass could not be used by the static compiler, so move the optimizations directly into the JIT. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61132&r1=61131&r2=61132&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Dec 17 07:47:32 2008 @@ -985,7 +985,7 @@ #ifdef ISOLATE_SHARING // We're dealing with exceptions, don't catch the exception if the class can // not be found. - if (cur->catche) cl = getResolvedClass(cur->catche, false, false); + if (cur->catche) cl = getResolvedClass(cur->catche, false, false, 0); else cl = CallInst::Create(module->GetJnjvmExceptionClassFunction, isolateLocal, "", currentBlock); #else @@ -1168,20 +1168,17 @@ push(ConstantFP::get(Type::FloatTy, ctpInfo->FloatAt(index)), false); } else if (type == JavaConstantPool::ConstantClass) { -#if !defined(ISOLATE) - if (ctpInfo->ctpRes[index]) { - CommonClass* cl = (CommonClass*)(ctpInfo->ctpRes[index]); - Value* Val = module->getJavaClass(cl, currentBlock); - push(Val, false); - } else { -#endif - Value* val = getResolvedCommonClass(index, false); - Value* res = CallInst::Create(module->GetClassDelegateeFunction, - val, "", currentBlock); - push(res, false); -#if !defined(ISOLATE) - } + UserCommonClass* cl = 0; + Value* res = getResolvedCommonClass(index, false, &cl); + +#ifndef ISOLATE + if (cl) res = module->getJavaClass(cl, currentBlock); + else #endif + + res = CallInst::Create(module->GetClassDelegateeFunction, res, "", + currentBlock); + push(res, false); } else { JavaThread::get()->getJVM()->unknownError("unknown type %d", type); } @@ -1599,8 +1596,9 @@ if (module->isStaticCompiling()) { #endif uint32 clIndex = ctpInfo->getClassIndexFromMethod(index); - Value* Cl = getResolvedClass(clIndex, true); - if (!meth || needsInitialisationCheck(meth->classDef, compilingClass)) { + UserClass* cl = 0; + Value* Cl = getResolvedClass(clIndex, true, true, &cl); + if (!meth || (cl && needsInitialisationCheck(cl, compilingClass))) { CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", currentBlock); } @@ -1669,12 +1667,14 @@ return res; } -Value* JavaJIT::getResolvedCommonClass(uint16 index, bool doThrow) { +Value* JavaJIT::getResolvedCommonClass(uint16 index, bool doThrow, + UserCommonClass** alreadyResolved) { JavaConstantPool* ctpInfo = compilingClass->ctpInfo; CommonClass* cl = ctpInfo->getMethodClassIfLoaded(index); Value* node = 0; if (cl && (!cl->isClass() || cl->asClass()->isResolved())) { + if (alreadyResolved) *alreadyResolved = cl; node = module->getNativeClass(cl, currentBlock); if (node->getType() != module->JavaCommonClassType) { node = new BitCastInst(node, module->JavaCommonClassType, "", @@ -1688,12 +1688,14 @@ return node; } -Value* JavaJIT::getResolvedClass(uint16 index, bool clinit, bool doThrow) { +Value* JavaJIT::getResolvedClass(uint16 index, bool clinit, bool doThrow, + Class** alreadyResolved) { JavaConstantPool* ctpInfo = compilingClass->ctpInfo; Class* cl = (Class*)(ctpInfo->getMethodClassIfLoaded(index)); Value* node = 0; if (cl && cl->isResolved()) { + if (alreadyResolved) (*alreadyResolved) = cl; node = module->getNativeClass(cl, currentBlock); } else { node = getConstantPoolAt(index, module->ClassLookupFunction, @@ -1713,11 +1715,22 @@ void JavaJIT::invokeNew(uint16 index) { - Value* Cl = getResolvedClass(index, true); - Value* Size = CallInst::Create(module->GetObjectSizeFromClassFunction, Cl, - "", currentBlock); - Value* VT = CallInst::Create(module->GetVTFromClassFunction, Cl, "", - currentBlock); + Class* cl = 0; + Value* Cl = getResolvedClass(index, true, true, &cl); + + Value* VT = 0; + Value* Size = 0; + + if (cl) { + VT = module->getVirtualTable(cl, currentBlock); + LLVMClassInfo* LCI = module->getClassInfo(cl); + Size = LCI->getVirtualSize(); + } else { + VT = CallInst::Create(module->GetVTFromClassFunction, Cl, "", + currentBlock); + Size = CallInst::Create(module->GetObjectSizeFromClassFunction, Cl, + "", currentBlock); + } Value* val = invoke(module->JavaObjectAllocateFunction, Size, VT, "", currentBlock); @@ -1775,12 +1788,23 @@ if (stat) { type = LCI->getStaticType(); Value* Cl = module->getNativeClass(field->classDef, currentBlock); - if (needsInitialisationCheck(field->classDef, compilingClass)) { + bool needsCheck = needsInitialisationCheck(field->classDef, + compilingClass); + if (needsCheck) { Cl = invoke(module->InitialisationCheckFunction, Cl, "", currentBlock); } +#if !defined(ISOLATE) && !defined(ISOLATE_SHARING) + if (needsCheck) { + CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", + currentBlock); + } + + object = module->getStaticInstance(field->classDef, currentBlock); +#else object = CallInst::Create(module->GetStaticInstanceFunction, Cl, "", currentBlock); +#endif } else { type = LCI->getVirtualType(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=61132&r1=61131&r2=61132&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Wed Dec 17 07:47:32 2008 @@ -214,8 +214,10 @@ llvm::Value* ldResolved(uint16 index, bool stat, llvm::Value* object, const llvm::Type* fieldType, const llvm::Type* fieldTypePtr); - llvm::Value* getResolvedClass(uint16 index, bool clinit, bool doThrow = true); - llvm::Value* getResolvedCommonClass(uint16 index, bool doThrow = true); + llvm::Value* getResolvedClass(uint16 index, bool clinit, bool doThrow, + UserClass** alreadyResolved); + llvm::Value* getResolvedCommonClass(uint16 index, bool doThrow, + UserCommonClass** alreadyResolved); // methods invoke void makeArgs(llvm::FunctionType::param_iterator it, Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=61132&r1=61131&r2=61132&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Wed Dec 17 07:47:32 2008 @@ -1851,12 +1851,24 @@ TheVT = module->getPrimitiveArrayVT(currentBlock); } else { uint16 index = readU2(bytecodes, i); - valCl = getResolvedCommonClass(index); - const llvm::Type* Ty = - PointerType::getUnqual(module->JavaCommonClassType); - Value* args[2]= { valCl, Constant::getNullValue(Ty) }; - valCl = CallInst::Create(module->GetArrayClassFunction, args, - args + 2, "", currentBlock); + CommonClass* cl = 0; + valCl = getResolvedCommonClass(index, true, &cl); + + if (cl) { + JnjvmClassLoader* JCL = cl->classLoader; + const UTF8* arrayName = JCL->constructArrayName(1, cl->name); + + UserCommonClass* dcl = JCL->constructArray(arrayName); + valCl = module->getNativeClass(dcl, currentBlock); + + } else { + const llvm::Type* Ty = + PointerType::getUnqual(module->JavaCommonClassType); + Value* args[2]= { valCl, Constant::getNullValue(Ty) }; + valCl = CallInst::Create(module->GetArrayClassFunction, args, + args + 2, "", currentBlock); + } + sizeElement = module->constantPtrSize; TheVT = module->getReferenceArrayVT(currentBlock); } @@ -1975,52 +1987,132 @@ break; } - case CHECKCAST : { - uint16 index = readU2(bytecodes, i); + case CHECKCAST : + case INSTANCEOF : { - Value* obj = top(); + bool checkcast = (bytecodes[i] == CHECKCAST); + + BasicBlock* exceptionCheckcast = 0; + BasicBlock* endCheckcast = 0; + Value* result = 0; + uint16 index = readU2(bytecodes, i); + UserCommonClass* cl = 0; + Value* clVar = getResolvedCommonClass(index, true, &cl); + Value* obj = top(); + Value* args[2] = { obj, clVar }; Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, obj, module->JavaObjectNullConstant, "", currentBlock); - BasicBlock* ifTrue = createBasicBlock("null checkcast"); - BasicBlock* ifFalse = createBasicBlock("non null checkcast"); + if (checkcast) { + exceptionCheckcast = createBasicBlock("false checkcast"); - BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); - currentBlock = ifFalse; - Value* clVar = getResolvedCommonClass(index); - Value* args[2] = { obj, clVar }; - Value* call = CallInst::Create(module->InstanceOfFunction, args, - args + 2, "", currentBlock); + endCheckcast = createBasicBlock("null checkcast"); + BasicBlock* ifFalse = createBasicBlock("non null checkcast"); + + BranchInst::Create(endCheckcast, ifFalse, cmp, currentBlock); + + if (currentExceptionBlock != endExceptionBlock) { + InvokeInst::Create(module->ClassCastExceptionFunction, + unifiedUnreachable, + currentExceptionBlock, args, args + 2, "", + exceptionCheckcast); + } else { + CallInst::Create(module->ClassCastExceptionFunction, + args, args + 2, "", exceptionCheckcast); + new UnreachableInst(exceptionCheckcast); + } + currentBlock = ifFalse; + } - BasicBlock* ex = createBasicBlock("false checkcast"); - BranchInst::Create(ifTrue, ex, call, currentBlock); + if (cl) { + + BasicBlock* ifTrue = createBasicBlock("true type compare"); + BasicBlock* ifFalse = createBasicBlock("false type compare"); + BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); + PHINode* node = PHINode::Create(Type::Int1Ty, "", ifTrue); + node->addIncoming(ConstantInt::getFalse(), currentBlock); + Value* objCl = CallInst::Create(module->GetClassFunction, obj, "", + ifFalse); + Value* classArgs[2] = { objCl, clVar }; + + if (isInterface(cl->access)) { + Value* res = CallInst::Create(module->ImplementsFunction, + classArgs, classArgs + 2, "", + ifFalse); + node->addIncoming(res, ifFalse); + BranchInst::Create(ifTrue, ifFalse); + } else { + cmp = new ICmpInst(ICmpInst::ICMP_EQ, objCl, clVar, "", ifFalse); + BasicBlock* notEquals = createBasicBlock("false compare"); + BranchInst::Create(ifTrue, notEquals, cmp, ifFalse); + node->addIncoming(ConstantInt::getTrue(), ifFalse); + + if (cl->isPrimitive()) { + fprintf(stderr, "implement me"); + abort(); + } else if (cl->isArray()) { + Value* res = + CallInst::Create(module->InstantiationOfArrayFunction, + classArgs, classArgs + 2, "", notEquals); + node->addIncoming(res, notEquals); + BranchInst::Create(ifTrue, notEquals); + } else { + Value* depthCl; + if (cl->asClass()->isResolved()) { + depthCl = ConstantInt::get(Type::Int32Ty, cl->depth); + } else { + depthCl = CallInst::Create(module->GetDepthFunction, + clVar, "", notEquals); + } + + Value* depthClObj = CallInst::Create(module->GetDepthFunction, + objCl, "", notEquals); + Value* cmp = new ICmpInst(ICmpInst::ICMP_ULE, depthCl, depthClObj, + "", notEquals); + + BasicBlock* supDepth = createBasicBlock("superior depth"); + + BranchInst::Create(supDepth, ifTrue, cmp, notEquals); + node->addIncoming(ConstantInt::getFalse(), notEquals); + + Value* inDisplay = CallInst::Create(module->GetDisplayFunction, + objCl, "", supDepth); + + Value* displayArgs[2] = { inDisplay, depthCl }; + Value* clInDisplay = + CallInst::Create(module->GetClassInDisplayFunction, displayArgs, + displayArgs + 2, "", supDepth); + + cmp = new ICmpInst(ICmpInst::ICMP_EQ, clInDisplay, clVar, "", + supDepth); + BranchInst::Create(ifTrue, supDepth); + + node->addIncoming(cmp, supDepth); + } + } + + currentBlock = ifTrue; + result = node; - if (currentExceptionBlock != endExceptionBlock) { - InvokeInst::Create(module->ClassCastExceptionFunction, - unifiedUnreachable, - currentExceptionBlock, args, args + 2, "", ex); } else { - CallInst::Create(module->ClassCastExceptionFunction, - args, args + 2, "", ex); - new UnreachableInst(ex); + result = CallInst::Create(module->InstanceOfFunction, args, + args + 2, "", currentBlock); + + } + + if (checkcast) { + BranchInst::Create(endCheckcast, exceptionCheckcast, result, + currentBlock); + currentBlock = endCheckcast; + } else { + pop(); + push(new ZExtInst(result, Type::Int32Ty, "", currentBlock), + false); } - - currentBlock = ifTrue; - break; - } - case INSTANCEOF : { - uint16 index = readU2(bytecodes, i); - Value* clVar = getResolvedCommonClass(index); - - Value* args[2] = { pop(), clVar }; - Value* val = CallInst::Create(module->InstanceOfFunction, - args, args + 2, "", currentBlock); - push(new ZExtInst(val, Type::Int32Ty, "", currentBlock), - false); break; } @@ -2043,7 +2135,7 @@ uint8 dim = readU1(bytecodes, i); - Value* valCl = getResolvedCommonClass(index); + Value* valCl = getResolvedCommonClass(index, true, 0); Value** args = (Value**)alloca(sizeof(Value*) * (dim + 2)); args[0] = valCl; args[1] = ConstantInt::get(Type::Int32Ty, dim); Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=61132&r1=61131&r2=61132&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Wed Dec 17 07:47:32 2008 @@ -36,37 +36,6 @@ "Lower Constant calls"); -static ConstantExpr* getClass(JnjvmModule* Mod, Value* obj) { - ConstantExpr* CE = 0; - if (Mod->isStaticCompiling()) { - LoadInst* LI = dyn_cast(obj); - if (!LI) { - PHINode* node = dyn_cast(obj); - if (node) { - LI = dyn_cast(node->getIncomingValue(0)); - } else { - GetElementPtrInst* GEP = dyn_cast(obj); - if (GEP) { - return getClass(Mod, GEP->getOperand(0)); - } - } - } - - if (LI) { - GlobalVariable* GV = dyn_cast(LI->getOperand(0)); - CE = dyn_cast(GV->getInitializer()); - } - } else { - CE = dyn_cast(obj); - if (!CE) { - // It has to be a phi for intialization check. - PHINode* node = dyn_cast(obj); - if (node) CE = dyn_cast(node->getIncomingValue(0)); - } - } - return CE; -} - #ifdef ISOLATE static Value* getTCM(JnjvmModule* module, Value* Arg, Instruction* CI) { Value* GEP[2] = { module->constantZero, @@ -91,22 +60,7 @@ CI); return TCM; } -#else -static Value* getTCM(JnjvmModule* module, Value* Arg, Instruction* CI) { - Value* GEP[2] = { module->constantZero, - module->OffsetTaskClassMirrorInClassConstant }; - Value* TCMArray = GetElementPtrInst::Create(Arg, GEP, GEP + 2, "", CI); - - Value* GEP2[2] = { module->constantZero, module->constantZero }; - - Value* TCM = GetElementPtrInst::Create(TCMArray, GEP2, GEP2 + 2, "", - CI); - return TCM; - -} -#endif -#ifdef ISOLATE static Value* getDelegatee(JnjvmModule* module, Value* Arg, Instruction* CI) { Value* GEP[2] = { module->constantZero, module->constantTwo }; @@ -130,7 +84,22 @@ CI); return new LoadInst(TCM, "", CI); } + #else + +static Value* getTCM(JnjvmModule* module, Value* Arg, Instruction* CI) { + Value* GEP[2] = { module->constantZero, + module->OffsetTaskClassMirrorInClassConstant }; + Value* TCMArray = GetElementPtrInst::Create(Arg, GEP, GEP + 2, "", CI); + + Value* GEP2[2] = { module->constantZero, module->constantZero }; + + Value* TCM = GetElementPtrInst::Create(TCMArray, GEP2, GEP2 + 2, "", + CI); + return TCM; + +} + static Value* getDelegatee(JnjvmModule* module, Value* Arg, Instruction* CI) { Value* GEP[2] = { module->constantZero, module->constantTwo }; @@ -206,18 +175,6 @@ } else if (V == module->GetVTFromClassFunction) { Changed = true; - ConstantExpr* CE = getClass(module, Call.getArgument(0)); - if (CE) { - ConstantInt* C = (ConstantInt*)CE->getOperand(0); - Class* cl = (Class*)C->getZExtValue(); - if (cl->isResolved()) { - Value* VT = module->getVirtualTable(cl, CI); - CI->replaceAllUsesWith(VT); - CI->eraseFromParent(); - continue; - } - } - Value* val = Call.getArgument(0); Value* indexes[2] = { module->constantZero, module->OffsetVTInClassConstant }; @@ -229,19 +186,6 @@ } else if (V == module->GetObjectSizeFromClassFunction) { Changed = true; - ConstantExpr* CE = getClass(module, Call.getArgument(0)); - if (CE) { - ConstantInt* C = (ConstantInt*)CE->getOperand(0); - Class* cl = (Class*)C->getZExtValue(); - if (cl->isResolved()) { - LLVMClassInfo* LCI = module->getClassInfo(cl); - Value* Size = LCI->getVirtualSize(); - CI->replaceAllUsesWith(Size); - CI->eraseFromParent(); - continue; - } - } - Value* val = Call.getArgument(0); Value* indexes[2] = { module->constantZero, module->OffsetObjectSizeInClassConstant }; @@ -278,104 +222,10 @@ Value* Class = new LoadInst(ClassPtr, "", CI); CI->replaceAllUsesWith(Class); CI->eraseFromParent(); - } else if (V == module->InstanceOfFunction) { - ConstantExpr* CE = dyn_cast(Call.getArgument(1)); - if (CE) { - ConstantInt* C = (ConstantInt*)CE->getOperand(0); - CommonClass* cl = (CommonClass*)C->getZExtValue(); - Changed = true; - BasicBlock* NBB = II->getParent()->splitBasicBlock(II); - I->getParent()->getTerminator()->eraseFromParent(); - Value* obj = Call.getArgument(0); - Instruction* cmp = new ICmpInst(ICmpInst::ICMP_EQ, obj, - module->JavaObjectNullConstant, - "", CI); - BasicBlock* ifTrue = BasicBlock::Create("", &F); - BasicBlock* ifFalse = BasicBlock::Create("", &F); - BranchInst::Create(ifTrue, ifFalse, cmp, CI); - PHINode* node = PHINode::Create(Type::Int1Ty, "", ifTrue); - node->addIncoming(ConstantInt::getFalse(), CI->getParent()); - Value* objCl = CallInst::Create(module->GetClassFunction, obj, - "", ifFalse); - - if (isInterface(cl->access)) { - Value* args[2] = { objCl, CE }; - Value* res = CallInst::Create(module->ImplementsFunction, - args, args + 2, "", ifFalse); - node->addIncoming(res, ifFalse); - BranchInst::Create(ifTrue, ifFalse); - } else { - cmp = new ICmpInst(ICmpInst::ICMP_EQ, objCl, CE, "", ifFalse); - BasicBlock* notEquals = BasicBlock::Create("", &F); - BranchInst::Create(ifTrue, notEquals, cmp, ifFalse); - node->addIncoming(ConstantInt::getTrue(), ifFalse); - - if (cl->isPrimitive()) { - fprintf(stderr, "implement me"); - abort(); - } else if (cl->isArray()) { - Value* args[2] = { objCl, CE }; - Value* res = - CallInst::Create(module->InstantiationOfArrayFunction, - args, args + 2, "", notEquals); - node->addIncoming(res, notEquals); - BranchInst::Create(ifTrue, notEquals); - } else { - Value* depthCl; - if (cl->asClass()->isResolved()) { - depthCl = ConstantInt::get(Type::Int32Ty, cl->depth); - } else { - depthCl = CallInst::Create(module->GetDepthFunction, - CE, "", notEquals); - } - Value* depthClObj = CallInst::Create(module->GetDepthFunction, - objCl, "", notEquals); - Value* cmp = new ICmpInst(ICmpInst::ICMP_ULE, depthCl, depthClObj, "", - notEquals); - - BasicBlock* supDepth = BasicBlock::Create("superior depth", &F); - - BranchInst::Create(supDepth, ifTrue, cmp, notEquals); - node->addIncoming(ConstantInt::getFalse(), notEquals); - - Value* inDisplay = - CallInst::Create(module->GetDisplayFunction, objCl, - "", supDepth); - - Value* args[2] = { inDisplay, depthCl }; - Value* clInDisplay = - CallInst::Create(module->GetClassInDisplayFunction, - args, args + 2, "", supDepth); - - cmp = new ICmpInst(ICmpInst::ICMP_EQ, clInDisplay, CE, "", - supDepth); - BranchInst::Create(ifTrue, supDepth); - node->addIncoming(cmp, supDepth); - } - } - CI->replaceAllUsesWith(node); - CI->eraseFromParent(); - BranchInst::Create(NBB, ifTrue); - break; - } +#if defined(ISOLATE) } else if (V == module->GetStaticInstanceFunction) { Changed = true; -#if !defined(ISOLATE_SHARING) && !defined(ISOLATE) - ConstantExpr* CE = getClass(module, Call.getArgument(0)); - assert(CE && "Wrong use of GetStaticInstanceFunction"); - - ConstantInt* C = (ConstantInt*)CE->getOperand(0); - Class* cl = (Class*)C->getZExtValue(); - - Instruction* R = dyn_cast(Call.getArgument(0)); - Value* Replace = module->getStaticInstance(cl, CI); - CI->replaceAllUsesWith(Replace); - CI->eraseFromParent(); - - if (R && !R->getNumUses()) R->eraseFromParent(); - -#elif defined(ISOLATE) Value* TCM = getTCM(module, Call.getArgument(0), CI); Constant* C = module->OffsetStaticInstanceInTaskClassMirrorConstant; Value* GEP[2] = { module->constantZero, C }; @@ -383,8 +233,6 @@ Replace = new LoadInst(Replace, "", CI); CI->replaceAllUsesWith(Replace); CI->eraseFromParent(); -#else - abort(); #endif } else if (V == module->GetClassDelegateeFunction) { Changed = true; @@ -569,33 +417,7 @@ PointerType::getUnqual(module->JavaCommonClassType); Constant* nullValue = Constant::getNullValue(Ty); // Check if we have already proceed this call. - if (Call.getArgument(1) == nullValue) { - Changed = true; - ConstantExpr* CE = getClass(module, Call.getArgument(0)); - if (CE) { - ConstantInt* C = (ConstantInt*)CE->getOperand(0); - Class* cl = (Class*)C->getZExtValue(); - if (cl->isResolved()) { - JnjvmClassLoader* JCL = cl->classLoader; - const UTF8* arrayName = JCL->constructArrayName(1, cl->name); - - UserCommonClass* dcl = JCL->constructArray(arrayName); - Value* valCl = module->getNativeClass(dcl, CI); - - Instruction* V = dyn_cast(Call.getArgument(0)); - CI->replaceAllUsesWith(valCl); - CI->eraseFromParent(); - - if (V) { - Instruction* Op = dyn_cast(V->getOperand(0)); - if (!V->getNumUses()) V->eraseFromParent(); - if (Op && !Op->getNumUses()) Op->eraseFromParent(); - } - - continue; - } - } - + if (Call.getArgument(1) == nullValue) { BasicBlock* NBB = II->getParent()->splitBasicBlock(II); I->getParent()->getTerminator()->eraseFromParent(); From nicolas.geoffray at lip6.fr Wed Dec 17 06:01:49 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 17 Dec 2008 14:01:49 -0000 Subject: [vmkit-commits] [vmkit] r61133 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200812171401.mBHE1p9G003171@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 17 08:01:32 2008 New Revision: 61133 URL: http://llvm.org/viewvc/llvm-project?rev=61133&view=rev Log: Do not allocate the JavaObject::VT twice... Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61133&r1=61132&r2=61133&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Dec 17 08:01:32 2008 @@ -387,7 +387,7 @@ assert(super->virtualVT && "Super does not have a VT!"); memcpy(VT, super->virtualVT, cl->super->virtualTableSize * sizeof(void*)); } else { - memcpy(VT, JavaObject::VT, VT_SIZE); + VT = JavaObject::VT; } return VT; } @@ -509,7 +509,7 @@ BasicBlock::iterator I = BB->begin(); if (isa(I)) { ((void**)VT)[0] = 0; - } else { + } else if (!staticCompilation) { // LLVM does not allow recursive compilation. Create the code now. ((void**)VT)[0] = EE->getPointerToFunction(func); } @@ -533,10 +533,10 @@ (void*)((uintptr_t)VT + VT_SIZE), size); COPY(JavaArray) - COPY(JavaObject) COPY(ArrayObject) #undef COPY + } #endif @@ -1115,27 +1115,23 @@ ClassReadyConstant = ConstantInt::get(Type::Int32Ty, ready); - Constant* consPrim = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64(JavaArray::VT)), - VTType); - - Constant* consRef = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64(ArrayObject::VT)), - VTType); if (staticCompilation) { PrimitiveArrayVT = new GlobalVariable(VTType, false, GlobalValue::ExternalLinkage, - consPrim, "", this); + 0, "", this); ReferenceArrayVT = new GlobalVariable(VTType, false, GlobalValue::ExternalLinkage, - consRef, "", this); + 0, "", this); } else { - PrimitiveArrayVT = consPrim; - ReferenceArrayVT = consRef; + PrimitiveArrayVT = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, + uint64(JavaArray::VT)), + VTType); + + ReferenceArrayVT = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, + uint64(ArrayObject::VT)), + VTType); } LLVMAssessorInfo::initialise(); From nicolas.geoffray at lip6.fr Wed Dec 17 06:31:27 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 17 Dec 2008 14:31:27 -0000 Subject: [vmkit-commits] [vmkit] r61136 - in /vmkit/trunk/lib: JnJVM/LLVMRuntime/runtime-boehm.ll JnJVM/LLVMRuntime/runtime-default.ll JnJVM/LLVMRuntime/runtime-isolate.ll JnJVM/LLVMRuntime/runtime-single.ll JnJVM/VMCore/JavaJIT.cpp JnJVM/VMCore/JnjvmModule.cpp Mvm/Runtime/LLVMRuntime.ll Message-ID: <200812171431.mBHEVUPY004000@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 17 08:31:16 2008 New Revision: 61136 URL: http://llvm.org/viewvc/llvm-project?rev=61136&view=rev Log: Set the LLVM type of the VT as an array of functions. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-boehm.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-boehm.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-boehm.ll?rev=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-boehm.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-boehm.ll Wed Dec 17 08:31:16 2008 @@ -2,4 +2,4 @@ ;;;;;;;;;;;;;;;;;;;; Collector specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -declare %JavaObject* @gcmalloc(i32, %VT) +declare %JavaObject* @gcmalloc(i32, %VT*) 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=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Wed Dec 17 08:31:16 2008 @@ -3,10 +3,10 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; A virtual table is an array of function pointers. -%VT = type i32 (...)** +%VT = type [0 x i32 (...)*] ;;; The root of all Java Objects: a VT, a class and a lock. -%JavaObject = type { %VT, %JavaCommonClass*, i8* } +%JavaObject = type { %VT*, %JavaCommonClass*, i8* } ;;; Types for Java arrays. A size of 0 means an undefined size. %JavaArray = type { %JavaObject, i8* } @@ -55,7 +55,7 @@ declare i32 @arrayLength(%JavaObject*) readnone ;;; getVT - Get the VT of the object. -declare %VT @getVT(%JavaObject*) readnone +declare %VT* @getVT(%JavaObject*) readnone ;;; getClass - Get the class of an object. declare %JavaCommonClass* @getClass(%JavaObject*) readnone @@ -64,7 +64,7 @@ declare i8* @getLock(%JavaObject*) ;;; getVTFromClass - Get the VT of a class from its runtime representation. -declare %VT @getVTFromClass(%JavaClass*) readnone +declare %VT* @getVTFromClass(%JavaClass*) readnone ;;; getObjectSizeFromClass - Get the size of a class from its runtime ;;; representation. @@ -185,7 +185,7 @@ declare void @jniProceedPendingException() declare i8* @getSJLJBuffer() -declare %JavaObject* @gcmalloc(i32, %VT) +declare %JavaObject* @gcmalloc(i32, %VT*) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Debugging methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll?rev=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Wed Dec 17 08:31:16 2008 @@ -2,13 +2,13 @@ ;;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -%Jnjvm = type {%VT, %JavaClass*, [9 x %JavaClass*]} +%Jnjvm = type { %VT*, %JavaClass*, [9 x %JavaClass*] } %JavaCommonClass = type { %JavaCommonClass**, i32, [32 x %JavaObject*], i16, %JavaClass**, i16, %UTF8*, %JavaClass*, i8* } -%JavaClass = type { %JavaCommonClass, i32, %VT, [32 x %TaskClassMirror], i8*, +%JavaClass = type { %JavaCommonClass, i32, %VT*, [32 x %TaskClassMirror], i8*, %JavaField*, i16, %JavaField*, i16, %JavaMethod*, i16, %JavaMethod*, i16, i8*, %ArrayUInt8*, i8*, %Attribut*, i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*, Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll?rev=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll Wed Dec 17 08:31:16 2008 @@ -6,7 +6,7 @@ %JavaClass**, i16, %UTF8*, %JavaClass*, i8* } -%JavaClass = type { %JavaCommonClass, i32, %VT, [1 x %TaskClassMirror], i8*, +%JavaClass = type { %JavaCommonClass, i32, %VT*, [1 x %TaskClassMirror], i8*, %JavaField*, i16, %JavaField*, i16, %JavaMethod*, i16, %JavaMethod*, i16, i8*, %ArrayUInt8*, i8*, %Attribut*, i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*, Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Dec 17 08:31:16 2008 @@ -114,14 +114,16 @@ Value* VT = CallInst::Create(module->GetVTFunction, args[0], "", currentBlock); - Value* indexes2; //[3]; + Value* indexes2[2]; + indexes2[0] = module->constantZero; + #ifdef ISOLATE_SHARING Value* indexesCtp; //[3]; #endif if (meth) { LLVMMethodInfo* LMI = module->getMethodInfo(meth); ConstantInt* Offset = LMI->getOffset(); - indexes2 = Offset; + indexes2[1] = Offset; #ifdef ISOLATE_SHARING indexesCtp = ConstantInt::get(Type::Int32Ty, Offset->getZExtValue() * -1); @@ -130,7 +132,7 @@ Value* val = getConstantPoolAt(index, module->VirtualLookupFunction, Type::Int32Ty, args[0], true); - indexes2 = val; + indexes2[1] = val; #ifdef ISOLATE_SHARING Value* mul = BinaryOperator::CreateMul(val, module->constantMinusOne, "", currentBlock); @@ -138,9 +140,11 @@ #endif } - Value* FuncPtr = GetElementPtrInst::Create(VT, indexes2, "", currentBlock); + Value* FuncPtr = GetElementPtrInst::Create(VT, indexes2, indexes2 + 2, "", + currentBlock); Value* Func = new LoadInst(FuncPtr, "", currentBlock); + Func = new BitCastInst(Func, LSI->getVirtualPtrType(), "", currentBlock); #ifdef ISOLATE_SHARING Value* CTP = GetElementPtrInst::Create(VT, indexesCtp, "", currentBlock); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Dec 17 08:31:16 2008 @@ -536,7 +536,7 @@ COPY(ArrayObject) #undef COPY - + } #endif @@ -1041,7 +1041,7 @@ Module* module = this; initialModule = this; - VTType = module->getTypeByName("VT"); + VTType = PointerType::getUnqual(module->getTypeByName("VT")); #ifdef ISOLATE_SHARING JnjvmType = Modified: vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll?rev=61136&r1=61135&r2=61136&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll (original) +++ vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Wed Dec 17 08:31:16 2008 @@ -3,7 +3,7 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; A virtual table is an array of function pointers. -%VT = type i32 (...)** +%VT = type [0 x i32 (...)*] ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Printing functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; From nicolas.geoffray at lip6.fr Fri Dec 19 14:20:28 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 19 Dec 2008 22:20:28 -0000 Subject: [vmkit-commits] [vmkit] r61262 - in /vmkit/trunk/lib: JnJVM/LLVMRuntime/runtime-default.ll JnJVM/VMCore/JavaClass.cpp JnJVM/VMCore/JavaConstantPool.cpp JnJVM/VMCore/JnjvmModule.cpp JnJVM/VMCore/JnjvmModule.h Mvm/Runtime/EscapeAnalysis.cpp Message-ID: <200812192220.mBJMKTtD004811@zion.cs.uiuc.edu> Author: geoffray Date: Fri Dec 19 16:20:27 2008 New Revision: 61262 URL: http://llvm.org/viewvc/llvm-project?rev=61262&view=rev Log: Support for class, methods and fields constants when static compiling. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp 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=61262&r1=61261&r2=61262&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Fri Dec 19 16:20:27 2008 @@ -38,12 +38,15 @@ %UTF8 = type { %JavaObject, i8*, [0 x i16] } -%JavaField = type { i8*, i16, %UTF8*, %UTF8*, %Attribut*, i16, %JavaClass*, i64, +%JavaField = type { i8*, i16, %UTF8*, %UTF8*, %Attribut*, i16, %JavaClass*, i32, i16, i8* } %JavaMethod = type { i8*, i16, %Attribut*, i16, %Enveloppe*, i16, %JavaClass*, %UTF8*, %UTF8*, i8, i8*, i32, i8* } +%JavaClassPrimitive = type { %JavaCommonClass, i32 } +%JavaClassArray = type { %JavaCommonClass, %JavaCommonClass* } + ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;; Constant calls for Jnjvm runtime internal objects field accesses ;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61262&r1=61261&r2=61262&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Dec 19 16:20:27 2008 @@ -299,6 +299,7 @@ virtualFields = 0; staticFields = 0; ownerClass = 0; + innerAccess = 0; access = JNJVM_CLASS; memset(IsolateInfo, 0, sizeof(TaskClassMirror) * NR_ISOLATES); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=61262&r1=61261&r2=61262&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Fri Dec 19 16:20:27 2008 @@ -307,6 +307,10 @@ temp = loader->lookupClassOrArray(name); } #endif + + if (!temp && classDef->classLoader->getModule()->isStaticCompiling()) { + temp = loadClass(index); + } return temp; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61262&r1=61261&r2=61262&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Dec 19 16:20:27 2008 @@ -9,15 +9,18 @@ #include "llvm/BasicBlock.h" #include "llvm/CallingConv.h" +#include "llvm/Constants.h" #include "llvm/Instructions.h" #include "llvm/Support/MutexGuard.h" #include "mvm/JIT.h" +#include "JavaCache.h" #include "JavaJIT.h" #include "JavaThread.h" #include "JavaTypes.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" #include "JnjvmModule.h" #include "JnjvmModuleProvider.h" @@ -27,8 +30,8 @@ using namespace jnjvm; using namespace llvm; -llvm::Value* JnjvmModule::PrimitiveArrayVT; -llvm::Value* JnjvmModule::ReferenceArrayVT; +llvm::Constant* JnjvmModule::PrimitiveArrayVT; +llvm::Constant* JnjvmModule::ReferenceArrayVT; #ifdef WITH_TRACER const llvm::FunctionType* JnjvmModule::MarkAndTraceType = 0; @@ -49,6 +52,10 @@ const llvm::Type* JnjvmModule::CacheNodeType = 0; const llvm::Type* JnjvmModule::EnveloppeType = 0; const llvm::Type* JnjvmModule::ConstantPoolType = 0; +const llvm::Type* JnjvmModule::UTF8Type = 0; +const llvm::Type* JnjvmModule::JavaFieldType = 0; +const llvm::Type* JnjvmModule::JavaMethodType = 0; +const llvm::Type* JnjvmModule::AttributType = 0; #ifdef ISOLATE_SHARING const llvm::Type* JnjvmModule::JnjvmType = 0; @@ -66,6 +73,8 @@ llvm::ConstantInt* JnjvmModule::OffsetStatusInTaskClassMirrorConstant; llvm::ConstantInt* JnjvmModule::ClassReadyConstant; const llvm::Type* JnjvmModule::JavaClassType; +const llvm::Type* JnjvmModule::JavaClassPrimitiveType; +const llvm::Type* JnjvmModule::JavaClassArrayType; const llvm::Type* JnjvmModule::JavaCommonClassType; const llvm::Type* JnjvmModule::VTType; llvm::ConstantInt* JnjvmModule::JavaArrayElementsOffsetConstant; @@ -73,63 +82,68 @@ llvm::ConstantInt* JnjvmModule::JavaObjectLockOffsetConstant; llvm::ConstantInt* JnjvmModule::JavaObjectClassOffsetConstant; -Value* JnjvmModule::getNativeClass(CommonClass* classDef, Value* Where) { - const llvm::Type* Ty = classDef->isClass() ? JavaClassType : - JavaCommonClassType; +Constant* JnjvmModule::getNativeClass(CommonClass* classDef, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; native_class_iterator End = nativeClasses.end(); native_class_iterator I = nativeClasses.find(classDef); if (I == End) { - ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t (classDef)); - Constant* cons = ConstantExpr::getIntToPtr(CI, Ty); + const llvm::Type* Ty = 0; + + if (classDef->isClass()) { + Ty = JavaClassType->getContainedType(0); + } else if (classDef->isPrimitive()) { + Ty = JavaClassPrimitiveType->getContainedType(0); + } else { + Ty = JavaClassArrayType->getContainedType(0); + } + + GlobalVariable* varGV = + new GlobalVariable(Ty, true, GlobalValue::ExternalLinkage, 0, "", this); - varGV = new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage, - cons, "", this); - nativeClasses.insert(std::make_pair(classDef, varGV)); - } else { - varGV = I->second; - } - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); + Constant* C = 0; + if (classDef->isClass()) { + C = CreateConstantFromClass((Class*)classDef); + } else if (classDef->isPrimitive()) { + C = CreateConstantFromClassPrimitive((ClassPrimitive*)classDef); + } else { + C = CreateConstantFromClassArray((ClassArray*)classDef); + } + + varGV->setInitializer(C); + + return varGV; + } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); + return I->second; } + } else { + const llvm::Type* Ty = classDef->isClass() ? JavaClassType : + JavaCommonClassType; ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(classDef)); return ConstantExpr::getIntToPtr(CI, Ty); } } -Value* JnjvmModule::getConstantPool(JavaConstantPool* ctp, Value* Where) { +Constant* JnjvmModule::getConstantPool(JavaConstantPool* ctp, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; + llvm::Constant* varGV = 0; constant_pool_iterator End = constantPools.end(); constant_pool_iterator I = constantPools.find(ctp); if (I == End) { - void* ptr = ctp->ctpRes; - assert(ptr && "No constant pool found"); - ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(ptr)); - Constant* cons = ConstantExpr::getIntToPtr(CI, ConstantPoolType); - varGV = new GlobalVariable(ConstantPoolType, false, + varGV = new GlobalVariable(ConstantPoolType->getContainedType(0), false, GlobalValue::ExternalLinkage, - cons, "", this); + 0, "", this); constantPools.insert(std::make_pair(ctp, varGV)); + return varGV; } else { - varGV = I->second; - } - - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); + return I->second; } + } else { void* ptr = ctp->ctpRes; assert(ptr && "No constant pool found"); @@ -138,28 +152,27 @@ } } -Value* JnjvmModule::getString(JavaString* str, Value* Where) { +Constant* JnjvmModule::getString(JavaString* str, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV; string_iterator SI = strings.find(str); if (SI != strings.end()) { - varGV = SI->second; + return SI->second; } else { assert(str && "No string given"); - ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(str)); - Constant* cons = ConstantExpr::getIntToPtr(CI, JavaObjectType); - varGV = new GlobalVariable(JnjvmModule::JavaObjectType, false, - GlobalValue::ExternalLinkage, - cons, "", this); - strings.insert(std::make_pair(str, varGV)); + LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo((Class*)str->classOf); + const llvm::Type* Ty = LCI->getVirtualType(); + GlobalVariable* varGV = + new GlobalVariable(Ty->getContainedType(0), true, + GlobalValue::ExternalLinkage, + 0, "", this); + Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV, + JavaObjectType); + strings.insert(std::make_pair(str, res)); + Constant* C = CreateConstantFromJavaString(str); + varGV->setInitializer(C); + return res; } - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); - } } else { assert(str && "No string given"); ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(str)); @@ -167,60 +180,52 @@ } } -Value* JnjvmModule::getEnveloppe(Enveloppe* enveloppe, Value* Where) { +Constant* JnjvmModule::getEnveloppe(Enveloppe* enveloppe, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV; enveloppe_iterator SI = enveloppes.find(enveloppe); if (SI != enveloppes.end()) { - varGV = SI->second; + return SI->second; } else { - void* ptr = enveloppe; - assert(ptr && "No enveloppe given"); - ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(ptr)); - Constant* cons = ConstantExpr::getIntToPtr(CI, EnveloppeType); - varGV = new GlobalVariable(JnjvmModule::EnveloppeType, false, - GlobalValue::ExternalLinkage, - cons, "", this); + GlobalVariable* varGV = + new GlobalVariable(EnveloppeType->getContainedType(0), false, + GlobalValue::ExternalLinkage, 0, "", this); enveloppes.insert(std::make_pair(enveloppe, varGV)); + + Constant* C = CreateConstantFromEnveloppe(enveloppe); + varGV->setInitializer(C); + return varGV; } - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); - } } else { - void* ptr = enveloppe; - assert(ptr && "No enveloppe given"); - ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(ptr)); - return ConstantExpr::getIntToPtr(CI, JnjvmModule::EnveloppeType); + assert(enveloppe && "No enveloppe given"); + ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64(enveloppe)); + return ConstantExpr::getIntToPtr(CI, EnveloppeType); } } -Value* JnjvmModule::getJavaClass(CommonClass* cl, Value* Where) { +Constant* JnjvmModule::getJavaClass(CommonClass* cl, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; java_class_iterator End = javaClasses.end(); java_class_iterator I = javaClasses.find(cl); if (I == End) { + Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass; + LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(javaClass); + const llvm::Type* Ty = LCI->getVirtualType(); + + GlobalVariable* varGV = + new GlobalVariable(Ty->getContainedType(0), false, + GlobalValue::ExternalLinkage, 0, "", this); + + Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV, + JavaObjectType); - Constant* cons = ConstantExpr::getIntToPtr(constantZero, JavaObjectType); - varGV = new GlobalVariable(JnjvmModule::JavaObjectType, false, - GlobalValue::ExternalLinkage, - cons, "", this); - - javaClasses.insert(std::make_pair(cl, varGV)); + javaClasses.insert(std::make_pair(cl, res)); + varGV->setInitializer(CreateConstantFromJavaClass(cl)); + return res; } else { - varGV = I->second; + return I->second; } - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); - } } else { JavaObject* obj = cl->getClassDelegatee(JavaThread::get()->getJVM()); assert(obj && "Delegatee not created"); @@ -229,37 +234,30 @@ } } -Value* JnjvmModule::getStaticInstance(Class* classDef, Value* Where) { +Constant* JnjvmModule::getStaticInstance(Class* classDef, Value* Where) { #ifdef ISOLATE assert(0 && "Should not be here"); abort(); #endif if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; + llvm::Constant* varGV = 0; static_instance_iterator End = staticInstances.end(); static_instance_iterator I = staticInstances.find(classDef); if (I == End) { LLVMClassInfo* LCI = getClassInfo(classDef); - LCI->getStaticType(); - void* obj = ((Class*)classDef)->getStaticInstance(); - Constant* CI = ConstantInt::get(Type::Int64Ty, (uint64_t(obj))); - Constant* cons = ConstantExpr::getIntToPtr(CI, ptrType); - - varGV = new GlobalVariable(ptrType, false, + const Type* Ty = LCI->getStaticType(); + varGV = new GlobalVariable(Ty->getContainedType(0), false, GlobalValue::ExternalLinkage, - cons, "", this); + 0, "", this); - staticInstances.insert(std::make_pair(classDef, varGV)); + Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV, + ptrType); + staticInstances.insert(std::make_pair(classDef, res)); + return res; } else { - varGV = I->second; - } - - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); + return I->second; } + } else { void* obj = ((Class*)classDef)->getStaticInstance(); if (!obj) { @@ -277,30 +275,31 @@ } } -Value* JnjvmModule::getVirtualTable(Class* classDef, Value* Where) { +Constant* JnjvmModule::getVirtualTable(Class* classDef, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; + llvm::Constant* res = 0; virtual_table_iterator End = virtualTables.end(); virtual_table_iterator I = virtualTables.find(classDef); if (I == End) { - void* ptr = classDef->virtualVT; - ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(ptr)); - Constant* cons = ConstantExpr::getIntToPtr(CI, VTType); - varGV = new GlobalVariable(JnjvmModule::VTType, false, - GlobalValue::ExternalLinkage, - cons, "", this); + const ArrayType* ATy = dyn_cast(VTType->getContainedType(0)); + const PointerType* PTy = dyn_cast(ATy->getContainedType(0)); + ATy = ArrayType::get(PTy, classDef->virtualTableSize); + GlobalVariable* varGV = new GlobalVariable(ATy, true, + GlobalValue::ExternalLinkage, + 0, "", this); - virtualTables.insert(std::make_pair(classDef, varGV)); - } else { - varGV = I->second; - } - - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); + res = ConstantExpr::getCast(Instruction::BitCast, varGV, VTType); + virtualTables.insert(std::make_pair(classDef, res)); + + Constant* C = CreateConstantFromVT(classDef->virtualVT, + classDef->virtualTableSize); + varGV->setInitializer(C); + + return res; } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); - } + return I->second; + } + } else { LLVMClassInfo* LCI = getClassInfo((Class*)classDef); LCI->getVirtualType(); @@ -311,38 +310,29 @@ } } -Value* JnjvmModule::getNativeFunction(JavaMethod* meth, void* ptr, - Value* Where) { +Constant* JnjvmModule::getNativeFunction(JavaMethod* meth, void* ptr, + Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; + llvm::Constant* varGV = 0; native_function_iterator End = nativeFunctions.end(); native_function_iterator I = nativeFunctions.find(meth); if (I == End) { LLVMSignatureInfo* LSI = getSignatureInfo(meth->getSignature()); - const llvm::Type* valPtrType = LSI->getNativePtrType(); + const llvm::Type* valPtrType = LSI->getNativeType(); assert((ptr || isStaticCompiling()) && "No native function given"); - Constant* cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t(ptr)), - valPtrType); - varGV = new GlobalVariable(valPtrType, false, GlobalValue::ExternalLinkage, - cons, "", this); + 0, "", this); nativeFunctions.insert(std::make_pair(meth, varGV)); + return varGV; } else { - varGV = I->second; + return I->second; } - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(varGV, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(varGV, "", dyn_cast(Where)); - } } else { LLVMSignatureInfo* LSI = getSignatureInfo(meth->getSignature()); const llvm::Type* valPtrType = LSI->getNativePtrType(); @@ -469,6 +459,655 @@ return func; } +Constant* JnjvmModule::CreateConstantForJavaObject(CommonClass* cl) { + const StructType* STy = + dyn_cast(JavaObjectType->getContainedType(0)); + + std::vector Elmts; + + if (cl->isClass()) { + Elmts.push_back(getVirtualTable(cl->asClass(), 0)); + } else { + ClassArray* clA = cl->asArrayClass(); + if (clA->baseClass()->isPrimitive()) { + Elmts.push_back(PrimitiveArrayVT); + } else { + Elmts.push_back(ReferenceArrayVT); + } + } + + Constant* Cl = getNativeClass(cl, 0); + Constant* ClGEPs[2] = { constantZero, constantZero }; + Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2); + + Elmts.push_back(Cl); + Elmts.push_back(Constant::getNullValue(ptrType)); + + return ConstantStruct::get(STy, Elmts); +} + +Constant* JnjvmModule::CreateConstantFromJavaClass(CommonClass* cl) { + Class* javaClass = cl->classLoader->bootstrapLoader->upcalls->newClass; + LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(javaClass); + const StructType* STy = + dyn_cast(LCI->getVirtualType()->getContainedType(0)); + + std::vector Elmts; + + Elmts.push_back(CreateConstantForJavaObject(cl)); + + // signers + Elmts.push_back(Constant::getNullValue(JavaObjectType)); + + // pd + Elmts.push_back(Constant::getNullValue(JavaObjectType)); + + // vmdata + Constant* Cl = getNativeClass(cl, 0); + Cl = ConstantExpr::getCast(Instruction::BitCast, Cl, JavaObjectType); + Elmts.push_back(Cl); + + // constructor + Elmts.push_back(Constant::getNullValue(JavaObjectType)); + + return ConstantStruct::get(STy, Elmts); +} + +Constant* JnjvmModule::CreateConstantFromJavaString(JavaString* str) { + Class* cl = (Class*)str->classOf; + LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl); + const StructType* STy = + dyn_cast(LCI->getVirtualType()->getContainedType(0)); + + std::vector Elmts; + + Elmts.push_back(CreateConstantForJavaObject(cl)); + + Constant* Array = getUTF8(str->value); + Constant* ObjGEPs[2] = { constantZero, constantZero }; + Array = ConstantExpr::getGetElementPtr(Array, ObjGEPs, 2); + Elmts.push_back(Array); + + Elmts.push_back(ConstantInt::get(Type::Int32Ty, str->count)); + Elmts.push_back(ConstantInt::get(Type::Int32Ty, str->cachedHashCode)); + Elmts.push_back(ConstantInt::get(Type::Int32Ty, str->offset)); + + return ConstantStruct::get(STy, Elmts); +} + + +Constant* JnjvmModule::CreateConstantFromCacheNode(CacheNode* CN) { + const StructType* STy = + dyn_cast(CacheNodeType->getContainedType(0)); + + std::vector Elmts; + Elmts.push_back(Constant::getNullValue(STy->getContainedType(0))); + Elmts.push_back(Constant::getNullValue(STy->getContainedType(1))); + Elmts.push_back(Constant::getNullValue(STy->getContainedType(2))); + Elmts.push_back(getEnveloppe(CN->enveloppe, 0)); + + return ConstantStruct::get(STy, Elmts); +} + +Constant* JnjvmModule::CreateConstantFromEnveloppe(Enveloppe* val) { + + const StructType* STy = + dyn_cast(EnveloppeType->getContainedType(0)); + const StructType* CNTy = + dyn_cast(CacheNodeType->getContainedType(0)); + + std::vector Elmts; + + Constant* firstCache = CreateConstantFromCacheNode(val->firstCache); + Elmts.push_back(new GlobalVariable(CNTy, false, + GlobalValue::InternalLinkage, + firstCache, "", this)); + 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(firstCache); + + return ConstantStruct::get(STy, Elmts); + +} + +Constant* JnjvmModule::CreateConstantFromAttribut(Attribut& attribut) { + const StructType* STy = + dyn_cast(AttributType->getContainedType(0)); + + + std::vector Elmts; + + // name + Elmts.push_back(getUTF8(attribut.name)); + + // start + Elmts.push_back(ConstantInt::get(Type::Int32Ty, attribut.start)); + + // nbb + Elmts.push_back(ConstantInt::get(Type::Int32Ty, attribut.nbb)); + + return ConstantStruct::get(STy, Elmts); +} + +Constant* JnjvmModule::CreateConstantFromCommonClass(CommonClass* cl) { + const StructType* STy = + dyn_cast(JavaCommonClassType->getContainedType(0)); + + const ArrayType* ATy = ArrayType::get(JavaCommonClassType, cl->depth + 1); + + std::vector CommonClassElts; + std::vector TempElmts; + Constant* ClGEPs[2] = { constantZero, constantZero }; + + // display + for (uint32 i = 0; i <= cl->depth; ++i) { + Constant* Cl = getNativeClass(cl->display[i], 0); + if (Cl->getType() != JavaCommonClassType) + Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2); + + TempElmts.push_back(Cl); + } + + Constant* display = ConstantArray::get(ATy, TempElmts); + TempElmts.clear(); + display = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + display, "", this); + display = ConstantExpr::getCast(Instruction::BitCast, display, + PointerType::getUnqual(JavaCommonClassType)); + CommonClassElts.push_back(display); + + // depth + CommonClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->depth)); + + // delegatee + ATy = dyn_cast(STy->getContainedType(2)); + assert(ATy && "Malformed type"); + + Constant* TCM[1] = { Constant::getNullValue(JavaObjectType) }; + CommonClassElts.push_back(ConstantArray::get(ATy, TCM, 1)); + + // access + CommonClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->access)); + + // interfaces + if (cl->nbInterfaces) { + for (uint32 i = 0; i < cl->nbInterfaces; ++i) { + TempElmts.push_back(getNativeClass(cl->interfaces[i], 0)); + } + + ATy = ArrayType::get(JavaClassType, cl->nbInterfaces); + Constant* interfaces = ConstantArray::get(ATy, TempElmts); + interfaces = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + interfaces, "", this); + interfaces = ConstantExpr::getCast(Instruction::BitCast, interfaces, + PointerType::getUnqual(JavaClassType)); + + CommonClassElts.push_back(interfaces); + } else { + const Type* Ty = PointerType::getUnqual(JavaClassType); + CommonClassElts.push_back(Constant::getNullValue(Ty)); + } + + // nbInterfaces + CommonClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbInterfaces)); + + // name + CommonClassElts.push_back(getUTF8(cl->name)); + + // super + if (cl->super) { + CommonClassElts.push_back(getNativeClass(cl->super, 0)); + } else { + CommonClassElts.push_back(Constant::getNullValue(JavaClassType)); + } + + // classLoader + CommonClassElts.push_back(Constant::getNullValue(ptrType)); + + return ConstantStruct::get(STy, CommonClassElts); +} + +Constant* JnjvmModule::CreateConstantFromJavaField(JavaField& field) { + const StructType* STy = + dyn_cast(JavaFieldType->getContainedType(0)); + + std::vector FieldElts; + std::vector TempElts; + + // signature + FieldElts.push_back(Constant::getNullValue(ptrType)); + + // access + FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.access)); + + // name + FieldElts.push_back(getUTF8(field.name)); + + // type + FieldElts.push_back(getUTF8(field.type)); + + // attributs + if (field.nbAttributs) { + const ArrayType* ATy = ArrayType::get(AttributType->getContainedType(0), + field.nbAttributs); + for (uint32 i = 0; i < field.nbAttributs; ++i) { + TempElts.push_back(CreateConstantFromAttribut(field.attributs[i])); + } + + Constant* attributs = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + attributs = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + attributs, "", this); + attributs = ConstantExpr::getCast(Instruction::BitCast, attributs, + AttributType); + + FieldElts.push_back(attributs); + } else { + FieldElts.push_back(Constant::getNullValue(AttributType)); + } + + // nbAttributs + FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.nbAttributs)); + + // classDef + FieldElts.push_back(getNativeClass(field.classDef, 0)); + + // ptrOffset + FieldElts.push_back(ConstantInt::get(Type::Int32Ty, field.ptrOffset)); + + // num + FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.num)); + + //JInfo + FieldElts.push_back(Constant::getNullValue(ptrType)); + + return ConstantStruct::get(STy, FieldElts); +} + +Constant* JnjvmModule::CreateConstantFromJavaMethod(JavaMethod& method) { + const StructType* STy = + dyn_cast(JavaMethodType->getContainedType(0)); + + std::vector MethodElts; + std::vector TempElts; + + // signature + MethodElts.push_back(Constant::getNullValue(ptrType)); + + // access + MethodElts.push_back(ConstantInt::get(Type::Int16Ty, method.access)); + + // attributs + if (method.nbAttributs) { + const ArrayType* ATy = ArrayType::get(AttributType->getContainedType(0), + method.nbAttributs); + for (uint32 i = 0; i < method.nbAttributs; ++i) { + TempElts.push_back(CreateConstantFromAttribut(method.attributs[i])); + } + + Constant* attributs = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + attributs = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + attributs, "", this); + attributs = ConstantExpr::getCast(Instruction::BitCast, attributs, + AttributType); + + MethodElts.push_back(attributs); + } else { + MethodElts.push_back(Constant::getNullValue(AttributType)); + } + + // nbAttributs + MethodElts.push_back(ConstantInt::get(Type::Int16Ty, method.nbAttributs)); + + // enveloppes + // already allocated by the JIT, don't reallocate them. + MethodElts.push_back(Constant::getNullValue(EnveloppeType)); + + // nbEnveloppes + // 0 because we're not allocating here. + MethodElts.push_back(ConstantInt::get(Type::Int16Ty, 0)); + + // classDef + MethodElts.push_back(getNativeClass(method.classDef, 0)); + + // name + MethodElts.push_back(getUTF8(method.name)); + + // type + MethodElts.push_back(getUTF8(method.type)); + + // canBeInlined + MethodElts.push_back(ConstantInt::get(Type::Int8Ty, method.canBeInlined)); + + // code + LLVMMethodInfo* LMI = getMethodInfo(&method); + Function* func = LMI->getMethod(); + MethodElts.push_back(ConstantExpr::getCast(Instruction::BitCast, func, + ptrType)); + + // offset + MethodElts.push_back(ConstantInt::get(Type::Int32Ty, method.offset)); + + //JInfo + MethodElts.push_back(Constant::getNullValue(ptrType)); + + return ConstantStruct::get(STy, MethodElts); +} + +Constant* JnjvmModule::CreateConstantFromClassPrimitive(ClassPrimitive* cl) { + const StructType* STy = + dyn_cast(JavaClassPrimitiveType->getContainedType(0)); + + std::vector ClassElts; + + // common class + ClassElts.push_back(CreateConstantFromCommonClass(cl)); + + // primSize + ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->primSize)); + + return ConstantStruct::get(STy, ClassElts); +} + +Constant* JnjvmModule::CreateConstantFromClassArray(ClassArray* cl) { + const StructType* STy = + dyn_cast(JavaClassArrayType->getContainedType(0)); + + std::vector ClassElts; + Constant* ClGEPs[2] = { constantZero, constantZero }; + + // common class + ClassElts.push_back(CreateConstantFromCommonClass(cl)); + + // baseClass + Constant* Cl = getNativeClass(cl->baseClass(), 0); + if (Cl->getType() != JavaCommonClassType) + Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2); + + ClassElts.push_back(Cl); + + return ConstantStruct::get(STy, ClassElts); +} + +Constant* JnjvmModule::CreateConstantFromClass(Class* cl) { + const StructType* STy = + dyn_cast(JavaClassType->getContainedType(0)); + + std::vector ClassElts; + std::vector TempElts; + + // common class + ClassElts.push_back(CreateConstantFromCommonClass(cl)); + + // virtualSize + ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->virtualSize)); + + // virtualTable + ClassElts.push_back(getVirtualTable(cl, 0)); + + // IsolateInfo + const ArrayType* ATy = dyn_cast(STy->getContainedType(3)); + assert(ATy && "Malformed type"); + + const StructType* TCMTy = dyn_cast(ATy->getContainedType(0)); + assert(TCMTy && "Malformed type"); + + TempElts.push_back(ConstantInt::get(Type::Int32Ty, ready)); + TempElts.push_back(getStaticInstance(cl, 0)); + Constant* CStr[1] = { ConstantStruct::get(TCMTy, TempElts) }; + TempElts.clear(); + ClassElts.push_back(ConstantArray::get(ATy, CStr, 1)); + + // thinlock + ClassElts.push_back(Constant::getNullValue(ptrType)); + + // virtualFields + if (cl->nbVirtualFields) { + ATy = ArrayType::get(JavaFieldType->getContainedType(0), cl->nbVirtualFields); + + for (uint32 i = 0; i < cl->nbVirtualFields; ++i) { + TempElts.push_back(CreateConstantFromJavaField(cl->virtualFields[i])); + } + + Constant* fields = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + fields = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + fields, "", this); + fields = ConstantExpr::getCast(Instruction::BitCast, fields, JavaFieldType); + ClassElts.push_back(fields); + } else { + ClassElts.push_back(Constant::getNullValue(JavaFieldType)); + } + + // nbVirtualFields + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbVirtualFields)); + + // staticFields + if (cl->nbStaticFields) { + ATy = ArrayType::get(JavaFieldType->getContainedType(0), cl->nbStaticFields); + + for (uint32 i = 0; i < cl->nbStaticFields; ++i) { + TempElts.push_back(CreateConstantFromJavaField(cl->staticFields[i])); + } + + Constant* fields = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + fields = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + fields, "", this); + fields = ConstantExpr::getCast(Instruction::BitCast, fields, JavaFieldType); + ClassElts.push_back(fields); + } else { + ClassElts.push_back(Constant::getNullValue(JavaFieldType)); + } + + // nbStaticFields + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbStaticFields)); + + // virtualMethods + if (cl->nbVirtualMethods) { + ATy = ArrayType::get(JavaMethodType->getContainedType(0), + cl->nbVirtualMethods); + + for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) { + TempElts.push_back(CreateConstantFromJavaMethod(cl->virtualMethods[i])); + } + + Constant* methods = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + methods = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + methods, "", this); + methods = ConstantExpr::getCast(Instruction::BitCast, methods, + JavaMethodType); + ClassElts.push_back(methods); + } else { + ClassElts.push_back(Constant::getNullValue(JavaMethodType)); + } + + // nbVirtualMethods + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbVirtualMethods)); + + // staticMethods + if (cl->nbStaticMethods) { + ATy = ArrayType::get(JavaMethodType->getContainedType(0), + cl->nbStaticMethods); + + for (uint32 i = 0; i < cl->nbStaticMethods; ++i) { + TempElts.push_back(CreateConstantFromJavaMethod(cl->staticMethods[i])); + } + + Constant* methods = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + methods = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + methods, "", this); + methods = ConstantExpr::getCast(Instruction::BitCast, methods, + JavaMethodType); + ClassElts.push_back(methods); + } else { + ClassElts.push_back(Constant::getNullValue(JavaMethodType)); + } + + // nbStaticMethods + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbStaticMethods)); + + // ownerClass + ClassElts.push_back(Constant::getNullValue(ptrType)); + + // bytes + ClassElts.push_back(Constant::getNullValue(JavaArrayUInt8Type)); + + // ctpInfo + ClassElts.push_back(Constant::getNullValue(ptrType)); + + // attributs + if (cl->nbAttributs) { + ATy = ArrayType::get(AttributType->getContainedType(0), + cl->nbAttributs); + + for (uint32 i = 0; i < cl->nbAttributs; ++i) { + TempElts.push_back(CreateConstantFromAttribut(cl->attributs[i])); + } + + Constant* attributs = ConstantArray::get(ATy, TempElts); + TempElts.clear(); + attributs = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + attributs, "", this); + attributs = ConstantExpr::getCast(Instruction::BitCast, attributs, + AttributType); + ClassElts.push_back(attributs); + } else { + ClassElts.push_back(Constant::getNullValue(AttributType)); + } + + // nbAttributs + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbAttributs)); + + // innerClasses + if (cl->nbInnerClasses) { + for (uint32 i = 0; i < cl->nbInnerClasses; ++i) { + TempElts.push_back(getNativeClass(cl->innerClasses[i], 0)); + } + + ATy = ArrayType::get(JavaClassType, cl->nbInnerClasses); + Constant* innerClasses = ConstantArray::get(ATy, TempElts); + innerClasses = new GlobalVariable(ATy, true, GlobalValue::InternalLinkage, + innerClasses, "", this); + innerClasses = ConstantExpr::getCast(Instruction::BitCast, innerClasses, + PointerType::getUnqual(JavaClassType)); + + ClassElts.push_back(innerClasses); + } else { + const Type* Ty = PointerType::getUnqual(JavaClassType); + ClassElts.push_back(Constant::getNullValue(Ty)); + } + + // nbInnerClasses + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->nbInnerClasses)); + + // outerClass + if (cl->outerClass) { + ClassElts.push_back(getNativeClass(cl->outerClass, 0)); + } else { + ClassElts.push_back(Constant::getNullValue(JavaClassType)); + } + + // innerAccess + ClassElts.push_back(ConstantInt::get(Type::Int16Ty, cl->innerAccess)); + + // innerOuterResolved + ClassElts.push_back(ConstantInt::get(Type::Int8Ty, cl->innerOuterResolved)); + + // virtualTableSize + ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->virtualTableSize)); + + // staticSize + ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->staticSize)); + + // JInfo + ClassElts.push_back(Constant::getNullValue(ptrType)); + + // staticTracer + Function* F = (Function*)(uintptr_t)cl->staticTracer; + const Type* FTy = STy->getContainedType(STy->getNumContainedTypes() - 1); + Constant* staticTracer = ConstantExpr::getCast(Instruction::BitCast, F, FTy); + ClassElts.push_back(staticTracer); + + return ConstantStruct::get(STy, ClassElts); +} + +Constant* JnjvmModule::CreateConstantFromUTF8(const UTF8* val) { + std::vector Elemts; + const ArrayType* ATy = ArrayType::get(Type::Int16Ty, val->size); + Elemts.push_back(JavaObjectType->getContainedType(0)); + Elemts.push_back(pointerSizeType == Type::Int32Ty ? Type::Int32Ty : + Type::Int64Ty); + + Elemts.push_back(ATy); + + const StructType* STy = StructType::get(Elemts); + + std::vector Cts; + Cts.push_back(Constant::getNullValue(JavaObjectType->getContainedType(0))); + Cts.push_back(ConstantInt::get(pointerSizeType, val->size)); + + std::vector Vals; + for (sint32 i = 0; i < val->size; ++i) { + Vals.push_back(ConstantInt::get(Type::Int16Ty, val->elements[i])); + } + + Cts.push_back(ConstantArray::get(ATy, Vals)); + + return ConstantStruct::get(STy, Cts); + +} + +Constant* JnjvmModule::getUTF8(const UTF8* val) { + utf8_iterator End = utf8s.end(); + utf8_iterator I = utf8s.find(val); + if (I == End) { + Constant* C = CreateConstantFromUTF8(val); + GlobalVariable* varGV = new GlobalVariable(C->getType(), true, + GlobalValue::ExternalLinkage, + C, "", this); + + Constant* res = ConstantExpr::getCast(Instruction::BitCast, varGV, + UTF8Type); + utf8s.insert(std::make_pair(val, res)); + + return res; + } else { + return I->second; + } +} + +Constant* JnjvmModule::CreateConstantFromVT(VirtualTable* VT, uint32 size) { + const ArrayType* ATy = dyn_cast(VTType->getContainedType(0)); + const PointerType* PTy = dyn_cast(ATy->getContainedType(0)); + ATy = ArrayType::get(PTy, size); + + ConstantPointerNull* N = ConstantPointerNull::get(PTy); + std::vector Elemts; + + Elemts.push_back(N); // Destructor + Elemts.push_back(N); // Delete + Elemts.push_back(N); // Tracer + 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); + } + + Constant* Array = ConstantArray::get(ATy, Elemts); + + return Array; +} + VirtualTable* JnjvmModule::makeVT(Class* cl) { VirtualTable* VT = 0; @@ -537,6 +1176,19 @@ #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 @@ -560,7 +1212,7 @@ if (!virtualType) { std::vector fields; - if (classDef->super) { + if (classDef->super && classDef->super->super) { LLVMClassInfo* CLI = JnjvmModule::getClassInfo((Class*)classDef->super); fields.push_back(CLI->getVirtualType()->getContainedType(0)); @@ -593,9 +1245,7 @@ virtualSizeConstant = ConstantInt::get(Type::Int32Ty, size); JnjvmModule* Mod = classDef->classLoader->getModule(); - if (!Mod->isStaticCompiling()) { - classDef->virtualVT = Mod->makeVT((Class*)classDef); - } + classDef->virtualVT = Mod->makeVT((Class*)classDef); } @@ -1057,7 +1707,10 @@ JavaCommonClassType = PointerType::getUnqual(module->getTypeByName("JavaCommonClass")); - + JavaClassPrimitiveType = + PointerType::getUnqual(module->getTypeByName("JavaClassPrimitive")); + JavaClassArrayType = + PointerType::getUnqual(module->getTypeByName("JavaClassArray")); JavaClassType = PointerType::getUnqual(module->getTypeByName("JavaClass")); @@ -1087,6 +1740,15 @@ EnveloppeType = PointerType::getUnqual(module->getTypeByName("Enveloppe")); + + JavaFieldType = + PointerType::getUnqual(module->getTypeByName("JavaField")); + JavaMethodType = + PointerType::getUnqual(module->getTypeByName("JavaMethod")); + UTF8Type = + PointerType::getUnqual(module->getTypeByName("UTF8")); + AttributType = + PointerType::getUnqual(module->getTypeByName("Attribut")); #ifdef WITH_TRACER MarkAndTraceType = module->getFunction("MarkAndTrace")->getFunctionType(); @@ -1117,13 +1779,16 @@ if (staticCompilation) { - PrimitiveArrayVT = new GlobalVariable(VTType, false, + const ArrayType* ATy = dyn_cast(VTType->getContainedType(0)); + const PointerType* PTy = dyn_cast(ATy->getContainedType(0)); + ATy = ArrayType::get(PTy, 16); + PrimitiveArrayVT = new GlobalVariable(ATy, true, GlobalValue::ExternalLinkage, - 0, "", this); + 0, "PrimitiveArrayVT", this); - ReferenceArrayVT = new GlobalVariable(VTType, false, + ReferenceArrayVT = new GlobalVariable(ATy, true, GlobalValue::ExternalLinkage, - 0, "", this); + 0, "ReferenceArrayVT", this); } else { PrimitiveArrayVT = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(JavaArray::VT)), @@ -1137,30 +1802,12 @@ LLVMAssessorInfo::initialise(); } -Value* JnjvmModule::getReferenceArrayVT(Value* Where) { - if (staticCompilation) { - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(ReferenceArrayVT, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(ReferenceArrayVT, "", dyn_cast(Where)); - } - } else { - return ReferenceArrayVT; - } +Constant* JnjvmModule::getReferenceArrayVT(Value* Where) { + return ReferenceArrayVT; } -Value* JnjvmModule::getPrimitiveArrayVT(Value* Where) { - if (staticCompilation) { - if (BasicBlock* BB = dyn_cast(Where)) { - return new LoadInst(PrimitiveArrayVT, "", BB); - } else { - assert(dyn_cast(Where) && "Wrong use of module"); - return new LoadInst(PrimitiveArrayVT, "", dyn_cast(Where)); - } - } else { - return PrimitiveArrayVT; - } +Constant* JnjvmModule::getPrimitiveArrayVT(Value* Where) { + return PrimitiveArrayVT; } void JnjvmModule::setMethod(JavaMethod* meth, const char* name) { @@ -1301,6 +1948,8 @@ addTypeName("JavaArray", JavaArrayType); addTypeName("JavaCommonClass", JavaCommonClassType); addTypeName("JavaClass", JavaClassType); + addTypeName("JavaClassPrimitive", JavaClassPrimitiveType); + addTypeName("JavaClassArray", JavaClassArrayType); addTypeName("ArrayUInt8", JavaArrayUInt8Type); addTypeName("ArraySInt8", JavaArraySInt8Type); addTypeName("ArrayUInt16", JavaArrayUInt16Type); @@ -1406,7 +2055,7 @@ #ifdef SERVICE Value* JnjvmModule::getIsolate(Jnjvm* isolate, Value* Where) { if (staticCompilation) { - llvm::GlobalVariable* varGV = 0; + llvm::Constant* varGV = 0; isolate_iterator End = isolates.end(); isolate_iterator I = isolates.find(isolate); if (I == End) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61262&r1=61261&r2=61262&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Fri Dec 19 16:20:27 2008 @@ -28,8 +28,10 @@ namespace jnjvm { +class CacheNode; class CommonClass; class Class; +class Enveloppe; class JavaField; class JavaMethod; class JavaObject; @@ -176,39 +178,43 @@ class JnjvmModule : public mvm::MvmModule { friend class LLVMClassInfo; private: - std::map nativeClasses; - std::map javaClasses; - std::map virtualTables; - std::map staticInstances; - std::map constantPools; - std::map strings; - std::map enveloppes; - std::map nativeFunctions; + std::map nativeClasses; + std::map javaClasses; + std::map virtualTables; + std::map staticInstances; + std::map constantPools; + std::map strings; + std::map enveloppes; + std::map nativeFunctions; + std::map utf8s; - typedef std::map::iterator + typedef std::map::iterator native_class_iterator; - typedef std::map::iterator + typedef std::map::iterator java_class_iterator; - typedef std::map::iterator + typedef std::map::iterator virtual_table_iterator; - typedef std::map::iterator + typedef std::map::iterator static_instance_iterator; - typedef std::map::iterator + typedef std::map::iterator constant_pool_iterator; - typedef std::map::iterator + typedef std::map::iterator string_iterator; - typedef std::map::iterator + typedef std::map::iterator enveloppe_iterator; - typedef std::map::iterator + typedef std::map::iterator native_function_iterator; + typedef std::map::iterator + utf8_iterator; + bool staticCompilation; @@ -217,8 +223,8 @@ VirtualTable* makeVT(Class* cl); VirtualTable* allocateVT(Class* cl); - static llvm::Value* PrimitiveArrayVT; - static llvm::Value* ReferenceArrayVT; + static llvm::Constant* PrimitiveArrayVT; + static llvm::Constant* ReferenceArrayVT; public: @@ -251,10 +257,16 @@ static const llvm::Type* JavaArrayType; static const llvm::Type* JavaCommonClassType; static const llvm::Type* JavaClassType; + static const llvm::Type* JavaClassArrayType; + static const llvm::Type* JavaClassPrimitiveType; static const llvm::Type* JavaCacheType; static const llvm::Type* EnveloppeType; static const llvm::Type* CacheNodeType; static const llvm::Type* ConstantPoolType; + static const llvm::Type* UTF8Type; + static const llvm::Type* JavaMethodType; + static const llvm::Type* JavaFieldType; + static const llvm::Type* AttributType; #ifdef ISOLATE_SHARING static const llvm::Type* JnjvmType; @@ -377,18 +389,18 @@ void initialise(); void printStats(); - llvm::Value* getNativeClass(CommonClass* cl, llvm::Value* Where); - llvm::Value* getJavaClass(CommonClass* cl, llvm::Value* Where); - llvm::Value* getStaticInstance(Class* cl, llvm::Value* Where); - llvm::Value* getVirtualTable(Class* cl, llvm::Value* Where); - - llvm::Value* getEnveloppe(Enveloppe* enveloppe, llvm::Value* Where); - llvm::Value* getString(JavaString* str, llvm::Value* Where); - llvm::Value* getConstantPool(JavaConstantPool* ctp, llvm::Value* Where); - llvm::Value* getNativeFunction(JavaMethod* meth, void* natPtr, llvm::Value* Where); + llvm::Constant* getNativeClass(CommonClass* cl, llvm::Value* Where); + llvm::Constant* getJavaClass(CommonClass* cl, llvm::Value* Where); + llvm::Constant* getStaticInstance(Class* cl, llvm::Value* Where); + llvm::Constant* getVirtualTable(Class* cl, llvm::Value* Where); + + llvm::Constant* getEnveloppe(Enveloppe* enveloppe, llvm::Value* Where); + llvm::Constant* getString(JavaString* str, llvm::Value* Where); + llvm::Constant* getConstantPool(JavaConstantPool* ctp, llvm::Value* Where); + llvm::Constant* getNativeFunction(JavaMethod* meth, void* natPtr, llvm::Value* Where); - llvm::Value* getReferenceArrayVT(llvm::Value* Where); - llvm::Value* getPrimitiveArrayVT(llvm::Value* Where); + llvm::Constant* getReferenceArrayVT(llvm::Value* Where); + llvm::Constant* getPrimitiveArrayVT(llvm::Value* Where); #ifdef SERVICE std::map isolates; @@ -398,9 +410,26 @@ llvm::Value* getIsolate(Jnjvm* vm, llvm::Value* Where); #endif + private: static llvm::Module* initialModule; - + + //--------------- Static compiler specific functions -----------------------// + llvm::Constant* CreateConstantFromVT(VirtualTable* VT, uint32 size); + llvm::Constant* CreateConstantFromUTF8(const UTF8* val); + llvm::Constant* CreateConstantFromEnveloppe(Enveloppe* val); + llvm::Constant* CreateConstantFromCacheNode(CacheNode* CN); + llvm::Constant* CreateConstantFromCommonClass(CommonClass* cl); + llvm::Constant* CreateConstantFromClass(Class* cl); + llvm::Constant* CreateConstantFromClassPrimitive(ClassPrimitive* cl); + llvm::Constant* CreateConstantFromClassArray(ClassArray* cl); + llvm::Constant* CreateConstantFromAttribut(Attribut& attribut); + llvm::Constant* CreateConstantFromJavaField(JavaField& field); + llvm::Constant* CreateConstantFromJavaMethod(JavaMethod& method); + llvm::Constant* CreateConstantFromJavaString(JavaString* str); + llvm::Constant* CreateConstantFromJavaClass(CommonClass* cl); + llvm::Constant* CreateConstantForJavaObject(CommonClass* cl); + llvm::Constant* getUTF8(const UTF8* val); }; } Modified: vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp?rev=61262&r1=61261&r2=61262&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp Fri Dec 19 16:20:27 2008 @@ -113,7 +113,9 @@ ConstantExpr* CE = dyn_cast(VT); if (CE) { - ConstantInt* C = (ConstantInt*)CE->getOperand(0); + ConstantInt* C = dyn_cast(CE->getOperand(0)); + if (!C) return false; + VirtualTable* Table = (VirtualTable*)C->getZExtValue(); ConstantInt* CI = dyn_cast(Size); // If the class has a finalize method, do not stack allocate the object. From nicolas.geoffray at lip6.fr Fri Dec 19 14:46:01 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 19 Dec 2008 22:46:01 -0000 Subject: [vmkit-commits] [vmkit] r61266 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JavaJITOpcodes.cpp JnjvmModule.cpp JnjvmModule.h Message-ID: <200812192246.mBJMk2S4005677@zion.cs.uiuc.edu> Author: geoffray Date: Fri Dec 19 16:46:00 2008 New Revision: 61266 URL: http://llvm.org/viewvc/llvm-project?rev=61266&view=rev Log: Code cleanup. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61266&r1=61265&r2=61266&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Fri Dec 19 16:46:00 2008 @@ -93,7 +93,7 @@ if (meth && !isAbstract(meth->access) && canBeInlined(meth)) { Value* cl = CallInst::Create(module->GetClassFunction, args[0], "", currentBlock); - Value* cl2 = module->getNativeClass((Class*)cl, currentBlock); + Value* cl2 = module->getNativeClass(meth->classDef); Value* test = new ICmpInst(ICmpInst::ICMP_EQ, cl, cl2, "", currentBlock); @@ -245,7 +245,7 @@ val, "", currentBlock); nativeArgs.push_back(res); #else - Value* cl = module->getJavaClass(compilingClass, currentBlock); + Value* cl = module->getJavaClass(compilingClass); nativeArgs.push_back(cl); #endif index = 2; @@ -258,8 +258,7 @@ nativeArgs.push_back(i); } - Value* nativeFunc = module->getNativeFunction(compilingMethod, (void*)natPtr, - currentBlock); + Value* nativeFunc = module->getNativeFunction(compilingMethod, (void*)natPtr); Value* result = llvm::CallInst::Create(nativeFunc, nativeArgs.begin(), nativeArgs.end(), "", currentBlock); @@ -399,7 +398,7 @@ if (isVirtual(compilingMethod->access)) { obj = llvmFunction->arg_begin(); } else { - obj = module->getJavaClass(compilingClass, currentBlock); + obj = module->getJavaClass(compilingClass); } monitorEnter(obj); } @@ -409,7 +408,7 @@ if (isVirtual(compilingMethod->access)) { obj = llvmFunction->arg_begin(); } else { - obj = module->getJavaClass(compilingClass, currentBlock); + obj = module->getJavaClass(compilingClass); } monitorExit(obj); } @@ -833,8 +832,7 @@ if (isVirtual(compilingMethod->access)) { argsSync = llvmFunction->arg_begin(); } else { - Value* cl = module->getJavaClass(compilingClass, - synchronizeExceptionBlock); + Value* cl = module->getJavaClass(compilingClass); argsSync = cl; } CallInst::Create(module->ReleaseObjectFunction, argsSync, "", @@ -994,7 +992,7 @@ isolateLocal, "", currentBlock); #else assert(cur->catchClass); - cl = module->getNativeClass(cur->catchClass, currentBlock); + cl = module->getNativeClass(cur->catchClass); #endif #ifdef SERVICE @@ -1155,7 +1153,7 @@ const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8); - Value* val = module->getString(str, currentBlock); + Value* val = module->getString(str); push(val, false); #endif @@ -1176,7 +1174,7 @@ Value* res = getResolvedCommonClass(index, false, &cl); #ifndef ISOLATE - if (cl) res = module->getJavaClass(cl, currentBlock); + if (cl) res = module->getJavaClass(cl); else #endif @@ -1640,8 +1638,8 @@ Cl = new LoadInst(Cl, "", currentBlock); #else JavaConstantPool* ctp = compilingClass->ctpInfo; - Value* CTP = module->getConstantPool(ctp, currentBlock); - Value* Cl = module->getNativeClass(compilingClass, currentBlock); + Value* CTP = module->getConstantPool(ctp); + Value* Cl = module->getNativeClass(compilingClass); #endif std::vector Args; @@ -1679,7 +1677,7 @@ Value* node = 0; if (cl && (!cl->isClass() || cl->asClass()->isResolved())) { if (alreadyResolved) *alreadyResolved = cl; - node = module->getNativeClass(cl, currentBlock); + node = module->getNativeClass(cl); if (node->getType() != module->JavaCommonClassType) { node = new BitCastInst(node, module->JavaCommonClassType, "", currentBlock); @@ -1700,7 +1698,7 @@ Value* node = 0; if (cl && cl->isResolved()) { if (alreadyResolved) (*alreadyResolved) = cl; - node = module->getNativeClass(cl, currentBlock); + node = module->getNativeClass(cl); } else { node = getConstantPoolAt(index, module->ClassLookupFunction, module->JavaCommonClassType, 0, doThrow); @@ -1726,7 +1724,7 @@ Value* Size = 0; if (cl) { - VT = module->getVirtualTable(cl, currentBlock); + VT = module->getVirtualTable(cl); LLVMClassInfo* LCI = module->getClassInfo(cl); Size = LCI->getVirtualSize(); } else { @@ -1791,7 +1789,7 @@ const Type* type = 0; if (stat) { type = LCI->getStaticType(); - Value* Cl = module->getNativeClass(field->classDef, currentBlock); + Value* Cl = module->getNativeClass(field->classDef); bool needsCheck = needsInitialisationCheck(field->classDef, compilingClass); if (needsCheck) { @@ -1804,7 +1802,7 @@ currentBlock); } - object = module->getStaticInstance(field->classDef, currentBlock); + object = module->getStaticInstance(field->classDef); #else object = CallInst::Create(module->GetStaticInstanceFunction, Cl, "", currentBlock); @@ -2036,7 +2034,7 @@ enveloppe.initialise(compilingClass->classLoader->allocator, name, signature->keyName); - Value* llvmEnv = module->getEnveloppe(&enveloppe, currentBlock); + Value* llvmEnv = module->getEnveloppe(&enveloppe); #else Value* llvmEnv = getConstantPoolAt(index, module->EnveloppeLookupFunction, Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=61266&r1=61265&r2=61266&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Fri Dec 19 16:46:00 2008 @@ -1838,7 +1838,7 @@ JnjvmBootstrapLoader* loader = compilingClass->classLoader->bootstrapLoader; UserClassArray* dcl = loader->getArrayClass(id); - valCl = module->getNativeClass(dcl, currentBlock); + valCl = module->getNativeClass(dcl); #else Value* args[2] = { isolateLocal, ConstantInt::get(Type::Int32Ty, id - 4) }; @@ -1848,7 +1848,7 @@ LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[charId]; sizeElement = LAI.sizeInBytesConstant; - TheVT = module->getPrimitiveArrayVT(currentBlock); + TheVT = module->getPrimitiveArrayVT(); } else { uint16 index = readU2(bytecodes, i); CommonClass* cl = 0; @@ -1859,7 +1859,7 @@ const UTF8* arrayName = JCL->constructArrayName(1, cl->name); UserCommonClass* dcl = JCL->constructArray(arrayName); - valCl = module->getNativeClass(dcl, currentBlock); + valCl = module->getNativeClass(dcl); } else { const llvm::Type* Ty = @@ -1870,9 +1870,9 @@ } sizeElement = module->constantPtrSize; - TheVT = module->getReferenceArrayVT(currentBlock); + TheVT = module->getReferenceArrayVT(); } - llvm::Value* arg1 = popAsInt(); + Value* arg1 = popAsInt(); Value* cmp = new ICmpInst(ICmpInst::ICMP_SLT, arg1, module->constantZero, "", currentBlock); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61266&r1=61265&r2=61266&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Dec 19 16:46:00 2008 @@ -82,7 +82,7 @@ llvm::ConstantInt* JnjvmModule::JavaObjectLockOffsetConstant; llvm::ConstantInt* JnjvmModule::JavaObjectClassOffsetConstant; -Constant* JnjvmModule::getNativeClass(CommonClass* classDef, Value* Where) { +Constant* JnjvmModule::getNativeClass(CommonClass* classDef) { if (staticCompilation) { native_class_iterator End = nativeClasses.end(); @@ -129,7 +129,7 @@ } } -Constant* JnjvmModule::getConstantPool(JavaConstantPool* ctp, Value* Where) { +Constant* JnjvmModule::getConstantPool(JavaConstantPool* ctp) { if (staticCompilation) { llvm::Constant* varGV = 0; constant_pool_iterator End = constantPools.end(); @@ -152,7 +152,7 @@ } } -Constant* JnjvmModule::getString(JavaString* str, Value* Where) { +Constant* JnjvmModule::getString(JavaString* str) { if (staticCompilation) { string_iterator SI = strings.find(str); if (SI != strings.end()) { @@ -180,7 +180,7 @@ } } -Constant* JnjvmModule::getEnveloppe(Enveloppe* enveloppe, Value* Where) { +Constant* JnjvmModule::getEnveloppe(Enveloppe* enveloppe) { if (staticCompilation) { enveloppe_iterator SI = enveloppes.find(enveloppe); if (SI != enveloppes.end()) { @@ -203,7 +203,7 @@ } } -Constant* JnjvmModule::getJavaClass(CommonClass* cl, Value* Where) { +Constant* JnjvmModule::getJavaClass(CommonClass* cl) { if (staticCompilation) { java_class_iterator End = javaClasses.end(); java_class_iterator I = javaClasses.find(cl); @@ -234,7 +234,7 @@ } } -Constant* JnjvmModule::getStaticInstance(Class* classDef, Value* Where) { +Constant* JnjvmModule::getStaticInstance(Class* classDef) { #ifdef ISOLATE assert(0 && "Should not be here"); abort(); @@ -275,7 +275,7 @@ } } -Constant* JnjvmModule::getVirtualTable(Class* classDef, Value* Where) { +Constant* JnjvmModule::getVirtualTable(Class* classDef) { if (staticCompilation) { llvm::Constant* res = 0; virtual_table_iterator End = virtualTables.end(); @@ -310,8 +310,7 @@ } } -Constant* JnjvmModule::getNativeFunction(JavaMethod* meth, void* ptr, - Value* Where) { +Constant* JnjvmModule::getNativeFunction(JavaMethod* meth, void* ptr) { if (staticCompilation) { llvm::Constant* varGV = 0; native_function_iterator End = nativeFunctions.end(); @@ -466,7 +465,7 @@ std::vector Elmts; if (cl->isClass()) { - Elmts.push_back(getVirtualTable(cl->asClass(), 0)); + Elmts.push_back(getVirtualTable(cl->asClass())); } else { ClassArray* clA = cl->asArrayClass(); if (clA->baseClass()->isPrimitive()) { @@ -476,7 +475,7 @@ } } - Constant* Cl = getNativeClass(cl, 0); + Constant* Cl = getNativeClass(cl); Constant* ClGEPs[2] = { constantZero, constantZero }; Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2); @@ -503,7 +502,7 @@ Elmts.push_back(Constant::getNullValue(JavaObjectType)); // vmdata - Constant* Cl = getNativeClass(cl, 0); + Constant* Cl = getNativeClass(cl); Cl = ConstantExpr::getCast(Instruction::BitCast, Cl, JavaObjectType); Elmts.push_back(Cl); @@ -544,7 +543,7 @@ Elmts.push_back(Constant::getNullValue(STy->getContainedType(0))); Elmts.push_back(Constant::getNullValue(STy->getContainedType(1))); Elmts.push_back(Constant::getNullValue(STy->getContainedType(2))); - Elmts.push_back(getEnveloppe(CN->enveloppe, 0)); + Elmts.push_back(getEnveloppe(CN->enveloppe)); return ConstantStruct::get(STy, Elmts); } @@ -604,7 +603,7 @@ // display for (uint32 i = 0; i <= cl->depth; ++i) { - Constant* Cl = getNativeClass(cl->display[i], 0); + Constant* Cl = getNativeClass(cl->display[i]); if (Cl->getType() != JavaCommonClassType) Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2); @@ -635,7 +634,7 @@ // interfaces if (cl->nbInterfaces) { for (uint32 i = 0; i < cl->nbInterfaces; ++i) { - TempElmts.push_back(getNativeClass(cl->interfaces[i], 0)); + TempElmts.push_back(getNativeClass(cl->interfaces[i])); } ATy = ArrayType::get(JavaClassType, cl->nbInterfaces); @@ -659,7 +658,7 @@ // super if (cl->super) { - CommonClassElts.push_back(getNativeClass(cl->super, 0)); + CommonClassElts.push_back(getNativeClass(cl->super)); } else { CommonClassElts.push_back(Constant::getNullValue(JavaClassType)); } @@ -713,7 +712,7 @@ FieldElts.push_back(ConstantInt::get(Type::Int16Ty, field.nbAttributs)); // classDef - FieldElts.push_back(getNativeClass(field.classDef, 0)); + FieldElts.push_back(getNativeClass(field.classDef)); // ptrOffset FieldElts.push_back(ConstantInt::get(Type::Int32Ty, field.ptrOffset)); @@ -772,7 +771,7 @@ MethodElts.push_back(ConstantInt::get(Type::Int16Ty, 0)); // classDef - MethodElts.push_back(getNativeClass(method.classDef, 0)); + MethodElts.push_back(getNativeClass(method.classDef)); // name MethodElts.push_back(getUTF8(method.name)); @@ -824,7 +823,7 @@ ClassElts.push_back(CreateConstantFromCommonClass(cl)); // baseClass - Constant* Cl = getNativeClass(cl->baseClass(), 0); + Constant* Cl = getNativeClass(cl->baseClass()); if (Cl->getType() != JavaCommonClassType) Cl = ConstantExpr::getGetElementPtr(Cl, ClGEPs, 2); @@ -847,7 +846,7 @@ ClassElts.push_back(ConstantInt::get(Type::Int32Ty, cl->virtualSize)); // virtualTable - ClassElts.push_back(getVirtualTable(cl, 0)); + ClassElts.push_back(getVirtualTable(cl)); // IsolateInfo const ArrayType* ATy = dyn_cast(STy->getContainedType(3)); @@ -857,7 +856,7 @@ assert(TCMTy && "Malformed type"); TempElts.push_back(ConstantInt::get(Type::Int32Ty, ready)); - TempElts.push_back(getStaticInstance(cl, 0)); + TempElts.push_back(getStaticInstance(cl)); Constant* CStr[1] = { ConstantStruct::get(TCMTy, TempElts) }; TempElts.clear(); ClassElts.push_back(ConstantArray::get(ATy, CStr, 1)); @@ -988,7 +987,7 @@ // innerClasses if (cl->nbInnerClasses) { for (uint32 i = 0; i < cl->nbInnerClasses; ++i) { - TempElts.push_back(getNativeClass(cl->innerClasses[i], 0)); + TempElts.push_back(getNativeClass(cl->innerClasses[i])); } ATy = ArrayType::get(JavaClassType, cl->nbInnerClasses); @@ -1009,7 +1008,7 @@ // outerClass if (cl->outerClass) { - ClassElts.push_back(getNativeClass(cl->outerClass, 0)); + ClassElts.push_back(getNativeClass(cl->outerClass)); } else { ClassElts.push_back(Constant::getNullValue(JavaClassType)); } @@ -1802,11 +1801,11 @@ LLVMAssessorInfo::initialise(); } -Constant* JnjvmModule::getReferenceArrayVT(Value* Where) { +Constant* JnjvmModule::getReferenceArrayVT() { return ReferenceArrayVT; } -Constant* JnjvmModule::getPrimitiveArrayVT(Value* Where) { +Constant* JnjvmModule::getPrimitiveArrayVT() { return PrimitiveArrayVT; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61266&r1=61265&r2=61266&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Fri Dec 19 16:46:00 2008 @@ -389,18 +389,18 @@ void initialise(); void printStats(); - llvm::Constant* getNativeClass(CommonClass* cl, llvm::Value* Where); - llvm::Constant* getJavaClass(CommonClass* cl, llvm::Value* Where); - llvm::Constant* getStaticInstance(Class* cl, llvm::Value* Where); - llvm::Constant* getVirtualTable(Class* cl, llvm::Value* Where); - - llvm::Constant* getEnveloppe(Enveloppe* enveloppe, llvm::Value* Where); - llvm::Constant* getString(JavaString* str, llvm::Value* Where); - llvm::Constant* getConstantPool(JavaConstantPool* ctp, llvm::Value* Where); - llvm::Constant* getNativeFunction(JavaMethod* meth, void* natPtr, llvm::Value* Where); + llvm::Constant* getNativeClass(CommonClass* cl); + llvm::Constant* getJavaClass(CommonClass* cl); + llvm::Constant* getStaticInstance(Class* cl); + llvm::Constant* getVirtualTable(Class* cl); + + llvm::Constant* getEnveloppe(Enveloppe* enveloppe); + llvm::Constant* getString(JavaString* str); + llvm::Constant* getConstantPool(JavaConstantPool* ctp); + llvm::Constant* getNativeFunction(JavaMethod* meth, void* natPtr); - llvm::Constant* getReferenceArrayVT(llvm::Value* Where); - llvm::Constant* getPrimitiveArrayVT(llvm::Value* Where); + llvm::Constant* getReferenceArrayVT(); + llvm::Constant* getPrimitiveArrayVT(); #ifdef SERVICE std::map isolates; From nicolas.geoffray at lip6.fr Sat Dec 27 07:42:24 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 27 Dec 2008 15:42:24 -0000 Subject: [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/ Message-ID: <200812271542.mBRFgQf4030230@zion.cs.uiuc.edu> 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 $( -#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 { 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 { 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(JavaObjectType->getContainedType(0)); std::vector 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 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(VTType->getContainedType(0)); const PointerType* PTy = dyn_cast(ATy->getContainedType(0)); ATy = ArrayType::get(PTy, size); ConstantPointerNull* N = ConstantPointerNull::get(PTy); std::vector 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 + #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 #include +#include #include #include #include +#include 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 #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); From nicolas.geoffray at lip6.fr Mon Dec 29 00:58:16 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 29 Dec 2008 08:58:16 -0000 Subject: [vmkit-commits] [vmkit] r61466 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JnjvmModuleProvider.cpp Message-ID: <200812290858.mBT8wOUA008759@zion.cs.uiuc.edu> Author: geoffray Date: Mon Dec 29 02:57:57 2008 New Revision: 61466 URL: http://llvm.org/viewvc/llvm-project?rev=61466&view=rev Log: Do not initialize a class when materializing a function. Make sure the class has already been loaded and initialized. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61466&r1=61465&r2=61466&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Dec 29 02:57:57 2008 @@ -1592,21 +1592,13 @@ args.push_back(newCtpCache); #endif - // If we're not static compiling or we're not in an isolate environment, - // the callback will do the initialization -#ifndef ISOLATE - if (module->isStaticCompiling()) { -#endif - uint32 clIndex = ctpInfo->getClassIndexFromMethod(index); - UserClass* cl = 0; - Value* Cl = getResolvedClass(clIndex, true, true, &cl); - if (!meth || (cl && needsInitialisationCheck(cl, compilingClass))) { - CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", - currentBlock); - } -#ifndef ISOLATE + uint32 clIndex = ctpInfo->getClassIndexFromMethod(index); + UserClass* cl = 0; + Value* Cl = getResolvedClass(clIndex, true, true, &cl); + if (!meth || (cl && needsInitialisationCheck(cl, compilingClass))) { + CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", + currentBlock); } -#endif if (meth && canBeInlined(meth)) { val = invokeInline(meth, args); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=61466&r1=61465&r2=61466&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Mon Dec 29 02:57:57 2008 @@ -53,15 +53,8 @@ JavaMethod* meth = lookup->lookupMethod(utf8, sign->keyName, isStatic, true, 0); -#ifndef ISOLATE_SHARING - // A multi environment would have already initialized the class. Besides, - // a callback does not involve UserClass, therefore we wouldn't know - // which class to initialize. - if (!isVirtual(meth->access)) - lookup->initialiseClass(JavaThread::get()->getJVM()); -#endif + assert(lookup->isInitializing() && "Class not ready"); - meth->compiledPtr(); return meth; } From nicolas.geoffray at lip6.fr Tue Dec 30 01:32:06 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 09:32:06 -0000 Subject: [vmkit-commits] [vmkit] r61487 - in /vmkit/trunk: include/mvm/Threads/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/ lib/Mvm/Runtime/ Message-ID: <200812300932.mBU9WEt6024015@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 03:31:45 2008 New Revision: 61487 URL: http://llvm.org/viewvc/llvm-project?rev=61487&view=rev Log: Major rewrite on how a the JVM walks the stack. When entering Java code or enterring native code, the JVM pushes the return address in a thread-specific stack. Therefore, we know if a frame belongs to a native function or a Java function. When the method pointer of a Java method is known, the JVM registers the pointer in a map so that we know for a given instruction pointer which method it beongs to. Modified: vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 30 03:31:45 2008 @@ -51,6 +51,12 @@ }; +#if defined(__MACH__) && !defined(__i386__) +#define FRAME_IP(fp) (fp[2]) +#else +#define FRAME_IP(fp) (fp[1]) +#endif + /// Thread - This class is the base of custom virtual machines' Thread classes. /// It provides static functions to manage threads. An instance of this class /// contains all thread-specific informations. Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Tue Dec 30 03:31:45 2008 @@ -29,16 +29,22 @@ #endif jclass Cl) { + bool res = false; + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(Cl); Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); - if (!cl->asClass()) return false; - if (cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName, + + if (cl->isClass() && + cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName, vm->bootstrapLoader->clinitType, true, false, 0)) - return true; - - return false; + res = true; + + END_NATIVE_EXCEPTION + + return res; } @@ -51,11 +57,16 @@ jclass clazz, #endif jobject Field, jobject obj, jboolean val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt8Field((JavaObject*)obj, (uint8)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative( @@ -64,11 +75,16 @@ jclass clazz, #endif jobject Field, jobject obj, jbyte val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt8Field((JavaObject*)obj, (uint8)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative( @@ -77,11 +93,16 @@ jclass clazz, #endif jobject Field, jobject obj, jchar val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt16Field((JavaObject*)obj, (uint16)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative( @@ -90,11 +111,16 @@ jclass clazz, #endif jobject Field, jobject obj, jshort val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt16Field((JavaObject*)obj, (sint16)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative( @@ -103,11 +129,16 @@ jclass clazz, #endif jobject Field, jobject obj, jint val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt32Field((JavaObject*)obj, (sint32)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative( @@ -116,11 +147,16 @@ jclass clazz, #endif jobject Field, jobject obj, jlong val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setLongField((JavaObject*)obj, (sint64)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative( @@ -129,11 +165,16 @@ jclass clazz, #endif jobject Field, jobject obj, jfloat val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setFloatField((JavaObject*)obj, (float)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative( @@ -142,11 +183,16 @@ jclass clazz, #endif jobject Field, jobject obj, jdouble val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setDoubleField((JavaObject*)obj, (double)val); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative( @@ -155,11 +201,16 @@ jclass clazz, #endif jobject Field, jobject obj, jobject val) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(obj); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setObjectField((JavaObject*)obj, (JavaObject*)val); + + END_NATIVE_EXCEPTION } JNIEXPORT jobject JNICALL Java_java_io_VMObjectInputStream_allocateObject( @@ -168,13 +219,22 @@ jclass clazz, #endif jclass target, jclass constr, jobject cons) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, target, true); - JavaObject* res = cl->doNew(vm); + JavaObject* obj = cl->doNew(vm); JavaField* field = vm->upcalls->constructorSlot; JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); - meth->invokeIntSpecial(vm, cl, res); - return (jobject)res; + meth->invokeIntSpecial(vm, cl, obj); + res = (jobject)obj; + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jobject JNICALL Java_java_lang_reflect_VMArray_createObjectArray( @@ -183,16 +243,26 @@ jclass thisClass, #endif jclass arrayType, jint arrayLength) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* base = NativeUtil::resolvedImplClass(vm, arrayType, true); JnjvmClassLoader* loader = base->classLoader; const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); UserClassArray* array = loader->constructArray(arrayName, base); - return (jobject)array->doNew(arrayLength, vm); + res = (jobject)array->doNew(arrayLength, vm); + + END_NATIVE_EXCEPTION + + return res; } +// Never throws. JNIEXPORT bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8( #ifdef NATIVE_JNI @@ -203,6 +273,7 @@ return false; } +// Never throws. JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong( #ifdef NATIVE_JNI JNIEnv *env, @@ -225,6 +296,7 @@ } +// Never throws. JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt( #ifdef NATIVE_JNI JNIEnv *env, @@ -238,6 +310,7 @@ return __sync_bool_compare_and_swap(ptr, expect, update); } +// Never throws. JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject( #ifdef NATIVE_JNI JNIEnv *env, @@ -252,6 +325,7 @@ return __sync_bool_compare_and_swap(ptr, expect, update); } +// Never throws. JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile( #ifdef NATIVE_JNI JNIEnv *env, Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Tue Dec 30 03:31:45 2008 @@ -45,6 +45,11 @@ JNIEnv *env, #endif jobject cons) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(cons); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = vm->upcalls->constructorSlot; @@ -52,7 +57,10 @@ UserClass* cl = internalGetClass(vm, meth, cons); JnjvmClassLoader* loader = cl->classLoader; - return (jobject)(NativeUtil::getParameterTypes(loader, meth)); + res = (jobject)(NativeUtil::getParameterTypes(loader, meth)); + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal( @@ -60,21 +68,31 @@ JNIEnv *env, #endif jobject cons) { + + jint res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(cons); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = vm->upcalls->constructorSlot; JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); - return meth->access; + res = meth->access; + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_constructNative( #ifdef NATIVE_JNI JNIEnv *env, #endif -jobject _cons, -jobject _args, -jclass Clazz, -jint _meth) { +jobject _cons, jobject _args, jclass Clazz, jint _meth) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); JavaMethod* meth = (JavaMethod*)_meth; @@ -93,7 +111,8 @@ UserClass* cl = _cl->asClass(); if (cl) { cl->initialiseClass(vm); - JavaObject* res = cl->doNew(vm); + JavaObject* obj = cl->doNew(vm); + res = (jobject) obj; JavaObject** ptr = (JavaObject**)(void*)(args->elements); Typedef* const* arguments = sign->getArgumentsType(); @@ -104,7 +123,7 @@ JavaObject* excp = 0; try { - meth->invokeIntSpecialBuf(vm, cl, res, startBuf); + meth->invokeIntSpecialBuf(vm, cl, obj, startBuf); }catch(...) { excp = JavaThread::getJavaException(); JavaThread::clearException(); @@ -120,11 +139,16 @@ } } - return (jobject)res; + } else { + vm->illegalArgumentExceptionForMethod(meth, 0, 0); } + } else { + vm->illegalArgumentExceptionForMethod(meth, 0, 0); } - vm->illegalArgumentExceptionForMethod(meth, 0, 0); - return 0; + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT @@ -133,13 +157,22 @@ JNIEnv *env, #endif jobject cons) { + + jobjectArray res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(cons); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = vm->upcalls->constructorSlot; JavaMethod* meth = (JavaMethod*)field->getInt32Field((JavaObject*)cons); UserClass* cl = internalGetClass(vm, meth, cons); - return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); + res = (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); + + END_NATIVE_EXCEPTION + + return res; } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp Tue Dec 30 03:31:45 2008 @@ -36,10 +36,18 @@ JNIEnv *env, #endif jobject obj) { + jint res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)obj); - return field->access; + res = field->access; + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jclass JNICALL Java_java_lang_reflect_Field_getType( @@ -47,13 +55,22 @@ JNIEnv *env, #endif jobject obj) { + + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)obj); UserClass* fieldCl = internalGetClass(vm, field, obj); JnjvmClassLoader* loader = fieldCl->classLoader; UserCommonClass* cl = field->getSignature()->assocClass(loader); - return (jclass)cl->getClassDelegatee(vm); + res = (jclass)cl->getClassDelegatee(vm); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt( @@ -61,6 +78,11 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jint res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -80,17 +102,22 @@ const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isInt()) - return (sint32)field->getInt32Field(Obj); - if (prim->isChar()) - return (uint32)field->getInt16Field(Obj); - if (prim->isByte()) - return (sint32)field->getInt8Field(Obj); - if (prim->isShort()) - return (sint32)field->getInt16Field(Obj); + res = (sint32)field->getInt32Field(Obj); + else if (prim->isChar()) + res = (uint32)field->getInt16Field(Obj); + else if (prim->isByte()) + res = (sint32)field->getInt8Field(Obj); + else if (prim->isShort()) + res = (sint32)field->getInt16Field(Obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - vm->illegalArgumentException(""); - return 0; + END_NATIVE_EXCEPTION + + return res; } @@ -99,6 +126,11 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jlong res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -118,19 +150,24 @@ const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isInt()) - return (sint64)field->getInt32Field(Obj); - if (prim->isChar()) - return (uint64)field->getInt16Field(Obj); - if (prim->isByte()) - return (sint64)field->getInt8Field(Obj); - if (prim->isShort()) - return (sint64)field->getInt16Field(Obj); - if (prim->isLong()) - return (sint64)field->getLongField(Obj); + res = (sint64)field->getInt32Field(Obj); + else if (prim->isChar()) + res = (uint64)field->getInt16Field(Obj); + else if (prim->isByte()) + res = (sint64)field->getInt8Field(Obj); + else if (prim->isShort()) + res = (sint64)field->getInt16Field(Obj); + else if (prim->isLong()) + res = (sint64)field->getLongField(Obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } + + END_NATIVE_EXCEPTION - vm->illegalArgumentException(""); - return 0; + return res; } JNIEXPORT jboolean JNICALL Java_java_lang_reflect_Field_getBoolean( @@ -138,6 +175,11 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jboolean res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -156,12 +198,16 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isBool()) - return (uint8)field->getInt8Field(Obj); + res = (uint8)field->getInt8Field(Obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - vm->illegalArgumentException(""); + END_NATIVE_EXCEPTION - return 0; + return res; } @@ -170,6 +216,11 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jfloat res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -188,22 +239,27 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isByte()) - return (jfloat)field->getInt8Field(Obj); - if (prim->isInt()) - return (jfloat)field->getInt32Field((JavaObject*)obj); - if (prim->isShort()) - return (jfloat)field->getInt16Field((JavaObject*)obj); - if (prim->isLong()) - return (jfloat)field->getLongField((JavaObject*)obj); - if (prim->isChar()) + res = (jfloat)field->getInt8Field(Obj); + else if (prim->isInt()) + res = (jfloat)field->getInt32Field((JavaObject*)obj); + else if (prim->isShort()) + res = (jfloat)field->getInt16Field((JavaObject*)obj); + else if (prim->isLong()) + res = (jfloat)field->getLongField((JavaObject*)obj); + else if (prim->isChar()) // Cast to uint32 because char is unsigned. - return (jfloat)(uint32)field->getInt16Field((JavaObject*)obj); - if (prim->isFloat()) - return (jfloat)field->getFloatField((JavaObject*)obj); + res = (jfloat)(uint32)field->getInt16Field((JavaObject*)obj); + else if (prim->isFloat()) + res = (jfloat)field->getFloatField((JavaObject*)obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - vm->illegalArgumentException(""); - return 0.0; + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jbyte JNICALL Java_java_lang_reflect_Field_getByte( @@ -211,6 +267,11 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jbyte res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -229,12 +290,16 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isByte()) - return (sint8)field->getInt8Field(Obj); + res = (sint8)field->getInt8Field(Obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - vm->illegalArgumentException(""); + END_NATIVE_EXCEPTION - return 0; + return res; } JNIEXPORT jchar JNICALL Java_java_lang_reflect_Field_getChar( @@ -242,6 +307,12 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jchar res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -260,12 +331,16 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isChar()) - return (uint16)field->getInt16Field((JavaObject*)obj); + res = (uint16)field->getInt16Field((JavaObject*)obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } + + END_NATIVE_EXCEPTION - vm->illegalArgumentException(""); - - return 0; + return res; } @@ -274,6 +349,12 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + + jshort res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -292,14 +373,18 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isShort()) - return (sint16)field->getInt16Field(Obj); - if (prim->isByte()) - return (sint16)field->getInt8Field(Obj); + res = (sint16)field->getInt16Field(Obj); + else if (prim->isByte()) + res = (sint16)field->getInt8Field(Obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - vm->illegalArgumentException(""); - - return 0; + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jdouble JNICALL Java_java_lang_reflect_Field_getDouble( @@ -307,6 +392,11 @@ JNIEnv *env, #endif jobject Field, jobject obj) { + + jdouble res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -325,23 +415,28 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isByte()) - return (jdouble)(sint64)field->getInt8Field(Obj); - if (prim->isInt()) - return (jdouble)(sint64)field->getInt32Field(Obj); - if (prim->isShort()) - return (jdouble)(sint64)field->getInt16Field(Obj); - if (prim->isLong()) - return (jdouble)(sint64)field->getLongField(Obj); - if (prim->isChar()) - return (jdouble)(uint64)field->getInt16Field(Obj); - if (prim->isFloat()) - return (jdouble)field->getFloatField(Obj); - if (prim->isDouble()) - return (jdouble)field->getDoubleField(Obj); + res = (jdouble)(sint64)field->getInt8Field(Obj); + else if (prim->isInt()) + res = (jdouble)(sint64)field->getInt32Field(Obj); + else if (prim->isShort()) + res = (jdouble)(sint64)field->getInt16Field(Obj); + else if (prim->isLong()) + res = (jdouble)(sint64)field->getLongField(Obj); + else if (prim->isChar()) + res = (jdouble)(uint64)field->getInt16Field(Obj); + else if (prim->isFloat()) + res = (jdouble)field->getFloatField(Obj); + else if (prim->isDouble()) + res = (jdouble)field->getDoubleField(Obj); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); - return 0.0; + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jobject JNICALL Java_java_lang_reflect_Field_get( @@ -349,6 +444,12 @@ JNIEnv *env, #endif jobject Field, jobject _obj) { + + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -411,6 +512,8 @@ res = field->getObjectField(Obj); } + END_NATIVE_EXCEPTION + return (jobject)res; } @@ -419,6 +522,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jobject val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -442,27 +548,26 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isBool()) - return field->setInt8Field(Obj, ((uint8*)_buf)[0]); - if (prim->isByte()) - return field->setInt8Field(Obj, ((sint8*)_buf)[0]); - if (prim->isChar()) - return field->setInt16Field(Obj, ((uint16*)_buf)[0]); - if (prim->isShort()) - return field->setInt16Field(Obj, ((sint16*)_buf)[0]); - if (prim->isInt()) - return field->setInt32Field(Obj, ((sint32*)_buf)[0]); - if (prim->isLong()) - return field->setLongField(Obj, ((sint64*)_buf)[0]); - if (prim->isFloat()) - return field->setFloatField(Obj, ((float*)_buf)[0]); - if (prim->isDouble()) - return field->setDoubleField(Obj, ((double*)_buf)[0]); + field->setInt8Field(Obj, ((uint8*)_buf)[0]); + else if (prim->isByte()) + field->setInt8Field(Obj, ((sint8*)_buf)[0]); + else if (prim->isChar()) + field->setInt16Field(Obj, ((uint16*)_buf)[0]); + else if (prim->isShort()) + field->setInt16Field(Obj, ((sint16*)_buf)[0]); + else if (prim->isInt()) + field->setInt32Field(Obj, ((sint32*)_buf)[0]); + else if (prim->isLong()) + field->setLongField(Obj, ((sint64*)_buf)[0]); + else if (prim->isFloat()) + field->setFloatField(Obj, ((float*)_buf)[0]); + else if (prim->isDouble()) + field->setDoubleField(Obj, ((double*)_buf)[0]); } else { - return field->setObjectField(Obj, ((JavaObject**)_buf)[0]); + field->setObjectField(Obj, ((JavaObject**)_buf)[0]); } - // Unreachable code - return; + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean( @@ -470,6 +575,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jboolean val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -488,10 +596,14 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isBool()) - return field->setInt8Field(Obj, (uint8)val); + field->setInt8Field(Obj, (uint8)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - vm->illegalArgumentException(""); + END_NATIVE_EXCEPTION } @@ -500,6 +612,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jbyte val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -518,20 +633,24 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isByte()) - return field->setInt8Field(Obj, (sint8)val); - if (prim->isShort()) - return field->setInt16Field(Obj, (sint16)val); - if (prim->isInt()) - return field->setInt32Field(Obj, (sint32)val); - if (prim->isLong()) - return field->setLongField(Obj, (sint64)val); - if (prim->isFloat()) - return field->setFloatField(Obj, (float)val); - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); + field->setInt8Field(Obj, (sint8)val); + else if (prim->isShort()) + field->setInt16Field(Obj, (sint16)val); + else if (prim->isInt()) + field->setInt32Field(Obj, (sint32)val); + else if (prim->isLong()) + field->setLongField(Obj, (sint64)val); + else if (prim->isFloat()) + field->setFloatField(Obj, (float)val); + else if (prim->isDouble()) + field->setDoubleField(Obj, (double)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar( @@ -539,6 +658,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jchar val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -556,18 +678,22 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isChar()) - return field->setInt16Field(Obj, (uint16)val); - if (prim->isInt()) - return field->setInt32Field(Obj, (uint32)val); - if (prim->isLong()) - return field->setLongField(Obj, (uint64)val); - if (prim->isFloat()) - return field->setFloatField(Obj, (float)(uint32)val); - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)(uint64)val); + field->setInt16Field(Obj, (uint16)val); + else if (prim->isInt()) + field->setInt32Field(Obj, (uint32)val); + else if (prim->isLong()) + field->setLongField(Obj, (uint64)val); + else if (prim->isFloat()) + field->setFloatField(Obj, (float)(uint32)val); + else if (prim->isDouble()) + field->setDoubleField(Obj, (double)(uint64)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort( @@ -575,6 +701,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jshort val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -593,18 +722,22 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isShort()) - return field->setInt16Field(Obj, (sint16)val); - if (prim->isInt()) - return field->setInt32Field(Obj, (sint32)val); - if (prim->isLong()) - return field->setLongField(Obj, (sint64)val); - if (prim->isFloat()) - return field->setFloatField(Obj, (float)val); - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); + field->setInt16Field(Obj, (sint16)val); + else if (prim->isInt()) + field->setInt32Field(Obj, (sint32)val); + else if (prim->isLong()) + field->setLongField(Obj, (sint64)val); + else if (prim->isFloat()) + field->setFloatField(Obj, (float)val); + else if (prim->isDouble()) + field->setDoubleField(Obj, (double)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt( @@ -612,6 +745,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jint val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -630,16 +766,20 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isInt()) - return field->setInt32Field(Obj, (sint32)val); - if (prim->isLong()) - return field->setLongField(Obj, (sint64)val); - if (prim->isFloat()) - return field->setFloatField(Obj, (float)val); - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); + field->setInt32Field(Obj, (sint32)val); + else if (prim->isLong()) + field->setLongField(Obj, (sint64)val); + else if (prim->isFloat()) + field->setFloatField(Obj, (float)val); + else if (prim->isDouble()) + field->setDoubleField(Obj, (double)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong( @@ -647,6 +787,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jlong val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -665,14 +808,18 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isLong()) - return field->setLongField(Obj, (sint64)val); - if (prim->isFloat()) - return field->setFloatField(Obj, (float)val); - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); + field->setLongField(Obj, (sint64)val); + else if (prim->isFloat()) + field->setFloatField(Obj, (float)val); + else if (prim->isDouble()) + field->setDoubleField(Obj, (double)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat( @@ -680,6 +827,10 @@ JNIEnv *env, #endif jobject Field, jobject obj, jfloat val) { + + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -698,12 +849,16 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isFloat()) - return field->setFloatField(Obj, (float)val); - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); + field->setFloatField(Obj, (float)val); + else if (prim->isDouble()) + field->setDoubleField(Obj, (double)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble( @@ -711,6 +866,9 @@ JNIEnv *env, #endif jobject Field, jobject obj, jdouble val) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->fieldSlot; JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); @@ -729,12 +887,17 @@ if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); + field->setDoubleField(Obj, (double)val); + else + vm->illegalArgumentException(""); + } else { + vm->illegalArgumentException(""); } - - vm->illegalArgumentException(""); + + END_NATIVE_EXCEPTION } +// Never throws. JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset( #ifdef NATIVE_JNI JNIEnv *env, Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Tue Dec 30 03:31:45 2008 @@ -46,10 +46,20 @@ JNIEnv *env, #endif jobject Meth) { + + jint res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->methodSlot; JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); - return meth->access; + + res = meth->access; + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jclass JNICALL Java_java_lang_reflect_Method_getReturnType( @@ -57,13 +67,22 @@ JNIEnv *env, #endif jobject Meth) { + + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->methodSlot; JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; Typedef* ret = meth->getSignature()->getReturnType(); - return (jclass)NativeUtil::getClassType(loader, ret); + res = (jclass)NativeUtil::getClassType(loader, ret); + + END_NATIVE_EXCEPTION + + return res; } @@ -72,12 +91,21 @@ JNIEnv *env, #endif jobject Meth) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->methodSlot; JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; - return (jobject)(NativeUtil::getParameterTypes(loader, meth)); + res = (jobject)(NativeUtil::getParameterTypes(loader, meth)); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_invokeNative( @@ -85,6 +113,10 @@ JNIEnv *env, #endif jobject Meth, jobject _obj, jobject _args, jclass Cl, jint _meth) { + + JavaObject* res = 0; + + BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); JavaMethod* meth = (JavaMethod*)_meth; @@ -151,7 +183,6 @@ } \ } \ - JavaObject* res = 0; Typedef* retType = sign->getReturnType(); if (retType->isPrimitive()) { PrimitiveTypedef* prim = (PrimitiveTypedef*)retType; @@ -205,10 +236,13 @@ RUN_METH(JavaObject); res = val; } - return (jobject)res; + } else { + vm->illegalArgumentExceptionForMethod(meth, 0, 0); } - vm->illegalArgumentExceptionForMethod(meth, 0, 0); - return 0; + + END_NATIVE_EXCEPTION + + return (jobject) res; } #undef RUN_METH @@ -218,12 +252,21 @@ JNIEnv *env, #endif jobject _meth) { + + jobjectArray res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(_meth); Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* slot = vm->upcalls->methodSlot; JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)_meth); UserClass* cl = internalGetClass(vm, meth, _meth); - return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); + res = (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); + + END_NATIVE_EXCEPTION + + return res; } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Tue Dec 30 03:31:45 2008 @@ -20,7 +20,7 @@ namespace jnjvm { class JavaObjectClass : public JavaObject { -private: +public: JavaObject* signers; JavaObject* pd; UserCommonClass* vmdata; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Tue Dec 30 03:31:45 2008 @@ -29,6 +29,7 @@ extern "C" { +// Never throws JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray( #ifdef NATIVE_JNI JNIEnv *env, @@ -51,6 +52,10 @@ jboolean clinit, jobject loader) { + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); @@ -60,11 +65,14 @@ if (clinit && cl->asClass()) { cl->asClass()->initialiseClass(vm); } - return (jclass)(cl->getClassDelegatee(vm)); + res =(jclass)(cl->getClassDelegatee(vm)); } else { vm->classNotFoundException((JavaString*)str); - return 0; } + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredConstructors( @@ -75,11 +83,15 @@ jclass Cl, jboolean publicOnly) { + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) { - return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm); + result = (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm); } else { UserClass* realCl = (Class*)cl; std::vector res; @@ -97,8 +109,12 @@ vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, Cl, meth); ret->elements[index] = tmp; } - return (jobject)ret; + result = (jobject)ret; } + + END_NATIVE_EXCEPTION + + return result; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredMethods( @@ -109,12 +125,16 @@ jclass Cl, jboolean publicOnly) { + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); Classpath* upcalls = vm->upcalls; if (cl->isArray() || cl->isPrimitive()) { - return (jobject)upcalls->methodArrayClass->doNew(0, vm); + result = (jobject)upcalls->methodArrayClass->doNew(0, vm); } else { std::vector res; UserClass* realCl = cl->asClass(); @@ -134,8 +154,12 @@ upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, str, meth); ret->elements[index] = tmp; } - return (jobject)ret; + result = (jobject)ret; } + + END_NATIVE_EXCEPTION + + return result; } JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers( @@ -145,10 +169,17 @@ #endif jclass Cl, jboolean ignore) { + + jint res = 0; + + BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); - return cl->getAccess(); + res = cl->getAccess(); + + END_NATIVE_EXCEPTION + return res; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName( @@ -157,13 +188,22 @@ jclass clazz, #endif jobject Cl) { + + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); const UTF8* iname = cl->getName(); const UTF8* res = iname->internalToJava(vm, 0, iname->size); - return (jobject)(vm->UTF8ToStr(res)); + result = (jobject)(vm->UTF8ToStr(res)); + + END_NATIVE_EXCEPTION + + return result; } JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive( @@ -172,9 +212,17 @@ jclass clazz, #endif jclass Cl) { + + jboolean res = 0; + BEGIN_NATIVE_EXCEPTION(0) + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); - return cl->isPrimitive(); + res = cl->isPrimitive(); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface( @@ -183,10 +231,19 @@ jclass clazz, #endif jclass Cl) { + + jboolean res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); - return cl->isInterface(); + res = cl->isInterface(); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType( @@ -195,15 +252,23 @@ jclass clazz, #endif jclass Cl) { + + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); if (cl->isArray()) { UserCommonClass* bc = ((UserClassArray*)cl)->baseClass(); - return (jclass)(bc->getClassDelegatee(vm)); + res = (jclass)(bc->getClassDelegatee(vm)); } else { - return 0; + res = 0; } + + END_NATIVE_EXCEPTION + return res; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getClassLoader( @@ -212,8 +277,17 @@ jclass clazz, #endif jclass Cl) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); - return (jobject)cl->classLoader->getJavaClassLoader(); + res = (jobject)cl->classLoader->getJavaClassLoader(); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom( @@ -222,11 +296,20 @@ jclass clazz, #endif jclass Cl1, jclass Cl2) { + + jboolean res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + UserCommonClass* cl1 = ((JavaObjectClass*)Cl1)->getClass(); UserCommonClass* cl2 = ((JavaObjectClass*)Cl2)->getClass(); if (cl2->asClass()) cl2->asClass()->resolveClass(); - return cl2->isAssignableFrom(cl1); + res = cl2->isAssignableFrom(cl1); + + END_NATIVE_EXCEPTION + + return res; } @@ -236,15 +319,23 @@ jclass clazz, #endif jclass Cl) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); - if (cl->isInterface()) - return 0; + if (cl->isInterface()) res = 0; else { if (cl->asClass()) cl->asClass()->resolveClass(); - if (cl->getSuper()) return (jobject)cl->getSuper()->getClassDelegatee(vm); - else return 0; + if (cl->getSuper()) res = (jobject)cl->getSuper()->getClassDelegatee(vm); + else res = 0; } + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance( @@ -253,8 +344,17 @@ jclass clazz, #endif jclass Cl, jobject obj) { + + bool res = false; + + BEGIN_NATIVE_EXCEPTION(0) + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); - return ((JavaObject*)obj)->instanceOf(cl); + res = ((JavaObject*)obj)->instanceOf(cl); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredFields( @@ -263,11 +363,16 @@ jclass clazz, #endif jclass Cl, jboolean publicOnly) { + + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (!cl) { - return (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm); + result = (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm); } else { std::vector res; cl->getDeclaredFields(res, publicOnly); @@ -285,8 +390,12 @@ vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, name, field); ret->elements[index] = tmp; } - return (jobject)ret; + result = (jobject)ret; } + + END_NATIVE_EXCEPTION + + return result; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getInterfaces( @@ -295,6 +404,11 @@ jclass clazz, #endif jclass Cl) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); ArrayObject* ret = @@ -303,7 +417,11 @@ UserClass* klass = cl->interfaces[i]; ret->elements[i] = klass->getClassDelegatee(vm); } - return (jobject)ret; + res = (jobject)ret; + + END_NATIVE_EXCEPTION + + return res; } @@ -313,17 +431,24 @@ jclass clazz, #endif jclass Cl) { + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (cl) { cl->resolveInnerOuterClasses(); UserClass* outer = cl->getOuterClass(); if (outer) { - return (jclass)outer->getClassDelegatee(vm); + res = (jclass)outer->getClassDelegatee(vm); } } - return 0; + END_NATIVE_EXCEPTION + + return res; + } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses( @@ -332,6 +457,12 @@ jclass clazz, #endif jclass Cl, bool publicOnly) { + + + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (cl) { @@ -342,14 +473,17 @@ UserClass* klass = cl->innerClasses[i]; res->elements[i] = klass->getClassDelegatee(vm); } - return (jobject)res; + result = (jobject)res; } + - return 0; + END_NATIVE_EXCEPTION -} + return result; +} +// Only throws. JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException( #ifdef NATIVE_JNI JNIEnv *env, @@ -366,8 +500,17 @@ #endif jclass Cl) { // TODO implement me + + jobjectArray res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserClassArray* array = vm->upcalls->constructorArrayAnnotation; - return (jobjectArray)array->doNew(0, vm); + res = (jobjectArray) array->doNew(0, vm); + + END_NATIVE_EXCEPTION + + return res; } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Tue Dec 30 03:31:45 2008 @@ -32,13 +32,21 @@ #endif jchar byteId) { + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); UserClassPrimitive* prim = UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls); if (!prim) vm->unknownError("unknown byte primitive %c", byteId); - return (jobject)prim->getClassDelegatee(vm); + res = (jobject)prim->getClassDelegatee(vm); + + END_NATIVE_EXCEPTION + + return res; } @@ -49,6 +57,10 @@ #endif jobject loader, jobject _name) { + + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); JavaString* name = (JavaString*)_name; @@ -57,7 +69,11 @@ JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); UserCommonClass* cl = JCL->lookupClass(utf8); - if (cl) return (jclass)(cl->getClassDelegatee(vm)); + if (cl) res = (jclass)(cl->getClassDelegatee(vm)); + + END_NATIVE_EXCEPTION + + return res; return 0; } @@ -69,6 +85,11 @@ #endif jobject _str, jboolean doResolve) { + + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaString* str = (JavaString*)_str; @@ -77,9 +98,11 @@ false); if (cl != 0) - return (jclass)cl->getClassDelegatee(vm); + res = (jclass)cl->getClassDelegatee(vm); - return 0; + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_defineClass( @@ -93,6 +116,11 @@ jint off, jint len, jobject pd) { + + jclass res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JnjvmClassLoader* JCL = @@ -102,7 +130,11 @@ const UTF8* name = str->value->javaToInternal(vm, str->offset, str->count); UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes); - return (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd)); + res = (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd)); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass( @@ -111,9 +143,14 @@ jclass clazz, #endif jclass Cl) { + + BEGIN_NATIVE_EXCEPTION(0) + verifyNull(Cl); Jnjvm* vm = JavaThread::get()->getJVM(); NativeUtil::resolvedImplClass(vm, Cl, false); + + END_NATIVE_EXCEPTION } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Tue Dec 30 03:31:45 2008 @@ -30,6 +30,10 @@ #endif jobject _src) { + JavaObject* res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + JavaObject* src = (JavaObject*)_src; UserCommonClass* cl = src->classOf; Jnjvm* vm = JavaThread::get()->getJVM(); @@ -46,10 +50,13 @@ assert(cl->isClass() && "Not a class!"); size = cl->asClass()->getVirtualSize(); } - JavaObject* res = (JavaObject*) + res = (JavaObject*) vm->gcAllocator.allocateManagedObject(size, src->getVirtualTable()); memcpy(res, src, size); res->lock.initialise(); + + END_NATIVE_EXCEPTION + return (jobject)res; } @@ -60,9 +67,17 @@ #endif jobject _obj) { + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + JavaObject* obj = (JavaObject*)_obj; Jnjvm* vm = JavaThread::get()->getJVM(); - return (jobject)(obj->classOf->getClassDelegatee(vm)); + res = (jobject)(obj->classOf->getClassDelegatee(vm)); + + END_NATIVE_EXCEPTION + + return res; } JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll( @@ -71,8 +86,13 @@ jclass clazz, #endif jobject _obj) { + + BEGIN_NATIVE_EXCEPTION(0) + JavaObject* obj = (JavaObject*)_obj; obj->notifyAll(); + + END_NATIVE_EXCEPTION } @@ -82,6 +102,9 @@ jclass clazz, #endif jobject _object, jlong ms, jint ns) { + + BEGIN_NATIVE_EXCEPTION(0) + uint32 sec = (uint32) (ms / 1000); uint32 usec = (ns / 1000) + 1000 * (ms % 1000); JavaObject* obj = (JavaObject*)_object; @@ -93,6 +116,8 @@ } else { obj->wait(); } + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_VMObject_notify( @@ -101,7 +126,12 @@ jclass clazz, #endif jobject obj) { + + BEGIN_NATIVE_EXCEPTION(0) + ((JavaObject*)obj)->notify(); + + END_NATIVE_EXCEPTION } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Tue Dec 30 03:31:45 2008 @@ -36,6 +36,10 @@ jclass clazz, #endif jobject _strLib) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) JavaString* strLib = (JavaString*)_strLib; Jnjvm* vm = JavaThread::get()->getJVM(); @@ -57,7 +61,11 @@ memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements, lgPost * sizeof(uint16)); - return (jobject)(vm->UTF8ToStr((const UTF8*)array)); + res = (jobject)(vm->UTF8ToStr((const UTF8*)array)); + + END_NATIVE_EXCEPTION + + return res; } @@ -70,6 +78,11 @@ #endif jobject _str, jobject _loader) { + + jint result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + JavaString* str = (JavaString*)_str; Jnjvm* vm = JavaThread::get()->getJVM(); JnjvmClassLoader* loader = @@ -82,10 +95,14 @@ if (res != 0) { onLoad_t onLoad = (onLoad_t)loader->loadInLib("JNI_OnLoad", res); if (onLoad) onLoad(&vm->javavmEnv, 0); - return 1; + result = 1; } else { - return 0; + result = 0; } + + END_NATIVE_EXCEPTION + + return result; } @@ -95,7 +112,11 @@ jclass clazz, #endif ) { + BEGIN_NATIVE_EXCEPTION(0) + Collector::collect(); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization( Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Tue Dec 30 03:31:45 2008 @@ -29,108 +29,40 @@ extern "C" { -#ifdef ISOLATE_SHARING -uint32 getPools(UserConstantPool** pools, uint32 size) { - unsigned int* top; - register unsigned int **cur = ⊤ - register unsigned int **max = (unsigned int**)mvm::Thread::get()->baseSP; - - uint32 i = 0; - for(; curgetVirtualTable() == UserConstantPool::VT) { - UserConstantPool* ctp = (UserConstantPool*)obj; - pools[i++] = ctp; - } - } - return i; -} - -JavaObject* getClassInContext(Jnjvm* vm, Class* cl, UserConstantPool** ctps, - uint32& ctpIndex) { - for (; ctpIndex < 100; ++ctpIndex) { - UserClass* newCl = ctps[ctpIndex]->getClass(); - if (cl == newCl->classDef) return newCl->getClassDelegatee(vm); - } - return 0; -} - -ArrayObject* recGetClassContext(Jnjvm* vm, int** stack, uint32 size, - uint32 first, uint32 rec, - UserConstantPool** ctps, uint32 ctpIndex) { - if (size != first) { - JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]); - if (meth) { - JavaObject* obj = getClassInContext(vm, meth->classDef, ctps, ctpIndex); - ArrayObject* res = recGetClassContext(vm, stack, size, first + 1, - rec + 1, ctps, ctpIndex); - res->elements[rec] = obj; - assert(res->elements[rec] && "Did not found the user class"); - return res; - } else { - return recGetClassContext(vm, stack, size, first + 1, rec, ctps, - ctpIndex); - } - } else { - return (ArrayObject*)vm->upcalls->classArrayClass->doNew(rec, vm); - } -} - -#else -ArrayObject* recGetClassContext(Jnjvm* vm, int** stack, uint32 size, - uint32 first, uint32 rec) { - if (size != first) { - JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]); - if (meth) { - ArrayObject* res = recGetClassContext(vm, stack, size, first + 1, - rec + 1); - res->elements[rec] = meth->classDef->getClassDelegatee(vm); - return res; - } else { - return recGetClassContext(vm, stack, size, first + 1, rec); - } - } else { - return (ArrayObject*)vm->upcalls->classArrayClass->doNew(rec, vm); - } -} -#endif - JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassContext( #ifdef NATIVE_JNI JNIEnv *env, jclass clazz, #endif ) { - Jnjvm* vm = JavaThread::get()->getJVM(); - int* ips[100]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100); -#ifdef ISOLATE_SHARING - UserConstantPool* pools[100]; - getPools(pools, 100); -#endif - int i = 0; - int first = 0; - UserCommonClass* cl = vm->upcalls->vmStackWalker; - - while (i < real_size) { - JavaMethod* meth = JavaJIT::IPToJavaMethod(ips[i++]); -#ifdef ISOLATE_SHARING - if (meth && meth->classDef == cl->classDef) { -#else - if (meth && meth->classDef == cl) { -#endif - first = i; - break; - } + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) + + JavaThread* th = JavaThread::get(); + Jnjvm* vm = th->getJVM(); + std::vector stack; + + th->getJavaFrameContext(stack); + + ArrayObject* res = (ArrayObject*) + vm->upcalls->stackTraceArray->doNew(stack.size(), vm); + + std::vector::iterator i = stack.begin(), e = stack.end(); + uint32 index = 0; + + for (; i != e; ++i) { + JavaMethod* meth = vm->IPToJavaMethod(*i); + assert(meth && "Wrong stack trace"); + res->elements[index++] = meth->classDef->getClassDelegatee(vm); } + + result = (jobject)res; + + END_NATIVE_EXCEPTION -#ifdef ISOLATE_SHARING - return (jobject)recGetClassContext(vm, ips, real_size, first, 0, pools, 0); -#else - return (jobject)recGetClassContext(vm, ips, real_size, first, 0); -#endif + return result; } JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader( @@ -139,19 +71,46 @@ jclass clazz, #endif jclass _Cl) { + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + JavaObject* Cl = (JavaObject*)_Cl; UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); - return (jobject)cl->classLoader->getJavaClassLoader(); + res = (jobject)cl->classLoader->getJavaClassLoader(); + + END_NATIVE_EXCEPTION + + return res; } extern "C" JavaObject* getCallingClass() { - UserClass* cl = JavaJIT::getCallingClass(); - if (cl) return cl->getClassDelegatee(JavaThread::get()->getJVM()); - return 0; + + JavaObject* res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + + JavaThread* th = JavaThread::get(); + UserClass* cl = th->getCallingClass(); + if (cl) res = cl->getClassDelegatee(th->getJVM()); + + END_NATIVE_EXCEPTION + + return res; } extern "C" JavaObject* getCallingClassLoader() { - return JavaJIT::getCallingClassLoader(); + + JavaObject *res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + JavaThread* th = JavaThread::get(); + UserClass* cl = th->getCallingClass(); + if (cl) res = cl->classLoader->getJavaClassLoader(); + END_NATIVE_EXCEPTION + + return res; } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp Tue Dec 30 03:31:45 2008 @@ -33,6 +33,8 @@ jobject _dst, jint dstart, jint len) { + + BEGIN_NATIVE_EXCEPTION(0) jnjvm::Jnjvm *vm = JavaThread::get()->getJVM(); JavaArray* src = (JavaArray*)_src; @@ -95,6 +97,8 @@ if (doThrow) vm->arrayStoreException(); + + END_NATIVE_EXCEPTION } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Tue Dec 30 03:31:45 2008 @@ -53,6 +53,8 @@ jclass clazz, #endif jobject _prop) { + + BEGIN_NATIVE_EXCEPTION(0) JavaObject* prop = (JavaObject*)_prop; Jnjvm* vm = JavaThread::get()->getJVM(); @@ -120,15 +122,20 @@ setProperty(vm, prop, "file.encoding", "ISO8859_1"); setProperty(vm, prop, "gnu.java.util.zoneinfo.dir", "/usr/share/zoneinfo"); - + END_NATIVE_EXCEPTION } extern "C" void propertiesPostInit(JavaObject* prop) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); for (std::vector >::iterator i = vm->postProperties.begin(), e = vm->postProperties.end(); i!= e; i++) { setProperty(vm, prop, i->first, i->second); } + + END_NATIVE_EXCEPTION } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Tue Dec 30 03:31:45 2008 @@ -27,6 +27,8 @@ extern "C" { +// Never throws. +// Never calls Java code. JNIEXPORT jobject JNICALL Java_java_lang_VMThread_currentThread( #ifdef NATIVE_JNI JNIEnv *env, @@ -81,6 +83,9 @@ JNIEnv *env, #endif jobject _vmThread, sint64 stackSize) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaObject* vmThread = (JavaObject*)_vmThread; @@ -91,6 +96,8 @@ JavaThread* th = new JavaThread(javaThread, vmThread, vm); if (!th) vm->outOfMemoryError(0); th->start((void (*)(mvm::Thread*))start); + + END_NATIVE_EXCEPTION } JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt( @@ -98,6 +105,9 @@ JNIEnv *env, #endif jobject _vmthread) { + + BEGIN_NATIVE_EXCEPTION(0) + Jnjvm* vm = JavaThread::get()->getJVM(); JavaObject* vmthread = (JavaObject*)_vmthread; JavaField* field = vm->upcalls->vmdataVMThread; @@ -117,8 +127,12 @@ } th->lock.unlock(); + + END_NATIVE_EXCEPTION } +// Never throws. +// Never calls Java code. JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted( #ifdef NATIVE_JNI JNIEnv *env, @@ -131,6 +145,8 @@ return (jboolean)interrupt; } +// Never throws. +// Never calls Java code. JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted( #ifdef NATIVE_JNI JNIEnv *env, @@ -143,6 +159,8 @@ return (jboolean)th->interruptFlag; } +// Never throws. +// Never calls Java code. JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority( #ifdef NATIVE_JNI JNIEnv *env, @@ -151,6 +169,8 @@ // Currently not implemented } +// Never throws. +// Never calls Java code. JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop( #ifdef NATIVE_JNI JNIEnv *env, @@ -159,6 +179,8 @@ // Currently not implemented } +// Never throws. +// Never calls Java code. JNIEXPORT void JNICALL Java_java_lang_VMThread_yield( #ifdef NATIVE_JNI JNIEnv *env, Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Tue Dec 30 03:31:45 2008 @@ -8,6 +8,7 @@ //===----------------------------------------------------------------------===// #include +#include #include "types.h" @@ -37,19 +38,33 @@ jclass clazz, #endif jobject throwable) { - Jnjvm* vm = JavaThread::get()->getJVM(); - int** stack = - (int**)vm->gcAllocator.allocateTemporaryMemory(sizeof(int*) * 100); - int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100); - stack[real_size] = 0; + + jobject res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + + JavaThread* th = JavaThread::get(); + Jnjvm* vm = th->getJVM(); + + // Allocate the temporary data. + std::vector* stack = new std::vector(); + + // Get the frame context. + th->getJavaFrameContext(*stack); + + // Set the tempory data in the new VMThrowable object. JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); uint64 ptr = (uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset; ((JavaObject**)ptr)[0] = (JavaObject*)stack; - return (jobject)vmThrowable; + res = (jobject)vmThrowable; + + END_NATIVE_EXCEPTION + + return res; } -JavaObject* consStackElement(JavaMethod* meth, int* ip) { +static JavaObject* consStackElement(JavaMethod* meth, void* ip) { Jnjvm* vm = JavaThread::get()->getJVM(); JavaObject* methodName = vm->internalUTF8ToStr(meth->name); Class* cl = meth->classDef; @@ -77,47 +92,47 @@ return res; } -ArrayObject* recGetStackTrace(int** stack, uint32 first, uint32 rec) { - Jnjvm* vm = JavaThread::get()->getJVM(); - if (stack[first] != 0) { - JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]); - if (meth) { - ArrayObject* res = recGetStackTrace(stack, first + 1, rec + 1); - res->elements[rec] = consStackElement(meth, stack[first]); - return res; - } else { - return recGetStackTrace(stack, first + 1, rec); - } - } else { - return (ArrayObject*)vm->upcalls->stackTraceArray->doNew(rec, vm); - } -} - JNIEXPORT jobject JNICALL Java_java_lang_VMThrowable_getStackTrace( #ifdef NATIVE_JNI JNIEnv *env, #endif jobject vmthrow, jobject throwable) { + + jobject result = 0; + + BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = vm->upcalls->vmDataVMThrowable; - int** stack = (int**)field->getObjectField((JavaObject*)vmthrow); - uint32 first = 0; - sint32 i = 0; - - while (stack[i] != 0) { - JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[i++]); -#ifdef ISOLATE_SHARING - if (meth) { -#else - if (meth && !meth->classDef->subclassOf(vm->upcalls->newThrowable)) { -#endif - first = i - 1; - break; - } + std::vector* stack = (std::vector*) + field->getObjectField((JavaObject*)vmthrow); + + std::vector::iterator i = stack->begin(), e = stack->end(); + uint32 index = 0; + while (i != e) { + JavaMethod* meth = vm->IPToJavaMethod(*i); + assert(meth && "Wrong stack trace"); + if (meth->classDef->subclassOf(vm->upcalls->newThrowable)) { + ++i; + ++index; + } else break; } - jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0); - vm->gcAllocator.freeTemporaryMemory(stack); - return res; + + ArrayObject* res = (ArrayObject*) + vm->upcalls->stackTraceArray->doNew(stack->size() - index, vm); + + index = 0; + for (; i != e; ++i) { + JavaMethod* meth = vm->IPToJavaMethod(*i); + assert(meth && "Wrong stack trace"); + res->elements[index++] = consStackElement(meth, *i); + } + + delete stack; + result = (jobject)res; + + END_NATIVE_EXCEPTION + + return result; } } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp Tue Dec 30 03:31:45 2008 @@ -22,6 +22,7 @@ using namespace jnjvm; +#if 0 JavaMethod* JavaJIT::IPToJavaMethod(void* begIp) { const llvm::Function* F = mvm::MvmModule::getCodeFromPointer(begIp); if (F) { @@ -141,3 +142,5 @@ if (!cl) return 0; else return cl->classLoader->getJavaClassLoader(); } + +#endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 03:31:45 2008 @@ -192,7 +192,6 @@ if (!natPtr && !module->isStaticCompiling()) { fprintf(stderr, "Native function %s not found. Probably " "not implemented by JnJVM?\n", compilingMethod->printString()); - JavaJIT::printBacktrace(); JavaThread::get()->getJVM()->unknownError("can not find native method %s", compilingMethod->printString()); } @@ -862,11 +861,6 @@ } } - // We don't need the lock here, and Java requires to load the classes in the - // try clause, which may require compilation. Therefore we release the lock - // and acquire it after the exception table is read. - module->executionEngine->lock.release(); - Exception* exceptions = (Exception*)alloca(sizeof(Exception) * (nbe - sync)); for (uint16 i = 0; i < nbe - sync; ++i) { Exception* ex = &exceptions[i]; @@ -878,22 +872,8 @@ #ifndef ISOLATE_SHARING if (ex->catche) { - JavaObject* exc = 0; - UserClass* cl = 0; - try { - cl = (UserClass*)(compilingClass->ctpInfo->loadClass(ex->catche)); - } catch(...) { - compilingClass->release(); - exc = JavaThread::getJavaException(); - assert(exc && "no exception?"); - JavaThread::clearException(); - } - - if (exc) { - Jnjvm* vm = JavaThread::get()->getJVM(); - vm->noClassDefFoundError(exc); - } - + UserClass* cl = + (UserClass*)(compilingClass->ctpInfo->isClassLoaded(ex->catche)); ex->catchClass = cl; } else { ex->catchClass = Classpath::newThrowable; @@ -920,7 +900,6 @@ opcodeInfos[ex->handlerpc].reqSuppl = true; } - module->executionEngine->lock.acquire(); bool first = true; for (sint16 i = 0; i < nbe - sync; ++i) { @@ -991,8 +970,10 @@ else cl = CallInst::Create(module->GetJnjvmExceptionClassFunction, isolateLocal, "", currentBlock); #else - assert(cur->catchClass); - cl = module->getNativeClass(cur->catchClass); + if (cur->catchClass) + cl = module->getNativeClass(cur->catchClass); + else + cl = getResolvedClass(cur->catche, false, false, 0); #endif #ifdef SERVICE @@ -1693,7 +1674,7 @@ node = module->getNativeClass(cl); } else { node = getConstantPoolAt(index, module->ClassLookupFunction, - module->JavaCommonClassType, 0, doThrow); + module->JavaClassType, 0, doThrow); } if (!(!clinit || (cl && !needsInitialisationCheck(cl, compilingClass)))) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Tue Dec 30 03:31:45 2008 @@ -76,12 +76,6 @@ JnjvmModule* module; - static void invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader, - const char* className, - const char* func, const char* sign, - int access, ...); - - llvm::Function* javaCompile(); llvm::Function* nativeCompile(intptr_t natPtr = 0); llvm::Instruction* inlineCompile(llvm::BasicBlock*& curBB, @@ -272,12 +266,6 @@ #endif static const char* OpcodeNames[256]; - - static UserClass* getCallingClass(); - static UserClass* getCallingClassWalker(); - static JavaObject* getCallingClassLoader(); - static void printBacktrace(); - static JavaMethod* IPToJavaMethod(void* ip); /// nbEnveloppes - Number of enveloppes (ie invokeinterface) in this /// method. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Tue Dec 30 03:31:45 2008 @@ -24,33 +24,6 @@ using namespace jnjvm; -void JavaJIT::invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader, - char const* className, char const* func, - char const* sign, int access, ...) { - - UserCommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className), - true, true); - - bool stat = access == ACC_STATIC ? true : false; - UserClass* lookup = cl->isArray() ? cl->super : cl->asClass(); - lookup->initialiseClass(vm); - JavaMethod* method = lookup->lookupMethod(loader->asciizConstructUTF8(func), - loader->asciizConstructUTF8(sign), - stat, true, 0); - va_list ap; - va_start(ap, access); - if (stat) { - method->invokeIntStaticAP(vm, (UserClass*)cl, ap); - } else { - JavaObject* obj = va_arg(ap, JavaObject*); - method->invokeIntSpecialAP(vm, (UserClass*)cl, obj, ap); - } - va_end(ap); -} - - - - #define readArgs(buf, signature, ap) \ Typedef* const* arguments = signature->getArgumentsType(); \ for (uint32 i = 0; i < signature->nbArguments; ++i) { \ @@ -98,7 +71,22 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = (((void***)obj)[0])[offset];\ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\ @@ -113,7 +101,22 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\ @@ -127,7 +130,22 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ - return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, _buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, _buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ @@ -140,7 +158,22 @@ \ Signdef* sign = getSignature(); \ void* func = (((void***)obj)[0])[offset];\ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ @@ -152,7 +185,22 @@ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\ @@ -163,7 +211,22 @@ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \ @@ -203,7 +266,22 @@ verifyNull(obj); \ void* func = (((void***)obj)[0])[offset];\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\ @@ -215,7 +293,22 @@ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\ @@ -226,7 +319,22 @@ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(cl->getConstantPool(), func, ap);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(cl->getConstantPool(), func, ap);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ @@ -238,7 +346,22 @@ verifyNull(obj);\ void* func = (((void***)obj)[0])[offset];\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ @@ -250,7 +373,22 @@ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\ @@ -261,7 +399,22 @@ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\ + JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + th->startJava(); \ + TYPE res = 0; \ + try { \ + res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\ + } catch (...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + th->pendingException = excp; \ + th->returnFromJava(); \ + } \ + th->endJava(); \ + return res; \ }\ \ TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \ Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Dec 30 03:31:45 2008 @@ -23,10 +23,18 @@ #include "JavaTypes.h" #include "Jnjvm.h" #include "LockedMap.h" +#include "NativeUtil.h" using namespace jnjvm; +// Throws if the method is not found. extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) { + + void* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + + Enveloppe* enveloppe = cache->enveloppe; UserCommonClass* ocl = obj->classOf; @@ -86,10 +94,20 @@ enveloppe->cacheLock.release(); - return rcache->methPtr; + res = rcache->methPtr; + + END_NATIVE_EXCEPTION + + return res; } +// Throws if the field is not found. extern "C" void* virtualFieldLookup(UserClass* caller, uint32 index) { + + void* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + UserConstantPool* ctpInfo = caller->getConstantPool(); if (ctpInfo->ctpRes[index]) { return ctpInfo->ctpRes[index]; @@ -106,10 +124,20 @@ ctpInfo->ctpRes[index] = (void*)field->ptrOffset; - return (void*)field->ptrOffset; + res = (void*)field->ptrOffset; + + END_NATIVE_EXCEPTION + + return res; } +// Throws if the field or its class is not found. extern "C" void* staticFieldLookup(UserClass* caller, uint32 index) { + + void* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + UserConstantPool* ctpInfo = caller->getConstantPool(); if (ctpInfo->ctpRes[index]) { @@ -135,73 +163,21 @@ void* ptr = (void*)((uint64)obj + field->ptrOffset); ctpInfo->ctpRes[index] = ptr; - return ptr; -} - -#ifdef ISOLATE -extern "C" void* stringLookup(UserClass* cl, uint32 index) { - UserConstantPool* ctpInfo = cl->getConstantPool(); - const UTF8* utf8 = ctpInfo->UTF8AtForString(index); - JavaString* str = JavaThread::get()->getJVM()->internalUTF8ToStr(utf8); -#ifdef ISOLATE_SHARING - ctpInfo->ctpRes[index] = str; -#endif - return (void*)str; -} - -#ifdef ISOLATE_SHARING -extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) { - UserConstantPool* ctpInfo = cl->getConstantPool(); - mvm::Allocator* allocator = cl->classLoader->allocator; - Enveloppe* enveloppe = new(allocator) Enveloppe(ctpInfo, index); - ctpInfo->ctpRes[index] = enveloppe; - return (void*)enveloppe; -} - -extern "C" void* staticCtpLookup(UserClass* cl, uint32 index) { - UserConstantPool* ctpInfo = cl->getConstantPool(); - JavaConstantPool* shared = ctpInfo->getSharedPool(); - uint32 clIndex = shared->getClassIndexFromMethod(index); - UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex); - refCl->initialiseClass(JavaThread::get()->getJVM()); + res = ptr; - CommonClass* baseCl = 0; - const UTF8* utf8 = 0; - Signdef* sign = 0; + END_NATIVE_EXCEPTION - shared->resolveMethod(index, baseCl, utf8, sign); - UserClass* methodCl = 0; - refCl->lookupMethod(utf8, sign->keyName, true, true, &methodCl); - ctpInfo->ctpRes[index] = methodCl->getConstantPool(); - shared->ctpRes[clIndex] = refCl->classDef; - return (void*)methodCl->getConstantPool(); + return res; } -extern "C" UserConstantPool* specialCtpLookup(UserConstantPool* ctpInfo, - uint32 index, - UserConstantPool** res) { - JavaConstantPool* shared = ctpInfo->getSharedPool(); - uint32 clIndex = shared->getClassIndexFromMethod(index); - UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex); - - CommonClass* baseCl = 0; - const UTF8* utf8 = 0; - Signdef* sign = 0; - - shared->resolveMethod(index, baseCl, utf8, sign); - UserClass* methodCl = 0; - refCl->lookupMethod(utf8, sign->keyName, false, true, &methodCl); - shared->ctpRes[clIndex] = refCl->classDef; - *res = methodCl->getConstantPool(); - return methodCl->getConstantPool(); -} - -#endif - -#endif - #ifndef WITHOUT_VTABLE +// Throws if the method is not found. extern "C" void* vtableLookup(UserClass* caller, uint32 index, ...) { + + void* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + UserCommonClass* cl = 0; const UTF8* utf8 = 0; Signdef* sign = 0; @@ -232,11 +208,21 @@ "Class not ready in a virtual lookup."); #endif - return (void*)dmeth->offset; + res = (void*)dmeth->offset; + + END_NATIVE_EXCEPTION + + return res; } #endif +// Throws if the class is not found. extern "C" void* classLookup(UserClass* caller, uint32 index) { + + void* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + UserConstantPool* ctpInfo = caller->getConstantPool(); UserClass* cl = (UserClass*)ctpInfo->loadClass(index); // We can not initialize here, because bytecodes such as CHECKCAST @@ -244,77 +230,37 @@ // This is really sad, because we need to insert class initialization checks // in the LLVM code. assert(cl && "No cl after class lookup"); - return (void*)cl; -} + res = (void*)cl; + END_NATIVE_EXCEPTION -extern "C" void printMethodStart(JavaMethod* meth) { - printf("[%p] executing %s\n", (void*)mvm::Thread::get(), - meth->printString()); - fflush(stdout); -} - -extern "C" void printMethodEnd(JavaMethod* meth) { - printf("[%p] return from %s\n", (void*)mvm::Thread::get(), - meth->printString()); - fflush(stdout); -} - -extern "C" void printExecution(char* opcode, uint32 index, JavaMethod* meth) { - printf("[%p] executing %s %s at %d\n", (void*)mvm::Thread::get(), - meth->printString(), opcode, index); - fflush(stdout); -} - -extern "C" void jniProceedPendingException() { - JavaThread* th = JavaThread::get(); - jmp_buf* buf = th->sjlj_buffers.back(); - th->sjlj_buffers.pop_back(); - mvm::Allocator& allocator = th->getJVM()->gcAllocator; - allocator.freeTemporaryMemory(buf); - if (JavaThread::get()->pendingException) { - th->throwPendingException(); - } -} - -extern "C" void* getSJLJBuffer() { - JavaThread* th = JavaThread::get(); - mvm::Allocator& allocator = th->getJVM()->gcAllocator; - void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf)); - th->sjlj_buffers.push_back((jmp_buf*)buf); - return (void*)buf; -} - -extern "C" void jnjvmNullPointerException() { - JavaThread::get()->getJVM()->nullPointerException("null"); -} - -extern "C" void negativeArraySizeException(sint32 val) { - JavaThread::get()->getJVM()->negativeArraySizeException(val); -} - -extern "C" void outOfMemoryError(sint32 val) { - JavaThread::get()->getJVM()->outOfMemoryError(val); -} - -extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) { - JavaThread::get()->getJVM()->classCastException(obj, cl); -} - -extern "C" void indexOutOfBoundsException(JavaObject* obj, sint32 index) { - JavaThread::get()->getJVM()->indexOutOfBounds(obj, index); + return res; } +// Calls Java code. +// Throws if initializing the class throws an exception. extern "C" UserCommonClass* jnjvmRuntimeInitialiseClass(UserClass* cl) { + BEGIN_NATIVE_EXCEPTION(1) + cl->initialiseClass(JavaThread::get()->getJVM()); + + END_NATIVE_EXCEPTION return cl; } +// Calls Java code. extern "C" JavaObject* jnjvmRuntimeDelegatee(UserCommonClass* cl) { + JavaObject* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) Jnjvm* vm = JavaThread::get()->getJVM(); - return cl->getClassDelegatee(vm); + res = cl->getClassDelegatee(vm); + END_NATIVE_EXCEPTION + + return res; } +// Throws if one of the dimension is negative. static JavaArray* multiCallNewIntern(UserClassArray* cl, uint32 len, sint32* dims, Jnjvm* vm) { if (len <= 0) JavaThread::get()->getJVM()->unknownError("Can not happen"); @@ -342,7 +288,12 @@ return _res; } +// Throws if one of the dimension is negative. extern "C" JavaArray* multiCallNew(UserClassArray* cl, uint32 len, ...) { + JavaArray* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + va_list ap; va_start(ap, len); sint32* dims = (sint32*)alloca(sizeof(sint32) * len); @@ -350,69 +301,212 @@ dims[i] = va_arg(ap, int); } Jnjvm* vm = JavaThread::get()->getJVM(); - return multiCallNewIntern(cl, len, dims, vm); + res = multiCallNewIntern(cl, len, dims, vm); + + END_NATIVE_EXCEPTION + + return res; } +// Throws if the class can not be resolved. extern "C" UserClassArray* getArrayClass(UserCommonClass* cl, UserClassArray** dcl) { + UserClassArray* res = 0; + + BEGIN_NATIVE_EXCEPTION(1) + JnjvmClassLoader* JCL = cl->classLoader; if (cl->asClass()) cl->asClass()->resolveClass(); const UTF8* arrayName = JCL->constructArrayName(1, cl->getName()); - UserClassArray* result = JCL->constructArray(arrayName); - if (dcl) *dcl = result; - return result; + res = JCL->constructArray(arrayName); + if (dcl) *dcl = res; + + END_NATIVE_EXCEPTION + + return res; +} + +// Does not call Java code. +extern "C" void jniProceedPendingException() { + JavaThread* th = JavaThread::get(); + jmp_buf* buf = th->sjlj_buffers.back(); + + // Remove the buffer. + th->sjlj_buffers.pop_back(); + + // We're going back to Java, remove the native address. + th->addresses.pop_back(); + + mvm::Allocator& allocator = th->getJVM()->gcAllocator; + allocator.freeTemporaryMemory(buf); + + // If there's an exception, throw it now. + if (JavaThread::get()->pendingException) { + th->throwPendingException(); + } } +// Never throws. +extern "C" void* getSJLJBuffer() { + JavaThread* th = JavaThread::get(); + mvm::Allocator& allocator = th->getJVM()->gcAllocator; + void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf)); + th->sjlj_buffers.push_back((jmp_buf*)buf); + + // Start native because the next instruction after setjmp is a call to a + // native function. + th->startNative(1); + + // Finally, return the buffer that the Java code will use to do the setjmp. + return (void*)buf; +} + +// Never throws. extern "C" void JavaObjectAquire(JavaObject* obj) { obj->acquire(); } +// Never throws. extern "C" void JavaObjectRelease(JavaObject* obj) { obj->release(); } +// Never throws. extern "C" bool instanceOf(JavaObject* obj, UserCommonClass* cl) { return obj->instanceOf(cl); } +// Never throws. extern "C" bool instantiationOfArray(UserCommonClass* cl1, UserClassArray* cl2) { return cl1->instantiationOfArray(cl2); } +// Never throws. extern "C" bool implements(UserCommonClass* cl1, UserCommonClass* cl2) { return cl1->implements(cl2); } +// Never throws. extern "C" bool isAssignableFrom(UserCommonClass* cl1, UserCommonClass* cl2) { return cl1->isAssignableFrom(cl2); } +// Never throws. extern "C" void* JavaThreadGetException() { return JavaThread::getException(); } -extern "C" void JavaThreadThrowException(JavaObject* obj) { - return JavaThread::throwException(obj); -} - +// Never throws. extern "C" JavaObject* JavaThreadGetJavaException() { return JavaThread::getJavaException(); } +// Does not call any Java code. +extern "C" void JavaThreadThrowException(JavaObject* obj) { + return JavaThread::throwException(obj); +} + +// Never throws. extern "C" bool JavaThreadCompareException(UserClass* cl) { return JavaThread::compareException(cl); } +// Never throws. extern "C" void JavaThreadClearException() { return JavaThread::clearException(); } +// Never throws. extern "C" void overflowThinLock(JavaObject* obj) { obj->overflowThinLock(); } +// Creates a Java object and then throws it. +extern "C" void jnjvmNullPointerException() { + + JavaObject *exc = 0; + + BEGIN_NATIVE_EXCEPTION(1) + + exc = JavaThread::get()->getJVM()->CreateNullPointerException(); + + END_NATIVE_EXCEPTION + + JavaThread::throwException(exc); +} + +// Creates a Java object and then throws it. +extern "C" void negativeArraySizeException(sint32 val) { + JavaObject *exc = 0; + + BEGIN_NATIVE_EXCEPTION(1) + + exc = JavaThread::get()->getJVM()->CreateNegativeArraySizeException(); + + END_NATIVE_EXCEPTION + + JavaThread::throwException(exc); +} + +// Creates a Java object and then throws it. +extern "C" void outOfMemoryError(sint32 val) { + JavaObject *exc = 0; + + BEGIN_NATIVE_EXCEPTION(1) + + exc = JavaThread::get()->getJVM()->CreateOutOfMemoryError(); + + END_NATIVE_EXCEPTION + + JavaThread::throwException(exc); +} + +// Creates a Java object and then throws it. +extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) { + JavaObject *exc = 0; + + BEGIN_NATIVE_EXCEPTION(1) + + exc = JavaThread::get()->getJVM()->CreateClassCastException(obj, cl); + + END_NATIVE_EXCEPTION + + JavaThread::throwException(exc); +} + +// Creates a Java object and then throws it. +extern "C" void indexOutOfBoundsException(JavaObject* obj, sint32 index) { + JavaObject *exc = 0; + + BEGIN_NATIVE_EXCEPTION(1) + + exc = JavaThread::get()->getJVM()->CreateIndexOutOfBoundsException(index); + + END_NATIVE_EXCEPTION + + JavaThread::throwException(exc); +} + +extern "C" void printMethodStart(JavaMethod* meth) { + printf("[%p] executing %s\n", (void*)mvm::Thread::get(), + meth->printString()); + fflush(stdout); +} + +extern "C" void printMethodEnd(JavaMethod* meth) { + printf("[%p] return from %s\n", (void*)mvm::Thread::get(), + meth->printString()); + fflush(stdout); +} + +extern "C" void printExecution(char* opcode, uint32 index, JavaMethod* meth) { + printf("[%p] executing %s %s at %d\n", (void*)mvm::Thread::get(), + meth->printString(), opcode, index); + fflush(stdout); +} + #ifdef SERVICE extern "C" void serviceCallStart(Jnjvm* OldService, @@ -429,3 +523,65 @@ } #endif + +#ifdef ISOLATE +extern "C" void* stringLookup(UserClass* cl, uint32 index) { + UserConstantPool* ctpInfo = cl->getConstantPool(); + const UTF8* utf8 = ctpInfo->UTF8AtForString(index); + JavaString* str = JavaThread::get()->getJVM()->internalUTF8ToStr(utf8); +#ifdef ISOLATE_SHARING + ctpInfo->ctpRes[index] = str; +#endif + return (void*)str; +} + +#ifdef ISOLATE_SHARING +extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) { + UserConstantPool* ctpInfo = cl->getConstantPool(); + mvm::Allocator* allocator = cl->classLoader->allocator; + Enveloppe* enveloppe = new(allocator) Enveloppe(ctpInfo, index); + ctpInfo->ctpRes[index] = enveloppe; + return (void*)enveloppe; +} + +extern "C" void* staticCtpLookup(UserClass* cl, uint32 index) { + UserConstantPool* ctpInfo = cl->getConstantPool(); + JavaConstantPool* shared = ctpInfo->getSharedPool(); + uint32 clIndex = shared->getClassIndexFromMethod(index); + UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex); + refCl->initialiseClass(JavaThread::get()->getJVM()); + + CommonClass* baseCl = 0; + const UTF8* utf8 = 0; + Signdef* sign = 0; + + shared->resolveMethod(index, baseCl, utf8, sign); + UserClass* methodCl = 0; + refCl->lookupMethod(utf8, sign->keyName, true, true, &methodCl); + ctpInfo->ctpRes[index] = methodCl->getConstantPool(); + shared->ctpRes[clIndex] = refCl->classDef; + return (void*)methodCl->getConstantPool(); +} + +extern "C" UserConstantPool* specialCtpLookup(UserConstantPool* ctpInfo, + uint32 index, + UserConstantPool** res) { + JavaConstantPool* shared = ctpInfo->getSharedPool(); + uint32 clIndex = shared->getClassIndexFromMethod(index); + UserClass* refCl = (UserClass*)ctpInfo->loadClass(clIndex); + + CommonClass* baseCl = 0; + const UTF8* utf8 = 0; + Signdef* sign = 0; + + shared->resolveMethod(index, baseCl, utf8, sign); + UserClass* methodCl = 0; + refCl->lookupMethod(utf8, sign->keyName, false, true, &methodCl); + shared->ctpRes[clIndex] = refCl->classDef; + *res = methodCl->getConstantPool(); + return methodCl->getConstantPool(); +} + +#endif + +#endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 03:31:45 2008 @@ -76,3 +76,118 @@ th->internalPendingException = exc; __cxa_throw(exc, 0, 0); } + +void JavaThread::startNative(int level) { + // Call to this function. + void** cur = (void**)__builtin_frame_address(0); + + // Caller (for native Classpath functions). + //if (level) + cur = (void**)cur[0]; + + // When entering, the number of addresses should be odd. + // Enable this when finalization gets proper support. + // assert((addresses.size() % 2) && "Wrong stack"); + + addresses.push_back(cur); +} + +void JavaThread::startJava() { + // Call to this function. + void** cur = (void**)__builtin_frame_address(0); + + // Caller in JavaMetaJIT.cpp + cur = (void**)cur[0]; + + addresses.push_back(cur); +} + +UserClass* JavaThread::getCallingClass() { + // I'm a native function, so try to look at the last Java method. + // First Get the caller of this method. + void** addr = (void**)addresses.back(); + + // Get the caller of the Java getCallingClass method. + addr = (void**)addr[0]; + void* ip = FRAME_IP(addr); + + JavaMethod* meth = getJVM()->IPToJavaMethod(ip); + + if (meth) return meth->classDef; + else return 0; +} + +void JavaThread::getJavaFrameContext(std::vector& context) { + std::vector::iterator it = addresses.end(); + + // Loop until we cross the first Java frame. + while (it != addresses.begin()) { + + // Get the last Java frame. + void** addr = (void**)*(--it); + + // Set the iterator to the next native -> Java call. + --it; + + do { + void* ip = FRAME_IP(addr); + context.push_back(ip); + addr = (void**)addr[0]; + // End walking the stack when we cross a native -> Java call. Here + // the iterator points to a native -> Java call. We dereference addr twice + // because a native -> Java call always contains the signature function. + } while (((void***)addr)[0][0] != *it); + } +} + +#include + +static void printFunctionInfo(void* ip) { + Dl_info info; + int res = dladdr(ip, &info); + if (res != 0) { + fprintf(stderr, "; %p in %s\n", ip, info.dli_sname); + } else { + fprintf(stderr, "; %p in Native to Java Frame\n", ip); + } +} + +void JavaThread::printBacktrace() { + std::vector::iterator it = addresses.end(); + Jnjvm* vm = getJVM(); + + void** addr = (void**)__builtin_frame_address(0); + + // Loop until we cross the first Java frame. + while (it != addresses.begin()) { + + --it; + // Until we hit the last Java frame. + while (addr != (void**)*it) { + void* ip = FRAME_IP(addr); + printFunctionInfo(ip); + addr = (void**)addr[0]; + } + + // Set the iterator to the next native -> Java call. + --it; + + do { + void* ip = FRAME_IP(addr); + JavaMethod* meth = vm->IPToJavaMethod(ip); + assert(meth && "Wrong stack"); + fprintf(stderr, "; %p in %s\n", ip, meth->printString()); + addr = (void**)addr[0]; + // End walking the stack when we cross a native -> Java call. Here + // the iterator points to a native -> Java call. We dereference addr twice + // because a native -> Java call always contains the signature function. + } while (((void***)addr)[0][0] != *it); + } + + while (addr < baseSP && addr < addr[0]) { + void* ip = FRAME_IP(addr); + printFunctionInfo(ip); + addr = (void**)addr[0]; + } + +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 03:31:45 2008 @@ -37,6 +37,7 @@ uint32 interruptFlag; uint32 state; std::vector sjlj_buffers; + std::vector addresses; static const unsigned int StateRunning; static const unsigned int StateWaiting; @@ -94,7 +95,7 @@ return JavaThread::get()->pendingException; } - void returnFromNative() { + void returnFromJNI() { assert(sjlj_buffers.size()); #if defined(__MACH__) longjmp((int*)sjlj_buffers.back(), 1); @@ -102,6 +103,40 @@ longjmp((__jmp_buf_tag*)sjlj_buffers.back(), 1); #endif } + + void returnFromNative() { + addresses.pop_back(); + throwPendingException(); + } + + void returnFromJava() { + addresses.pop_back(); + throwPendingException(); + } + + void startNative(int level); + void startJava(); + + void endNative() { + addresses.pop_back(); + } + + void endJava() { + addresses.pop_back(); + } + + /// getCallingClass - Get the Java method that called the last Java + /// method on the stack. + /// + UserClass* getCallingClass(); + + /// printBacktrace - Prints the backtrace of this thread. + /// + void printBacktrace(); + + /// getJavaFrameContext - Fill the vector with Java frames + /// currently on the stack. + void getJavaFrameContext(std::vector& context); /// printString - Prints the class. char *printString() const { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 03:31:45 2008 @@ -45,26 +45,6 @@ extern "C" const struct JNIInvokeInterface_ JNI_JavaVMTable; extern "C" struct JNINativeInterface_ JNI_JNIEnvTable; -#define BEGIN_EXCEPTION \ - JavaObject* excp = 0; \ - try { - -#define END_EXCEPTION \ - } catch(...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ - } \ - if (excp) { \ - JavaThread* th = JavaThread::get(); \ - th->pendingException = excp; \ - th->returnFromNative(); \ - } - -/* -static void* ptr_jvm = (JavaVM) &JNI_JavaVMTable; -static void *ptr_env = (void*) &JNI_JNIEnvTable; -*/ - jint GetVersion(JNIEnv *env) { return JNI_VERSION_1_4; } @@ -79,11 +59,12 @@ jclass FindClass(JNIEnv *env, const char *asciiz) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JnjvmClassLoader* loader = 0; - Jnjvm* vm = JavaThread::get()->getJVM(); - UserClass* currentClass = JavaJIT::getCallingClass(); + JavaThread* th = JavaThread::get(); + Jnjvm* vm = th->getJVM(); + UserClass* currentClass = th->getCallingClass(); if (currentClass) loader = currentClass->classLoader; else loader = vm->bootstrapLoader; @@ -93,14 +74,14 @@ if (cl->asClass()) cl->asClass()->initialiseClass(vm); return (jclass)(cl->getClassDelegatee(vm)); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jmethodID FromReflectedMethod(JNIEnv *env, jobject method) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); Classpath* upcalls = vm->upcalls; @@ -115,7 +96,7 @@ meth->printString()); } - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -129,7 +110,7 @@ jboolean IsAssignableFrom(JNIEnv *env, jclass sub, jclass sup) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl2 = NativeUtil::resolvedImplClass(vm, sup, false); @@ -137,7 +118,7 @@ return cl1->isAssignableFrom(cl2); - END_EXCEPTION + END_JNI_EXCEPTION return false; } @@ -151,7 +132,7 @@ jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaThread* th = JavaThread::get(); Jnjvm* vm = th->getJVM(); @@ -164,10 +145,10 @@ false, true, 0); init->invokeIntSpecial(vm, realCl, res, vm->asciizToStr(msg)); th->pendingException = res; - th->returnFromNative(); + th->returnFromJNI(); return 1; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -227,20 +208,20 @@ jobject AllocObject(JNIEnv *env, jclass clazz) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); if (cl->isArray()) JavaThread::get()->getJVM()->unknownError("implement me"); return (jobject)((UserClass*)cl)->doNew(JavaThread::get()->getJVM()); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jobject NewObject(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -252,7 +233,7 @@ va_end(ap); return (jobject)res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -266,7 +247,7 @@ jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue *args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaMethod* meth = (JavaMethod*)methodID; @@ -275,20 +256,20 @@ meth->invokeIntSpecialBuf(vm, cl, res, (void*)args); return (jobject)res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jclass GetObjectClass(JNIEnv *env, jobject obj) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION verifyNull((JavaObject*)obj); Jnjvm* vm = JavaThread::get()->getJVM(); return (jclass)((JavaObject*)obj)->classOf->getClassDelegatee(vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -322,7 +303,7 @@ jmethodID GetMethodID(JNIEnv* env, jclass clazz, const char *aname, const char *atype) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); @@ -333,14 +314,14 @@ return (jmethodID)meth; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jobject CallObjectMethod(JNIEnv *env, jobject obj, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -352,7 +333,7 @@ va_end(ap); return (jobject)res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -360,7 +341,7 @@ jobject CallObjectMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -368,7 +349,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jobject)meth->invokeJavaObjectVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -383,7 +364,7 @@ jboolean CallBooleanMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -395,7 +376,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -403,7 +384,7 @@ jboolean CallBooleanMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -411,7 +392,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jboolean)meth->invokeIntVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -432,7 +413,7 @@ jbyte CallByteMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -440,7 +421,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jbyte)meth->invokeIntVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -462,7 +443,7 @@ jchar CallCharMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -470,7 +451,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jchar)meth->invokeIntVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -492,7 +473,7 @@ jshort CallShortMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -500,7 +481,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jshort)meth->invokeIntVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -516,7 +497,7 @@ jint CallIntMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -528,7 +509,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -536,7 +517,7 @@ jint CallIntMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -544,7 +525,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jint)meth->invokeIntVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -567,7 +548,7 @@ jlong CallLongMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -575,7 +556,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jlong)meth->invokeLongVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -591,7 +572,7 @@ jfloat CallFloatMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -603,7 +584,7 @@ va_end(ap); return res; - END_EXCEPTION; + END_JNI_EXCEPTION; return 0.0; } @@ -611,7 +592,7 @@ jfloat CallFloatMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -619,7 +600,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jfloat)meth->invokeFloatVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0.0f; } @@ -635,7 +616,7 @@ jdouble CallDoubleMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -647,7 +628,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0.0; } @@ -655,7 +636,7 @@ jdouble CallDoubleMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -663,7 +644,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return (jdouble)meth->invokeDoubleVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0.0; } @@ -679,7 +660,7 @@ void CallVoidMethod(JNIEnv *env, jobject _obj, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -690,14 +671,14 @@ meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); - END_EXCEPTION + END_JNI_EXCEPTION } void CallVoidMethodV(JNIEnv *env, jobject _obj, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; @@ -705,7 +686,7 @@ UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); meth->invokeIntVirtualAP(vm, cl, obj, args); - END_EXCEPTION + END_JNI_EXCEPTION } @@ -916,7 +897,7 @@ void CallNonvirtualVoidMethod(JNIEnv *env, jobject _obj, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -927,7 +908,7 @@ meth->invokeIntSpecialAP(vm, cl, obj, ap); va_end(ap); - END_EXCEPTION + END_JNI_EXCEPTION } @@ -946,7 +927,7 @@ jfieldID GetFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); @@ -955,7 +936,7 @@ vm->asciizToUTF8(sig), 0, 1, 0) : 0); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -963,234 +944,234 @@ jobject GetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (jobject)field->getObjectField(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jboolean GetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (uint8)field->getInt8Field(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jbyte GetByteField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (sint8)field->getInt8Field(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jchar GetCharField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (uint16)field->getInt16Field(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jshort GetShortField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (sint16)field->getInt16Field(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jint GetIntField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (sint32)field->getInt32Field(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jlong GetLongField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (sint64)field->getLongField(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jfloat GetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return field->getFloatField(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jdouble GetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; return (jdouble)field->getDoubleField(o); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } void SetObjectField(JNIEnv *env, jobject obj, jfieldID fieldID, jobject value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setObjectField(o, (JavaObject*)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetBooleanField(JNIEnv *env, jobject obj, jfieldID fieldID, jboolean value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setInt8Field(o, (uint8)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetByteField(JNIEnv *env, jobject obj, jfieldID fieldID, jbyte value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setInt8Field(o, (uint8)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetCharField(JNIEnv *env, jobject obj, jfieldID fieldID, jchar value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setInt16Field(o, (uint16)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetShortField(JNIEnv *env, jobject obj, jfieldID fieldID, jshort value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setInt16Field(o, (sint16)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetIntField(JNIEnv *env, jobject obj, jfieldID fieldID, jint value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setInt32Field(o, (sint32)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetLongField(JNIEnv *env, jobject obj, jfieldID fieldID, jlong value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setLongField(o, (sint64)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetFloatField(JNIEnv *env, jobject obj, jfieldID fieldID, jfloat value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setFloatField(o, (float)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetDoubleField(JNIEnv *env, jobject obj, jfieldID fieldID, jdouble value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; field->setDoubleField(o, (float)value); - END_EXCEPTION + END_JNI_EXCEPTION } jmethodID GetStaticMethodID(JNIEnv *env, jclass clazz, const char *aname, const char *atype) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); @@ -1201,7 +1182,7 @@ return (jmethodID)meth; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1209,7 +1190,7 @@ jobject CallStaticObjectMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1220,21 +1201,21 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jobject CallStaticObjectMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jobject)meth->invokeJavaObjectStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1249,7 +1230,7 @@ jboolean CallStaticBooleanMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1260,7 +1241,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1268,14 +1249,14 @@ jboolean CallStaticBooleanMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jboolean)meth->invokeIntStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1289,7 +1270,7 @@ jbyte CallStaticByteMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1300,7 +1281,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1308,14 +1289,14 @@ jbyte CallStaticByteMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jbyte)meth->invokeIntStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1329,7 +1310,7 @@ jchar CallStaticCharMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1340,21 +1321,21 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jchar CallStaticCharMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jchar)meth->invokeIntStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1369,7 +1350,7 @@ jshort CallStaticShortMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1380,7 +1361,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1388,14 +1369,14 @@ jshort CallStaticShortMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jshort)meth->invokeIntStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1409,7 +1390,7 @@ jint CallStaticIntMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1420,21 +1401,21 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jint CallStaticIntMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jint)meth->invokeIntStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1449,7 +1430,7 @@ jlong CallStaticLongMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1460,7 +1441,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1468,14 +1449,14 @@ jlong CallStaticLongMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jlong)meth->invokeLongStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1492,7 +1473,7 @@ jfloat CallStaticFloatMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1503,7 +1484,7 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0.0f; } @@ -1511,14 +1492,14 @@ jfloat CallStaticFloatMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jfloat)meth->invokeFloatStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0.0f; } @@ -1534,7 +1515,7 @@ jdouble CallStaticDoubleMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1545,21 +1526,21 @@ va_end(ap); return res; - END_EXCEPTION + END_JNI_EXCEPTION return 0.0; } jdouble CallStaticDoubleMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); return (jdouble)meth->invokeDoubleStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION return 0.0; } @@ -1574,7 +1555,7 @@ void CallStaticVoidMethod(JNIEnv *env, jclass clazz, jmethodID methodID, ...) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION va_list ap; va_start(ap, methodID); @@ -1584,21 +1565,21 @@ meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); - END_EXCEPTION + END_JNI_EXCEPTION } void CallStaticVoidMethodV(JNIEnv *env, jclass clazz, jmethodID methodID, va_list args) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); meth->invokeIntStaticAP(vm, cl, args); - END_EXCEPTION + END_JNI_EXCEPTION } @@ -1611,7 +1592,7 @@ jfieldID GetStaticFieldID(JNIEnv *env, jclass clazz, const char *name, const char *sig) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); @@ -1620,14 +1601,14 @@ vm->asciizToUTF8(sig), true, true, 0) : 0); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jobject GetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1635,14 +1616,14 @@ void* Stat = cl->getStaticInstance(); return (jobject)field->getObjectField(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jboolean GetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1650,14 +1631,14 @@ void* Stat = cl->getStaticInstance(); return (jboolean)field->getInt8Field(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jbyte GetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1665,14 +1646,14 @@ void* Stat = cl->getStaticInstance(); return (jbyte)field->getInt8Field(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jchar GetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1680,14 +1661,14 @@ void* Stat = cl->getStaticInstance(); return (jchar)field->getInt16Field(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jshort GetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1695,14 +1676,14 @@ void* Stat = cl->getStaticInstance(); return (jshort)field->getInt16Field(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jint GetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1710,14 +1691,14 @@ void* Stat = cl->getStaticInstance(); return (jint)field->getInt32Field(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jlong GetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1725,14 +1706,14 @@ void* Stat = cl->getStaticInstance(); return (jlong)field->getLongField(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jfloat GetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1740,14 +1721,14 @@ void* Stat = cl->getStaticInstance(); return (jfloat)field->getFloatField(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jdouble GetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1755,7 +1736,7 @@ void* Stat = cl->getStaticInstance(); return (jdouble)field->getDoubleField(Stat); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1763,7 +1744,7 @@ void SetStaticObjectField(JNIEnv *env, jclass clazz, jfieldID fieldID, jobject value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1771,14 +1752,14 @@ void* Stat = cl->getStaticInstance(); field->setObjectField(Stat, (JavaObject*)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticBooleanField(JNIEnv *env, jclass clazz, jfieldID fieldID, jboolean value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1786,14 +1767,14 @@ void* Stat = cl->getStaticInstance(); field->setInt8Field(Stat, (uint8)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticByteField(JNIEnv *env, jclass clazz, jfieldID fieldID, jbyte value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1801,14 +1782,14 @@ void* Stat = cl->getStaticInstance(); field->setInt8Field(Stat, (sint8)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticCharField(JNIEnv *env, jclass clazz, jfieldID fieldID, jchar value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1816,14 +1797,14 @@ void* Stat = cl->getStaticInstance(); field->setInt16Field(Stat, (uint16)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticShortField(JNIEnv *env, jclass clazz, jfieldID fieldID, jshort value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1831,14 +1812,14 @@ void* Stat = cl->getStaticInstance(); field->setInt16Field(Stat, (sint16)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticIntField(JNIEnv *env, jclass clazz, jfieldID fieldID, jint value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1846,14 +1827,14 @@ void* Stat = cl->getStaticInstance(); field->setInt32Field(Stat, (sint32)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticLongField(JNIEnv *env, jclass clazz, jfieldID fieldID, jlong value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1861,14 +1842,14 @@ void* Stat = cl->getStaticInstance(); field->setLongField(Stat, (sint64)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticFloatField(JNIEnv *env, jclass clazz, jfieldID fieldID, jfloat value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1876,14 +1857,14 @@ void* Stat = cl->getStaticInstance(); field->setFloatField(Stat, (float)value); - END_EXCEPTION + END_JNI_EXCEPTION } void SetStaticDoubleField(JNIEnv *env, jclass clazz, jfieldID fieldID, jdouble value) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; @@ -1891,7 +1872,7 @@ void* Stat = cl->getStaticInstance(); field->setDoubleField(Stat, (double)value); - END_EXCEPTION + END_JNI_EXCEPTION } @@ -1920,12 +1901,12 @@ jstring NewStringUTF(JNIEnv *env, const char *bytes) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jstring)(vm->asciizToStr(bytes)); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1938,12 +1919,12 @@ const char *GetStringUTFChars(JNIEnv *env, jstring string, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy != 0) (*isCopy) = true; return strdup(((JavaString*)string)->strToAsciiz()); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -1955,18 +1936,18 @@ jsize GetArrayLength(JNIEnv *env, jarray array) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION return ((JavaArray*)array)->size; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); if (length < 0) vm->negativeArraySizeException(length); @@ -1982,20 +1963,20 @@ } } return (jobjectArray)res; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jobject GetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION ArrayObject* JA = (ArrayObject*)array; if (index >= JA->size) JavaThread::get()->getJVM()->indexOutOfBounds(JA, index); return (jobject)JA->elements[index]; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2004,109 +1985,109 @@ void SetObjectArrayElement(JNIEnv *env, jobjectArray array, jsize index, jobject val) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION ArrayObject* JA = (ArrayObject*)array; if (index >= JA->size) JavaThread::get()->getJVM()->indexOutOfBounds(JA, index); JA->elements[index] = (JavaObject*)val; - END_EXCEPTION + END_JNI_EXCEPTION } jbooleanArray NewBooleanArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jbooleanArray)vm->upcalls->ArrayOfByte->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jbyteArray NewByteArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jbyteArray)vm->upcalls->ArrayOfByte->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jcharArray NewCharArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jcharArray)vm->upcalls->ArrayOfChar->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jshortArray NewShortArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jshortArray)vm->upcalls->ArrayOfShort->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jintArray NewIntArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jintArray)vm->upcalls->ArrayOfInt->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jlongArray NewLongArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jlongArray)vm->upcalls->ArrayOfLong->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jfloatArray NewFloatArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jfloatArray)vm->upcalls->ArrayOfFloat->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jdoubleArray NewDoubleArray(JNIEnv *env, jsize len) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); return (jdoubleArray)vm->upcalls->ArrayOfDouble->doNew(len, vm); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2114,36 +2095,36 @@ jboolean *GetBooleanArrayElements(JNIEnv *env, jbooleanArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return (jboolean*)((ArrayUInt8*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jbyte *GetByteArrayElements(JNIEnv *env, jbyteArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((ArraySInt8*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jchar *GetCharArrayElements(JNIEnv *env, jcharArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((ArrayUInt16*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2151,36 +2132,36 @@ jshort *GetShortArrayElements(JNIEnv *env, jshortArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((ArraySInt16*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jint *GetIntArrayElements(JNIEnv *env, jintArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((ArraySInt32*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jlong *GetLongArrayElements(JNIEnv *env, jlongArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return (jlong*)(void*)(((ArrayLong*)array)->elements); - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2188,12 +2169,12 @@ jfloat *GetFloatArrayElements(JNIEnv *env, jfloatArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((ArrayFloat*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2201,12 +2182,12 @@ jdouble *GetDoubleArrayElements(JNIEnv *env, jdoubleArray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((ArrayDouble*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2377,34 +2358,34 @@ jint MonitorEnter(JNIEnv *env, jobject obj) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION ((JavaObject*)obj)->acquire(); return 1; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jint MonitorExit(JNIEnv *env, jobject obj) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION ((JavaObject*)obj)->release(); return 1; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } jint GetJavaVM(JNIEnv *env, JavaVM **vm) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* myvm = JavaThread::get()->getJVM(); (*vm) = (JavaVM*)(void*)(&(myvm->javavmEnv)); return 0; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2422,12 +2403,12 @@ void *GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION if (isCopy) (*isCopy) = false; return ((JavaArray*)array)->elements; - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2497,7 +2478,7 @@ void *GetDirectBufferAddress(JNIEnv *env, jobject _buf) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION Jnjvm* vm = NativeUtil::myVM(env); JavaObject* buf = (JavaObject*)_buf; @@ -2509,7 +2490,7 @@ return 0; } - END_EXCEPTION + END_JNI_EXCEPTION return 0; } @@ -2546,7 +2527,7 @@ jint GetEnv(JavaVM *vm, void **env, jint version) { - BEGIN_EXCEPTION + BEGIN_JNI_EXCEPTION JavaObject* th = JavaThread::currentThread(); Jnjvm* myvm = JavaThread::get()->getJVM(); @@ -2558,7 +2539,7 @@ return JNI_EDETACHED; } - END_EXCEPTION + END_JNI_EXCEPTION return 0; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 30 03:31:45 2008 @@ -47,9 +47,6 @@ #endif -typedef void (*clinit_t)(UserConstantPool*); - - /// initialiseClass - Java class initialisation. Java specification §2.17.5. void UserClass::initialiseClass(Jnjvm* vm) { @@ -197,8 +194,7 @@ JavaObject* exc = 0; if (meth) { try{ - clinit_t pred = (clinit_t)(intptr_t)meth->compiledPtr(); - pred(cl->getConstantPool()); + meth->invokeIntStatic(vm, cl); } catch(...) { exc = JavaThread::getJavaException(); assert(exc && "no exception?"); @@ -262,6 +258,13 @@ JavaThread::throwException(obj); } +JavaObject* Jnjvm::CreateError(UserClass* cl, JavaMethod* init, + const char* str) { + JavaObject* obj = cl->doNew(this); + init->invokeIntSpecial(this, cl, obj, str ? asciizToStr(str) : 0); + return obj; +} + void Jnjvm::error(UserClass* cl, JavaMethod* init, const char* fmt, ...) { char* tmp = (char*)alloca(4096); va_list ap; @@ -270,8 +273,7 @@ va_end(ap); if (cl && !bootstrapLoader->getModule()->isStaticCompiling()) { - JavaObject* obj = cl->doNew(this); - init->invokeIntSpecial(this, cl, obj, asciizToStr(tmp)); + JavaObject* obj = CreateError(cl, init, tmp); JavaThread::throwException(obj); } else { throw std::string(tmp); @@ -302,6 +304,37 @@ upcalls->InitNullPointerException, fmt, val); } +JavaObject* Jnjvm::CreateIndexOutOfBoundsException(sint32 entry) { + + char* tmp = (char*)alloca(4096); + snprintf(tmp, 4096, "%d", entry); + + return CreateError(upcalls->ArrayIndexOutOfBoundsException, + upcalls->InitArrayIndexOutOfBoundsException, tmp); +} + +JavaObject* Jnjvm::CreateNegativeArraySizeException() { + return CreateError(upcalls->NegativeArraySizeException, + upcalls->InitNegativeArraySizeException, 0); +} + +JavaObject* Jnjvm::CreateNullPointerException() { + return CreateError(upcalls->NullPointerException, + upcalls->InitNullPointerException, 0); +} + +JavaObject* Jnjvm::CreateOutOfMemoryError() { + return CreateError(upcalls->OutOfMemoryError, + upcalls->InitOutOfMemoryError, + "Java heap space"); +} + +JavaObject* Jnjvm::CreateClassCastException(JavaObject* obj, + UserCommonClass* cl) { + return CreateError(upcalls->ClassCastException, + upcalls->InitClassCastException, ""); +} + void Jnjvm::illegalAccessException(const char* msg) { error(upcalls->IllegalAccessException, upcalls->InitIllegalAccessException, msg); @@ -846,9 +879,17 @@ } void Jnjvm::executeClass(const char* className, ArrayObject* args) { + const UTF8* name = appClassLoader->asciizConstructUTF8(className); + UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true); + cl->initialiseClass(this); + + const UTF8* funcSign = + appClassLoader->asciizConstructUTF8("([Ljava/lang/String;)V"); + const UTF8* funcName = appClassLoader->asciizConstructUTF8("main"); + JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0); + try { - JavaJIT::invokeOnceVoid(this, appClassLoader, className, "main", - "([Ljava/lang/String;)V", ACC_STATIC, args); + method->invokeIntStatic(this, method->classDef, args); }catch(...) { } @@ -870,9 +911,16 @@ void Jnjvm::executePremain(const char* className, JavaString* args, JavaObject* instrumenter) { - JavaJIT::invokeOnceVoid(this, appClassLoader, className, "premain", - "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V", - ACC_STATIC, args, instrumenter); + const UTF8* name = appClassLoader->asciizConstructUTF8(className); + UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true); + cl->initialiseClass(this); + + const UTF8* funcSign = appClassLoader->asciizConstructUTF8( + "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V"); + const UTF8* funcName = appClassLoader->asciizConstructUTF8("premain"); + JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0); + + method->invokeIntStatic(this, method->classDef, args, instrumenter); } void Jnjvm::waitForExit() { @@ -1147,3 +1195,41 @@ bootstrapThread = new JavaThread(0, 0, this); bootstrapThread->start((void (*)(mvm::Thread*))mainCompilerStart); } + + + +void Jnjvm::addMethodInFunctionMap(JavaMethod* meth, void* addr) { + FunctionMapLock.acquire(); + JavaFunctionMap.insert(std::make_pair(addr, meth)); + FunctionMapLock.release(); +} + +void Jnjvm::removeMethodsInFunctionMap(JnjvmClassLoader* loader) { + // Loop over all methods in the map to find which ones belong + // to this class loader. + FunctionMapLock.acquire(); + std::map::iterator temp; + for (std::map::iterator i = JavaFunctionMap.begin(), + e = JavaFunctionMap.end(); i != e;) { + if (i->second->classDef->classLoader == loader) { + temp = i; + ++i; + JavaFunctionMap.erase(temp); + } else { + ++i; + } + } + FunctionMapLock.release(); +} + +JavaMethod* Jnjvm::IPToJavaMethod(void* Addr) { + FunctionMapLock.acquire(); + std::map::iterator I = JavaFunctionMap.upper_bound(Addr); + assert(I != JavaFunctionMap.begin() && "Wrong value in function map"); + FunctionMapLock.release(); + + // Decrement because we had the "greater than" value. + I--; + return I->second; + +} Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Tue Dec 30 03:31:45 2008 @@ -115,6 +115,11 @@ /// bootstrapThread - The initial thread of this JVM. /// JavaThread* bootstrapThread; + + /// CreateError - Creates a Java object of the specified exception class + /// and calling its function. + /// + JavaObject* CreateError(UserClass* cl, JavaMethod* meth, const char* str); /// error - Throws an exception in the execution of a JVM for the thread /// that calls this functions. This is used internally by Jnjvm to control @@ -240,6 +245,16 @@ StringMap hashStr; public: + + /// CreateExceptions - These are the runtime exceptions thrown by Java code + /// compiled by VMKit. + /// + JavaObject* CreateNullPointerException(); + JavaObject* CreateOutOfMemoryError(); + JavaObject* CreateIndexOutOfBoundsException(sint32 entry); + JavaObject* CreateNegativeArraySizeException(); + JavaObject* CreateClassCastException(JavaObject* obj, UserCommonClass* cl); + /// Exceptions - These are the only exceptions VMKit will make. /// void arrayStoreException(); @@ -326,6 +341,32 @@ /// waitForExit - Waits that there are no more non-daemon threads in this JVM. /// virtual void waitForExit(); + +private: + + /// JavaFunctionMap - Map of Java method to function pointers. This map is + /// used when walking the stack so that VMKit knows which Java method is + /// executing on the stack. + /// + std::map JavaFunctionMap; + + /// FunctionMapLock - Spin lock to protect the JavaFunctionMap. + /// + mvm::SpinLock FunctionMapLock; + +public: + /// addMethodInFunctionMap - A new method pointer in the function map. + /// + void addMethodInFunctionMap(JavaMethod* meth, void* addr); + + /// removeMethodsInFunctionMap - Removes all methods compiled by this + /// class loader from the function map. + /// + void removeMethodsInFunctionMap(JnjvmClassLoader* loader); + + /// IPToJavaMethod - Map an instruction pointer to the Java method. + /// + JavaMethod* IPToJavaMethod(void* ip); #ifdef ISOLATE static Jnjvm* RunningIsolates[NR_ISOLATES]; @@ -336,6 +377,7 @@ virtual void stopService(); #endif + }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Tue Dec 30 03:31:45 2008 @@ -736,6 +736,9 @@ JnjvmClassLoader::~JnjvmClassLoader() { + if (isolate) + isolate->removeMethodsInFunctionMap(this); + if (classes) { classes->~ClassMap(); allocator.Deallocate(classes); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 30 03:31:45 2008 @@ -1627,6 +1627,7 @@ virtualBufFunction = createFunctionCallBuf(true); signature->setVirtualCallBuf((intptr_t) mvm::MvmModule::executionEngine->getPointerToGlobal(virtualBufFunction)); + // Now that it's compiled, we don't need the IR anymore virtualBufFunction->deleteBody(); } return virtualBufFunction; @@ -1639,6 +1640,7 @@ virtualAPFunction = createFunctionCallAP(true); signature->setVirtualCallAP((intptr_t) mvm::MvmModule::executionEngine->getPointerToGlobal(virtualAPFunction)); + // Now that it's compiled, we don't need the IR anymore virtualAPFunction->deleteBody(); } return virtualAPFunction; @@ -1651,6 +1653,7 @@ staticBufFunction = createFunctionCallBuf(false); signature->setStaticCallBuf((intptr_t) mvm::MvmModule::executionEngine->getPointerToGlobal(staticBufFunction)); + // Now that it's compiled, we don't need the IR anymore staticBufFunction->deleteBody(); } return staticBufFunction; @@ -1663,6 +1666,7 @@ staticAPFunction = createFunctionCallAP(false); signature->setStaticCallAP((intptr_t) mvm::MvmModule::executionEngine->getPointerToGlobal(staticAPFunction)); + // Now that it's compiled, we don't need the IR anymore staticAPFunction->deleteBody(); } return staticAPFunction; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Tue Dec 30 03:31:45 2008 @@ -78,6 +78,8 @@ } void* val = meth->compiledPtr(); + + if (F->isDeclaration()) mvm::MvmModule::executionEngine->updateGlobalMapping(F, val); @@ -106,6 +108,9 @@ void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(func); func->deleteBody(); + + Jnjvm* vm = JavaThread::get()->getJVM(); + vm->addMethodInFunctionMap(meth, res); return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Tue Dec 30 03:31:45 2008 @@ -24,6 +24,38 @@ class Typedef; +#define BEGIN_NATIVE_EXCEPTION(level) \ + JavaObject* excp = 0; \ + JavaThread* __th = JavaThread::get(); \ + __th->startNative(level); \ + try { + +#define END_NATIVE_EXCEPTION \ + } catch(...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + __th->pendingException = excp; \ + __th->returnFromNative(); \ + } \ + __th->endNative(); + +#define BEGIN_JNI_EXCEPTION \ + JavaObject* excp = 0; \ + try { + +#define END_JNI_EXCEPTION \ + } catch(...) { \ + excp = JavaThread::getJavaException(); \ + JavaThread::clearException(); \ + } \ + if (excp) { \ + JavaThread* th = JavaThread::get(); \ + th->pendingException = excp; \ + th->returnFromJNI(); \ + } + class NativeUtil { public: Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=61487&r1=61486&r2=61487&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Tue Dec 30 03:31:45 2008 @@ -266,12 +266,6 @@ pm->run(*func); } -#if defined(__MACH__) && !defined(__i386__) -#define FRAME_IP(fp) (fp[2]) -#else -#define FRAME_IP(fp) (fp[1]) -#endif - int MvmModule::getBacktrace(void** stack, int size) { void** addr = (void**)__builtin_frame_address(0); int cpt = 0; From nicolas.geoffray at lip6.fr Tue Dec 30 02:08:35 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 10:08:35 -0000 Subject: [vmkit-commits] [vmkit] r61488 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaMetaJIT.cpp JavaThread.cpp JavaThread.h Jni.cpp NativeUtil.h Message-ID: <200812301008.mBUA8mxk027788@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 04:08:05 2008 New Revision: 61488 URL: http://llvm.org/viewvc/llvm-project?rev=61488&view=rev Log: Commentify and rename some functions for clarification. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=61488&r1=61487&r2=61488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Tue Dec 30 04:08:05 2008 @@ -83,7 +83,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -113,7 +113,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -142,7 +142,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -170,7 +170,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -197,7 +197,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -223,7 +223,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -278,7 +278,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -305,7 +305,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -331,7 +331,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -358,7 +358,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -385,7 +385,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ @@ -411,7 +411,7 @@ } \ if (excp) { \ th->pendingException = excp; \ - th->returnFromJava(); \ + th->throwFromJava(); \ } \ th->endJava(); \ return res; \ Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61488&r1=61487&r2=61488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 04:08:05 2008 @@ -26,11 +26,6 @@ const unsigned int JavaThread::StateWaiting = 1; const unsigned int JavaThread::StateInterrupted = 2; -void JavaThread::print(mvm::PrintBuffer* buf) const { - buf->write("Thread:"); - if (javaThread) javaThread->print(buf); -} - JavaThread::JavaThread(JavaObject* thread, JavaObject* vmth, Jnjvm* isolate) { javaThread = thread; vmThread = vmth; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61488&r1=61487&r2=61488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 04:08:05 2008 @@ -25,43 +25,101 @@ class JavaObject; class Jnjvm; +/// JavaThread - This class is the internal representation of a Java thread. +/// It maintains thread-specific information such as its state, the current +/// exception if there is one, the layout of the stack, etc. +/// class JavaThread : public mvm::Thread { + + public: + + /// VT - The virtual table of JavaThread objects, so that we know + /// if a thread is a JavaThread. + /// static VirtualTable *VT; + + /// javaThread - The Java representation of this thread. + /// JavaObject* javaThread; + + /// vmThread - The VMThread object of this thread. + /// JavaObject* vmThread; + + /// lock - This lock is used when waiting or being notified or interrupted. + /// mvm::LockNormal lock; + + /// varcond - Condition variable when the thread needs to be awaken from + /// a wait. + /// mvm::Cond varcond; + + /// pendingException - The Java exception currently pending. + /// JavaObject* pendingException; + + /// internalPendingException - The C++ exception currencty pending. + /// void* internalPendingException; - uint32 interruptFlag; - uint32 state; - std::vector sjlj_buffers; - std::vector addresses; + /// interruptFlag - Has this thread been interrupted? + /// + uint32 interruptFlag; + static const unsigned int StateRunning; static const unsigned int StateWaiting; static const unsigned int StateInterrupted; - void print(mvm::PrintBuffer *buf) const; + /// state - The current state of this thread: Running, Waiting or Interrupted. + uint32 state; + + /// sjlj_buffers - Setjmp buffers pushed when entering a non-JVM native + /// function and popped when leaving the function. The buffer is used when + /// the native function throws an exception through a JNI throwException call. + /// + std::vector sjlj_buffers; + + /// addresses - The list of return addresses which represent native/Java cross + /// calls. + /// + std::vector addresses; + + /// tracer - Traces GC-objects pointed by this thread object. + /// virtual void TRACER; + + /// JavaThread - Empty constructor, used to get the VT. + /// JavaThread() { #ifdef SERVICE replacedEIPs = 0; #endif } + + /// ~JavaThread - Delete any potential malloc'ed objects used by this thread. + /// ~JavaThread(); + /// JavaThread - Creates a Java thread. + /// JavaThread(JavaObject* thread, JavaObject* vmThread, Jnjvm* isolate); + /// get - Get the current thread as a JnJVM object. + /// static JavaThread* get() { return (JavaThread*)mvm::Thread::get(); } + /// getJVM - Get the JnJVM in which this thread executes. + /// Jnjvm* getJVM() { return (Jnjvm*)MyVM; } + /// currentThread - Return the current thread as a Java object. + /// static JavaObject* currentThread() { JavaThread* result = get(); if (result != 0) @@ -69,21 +127,26 @@ else return 0; } - + + /// getException - Return the C++ specific exception object. + /// static void* getException() { // 32 = sizeof(_Unwind_Exception) in libgcc... return (void*) ((uintptr_t)JavaThread::get()->internalPendingException - 32); } - /// throwException - Throws the given exception in the current thread. + /// throwException - Throw the given exception in the current thread. /// static void throwException(JavaObject* obj); - /// throwPendingException - Throws a pending exception created by JNI. + /// throwPendingException - Throw a pending exception created by JNI. /// static void throwPendingException(); + /// compareException - Compare the pending exception's class with the + /// given class. + /// static bool compareException(UserClass* cl) { JavaObject* pe = JavaThread::get()->pendingException; assert(pe && "no pending exception?"); @@ -91,11 +154,15 @@ return val; } + /// getJavaException - Return the pending exception. + /// static JavaObject* getJavaException() { return JavaThread::get()->pendingException; } - void returnFromJNI() { + /// throwFromJNI - Throw an exception after executing JNI code. + /// + void throwFromJNI() { assert(sjlj_buffers.size()); #if defined(__MACH__) longjmp((int*)sjlj_buffers.back(), 1); @@ -104,23 +171,36 @@ #endif } - void returnFromNative() { + /// throwFromNative - Throw an exception after executing Native code. + /// + void throwFromNative() { addresses.pop_back(); throwPendingException(); } - void returnFromJava() { + /// throwFromJava - Throw an exception after executing Java code. + /// + void throwFromJava() { addresses.pop_back(); throwPendingException(); } + /// startNative - Record that we are entering native code. + /// void startNative(int level); + + /// startJava - Record that we are entering Java code. + /// void startJava(); + /// endNative - Record that we are leaving native code. + /// void endNative() { addresses.pop_back(); } + /// endNative - Record that we are leaving Java code. + /// void endJava() { addresses.pop_back(); } @@ -136,30 +216,42 @@ /// getJavaFrameContext - Fill the vector with Java frames /// currently on the stack. + /// void getJavaFrameContext(std::vector& context); - /// printString - Prints the class. - char *printString() const { - mvm::PrintBuffer *buf = mvm::PrintBuffer::alloc(); - print(buf); - return buf->contents()->cString(); +private: + /// internalClearException - Clear the C++ and Java exceptions + /// currently pending. + /// + virtual void internalClearException() { + pendingException = 0; + internalPendingException = 0; } +public: + #ifdef SERVICE + /// ServiceException - The exception that will be thrown if a bundle is + /// stopped. JavaObject* ServiceException; + + /// replacedEIPs - List of instruction pointers which must be replaced + /// to a function that throws an exception. We maintain this list and update + /// the stack correctly so that Dwarf unwinding does not complain. + /// void** replacedEIPs; + + /// eipIndex - The current index in the replacedIPs list. + /// uint32_t eipIndex; #endif + /// isJavaThread - Is the given thread a Java thread? + /// static bool isJavaThread(mvm::Thread* th) { return ((void**)th)[0] == VT; } -private: - virtual void internalClearException() { - pendingException = 0; - internalPendingException = 0; - } }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61488&r1=61487&r2=61488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 04:08:05 2008 @@ -145,7 +145,7 @@ false, true, 0); init->invokeIntSpecial(vm, realCl, res, vm->asciizToStr(msg)); th->pendingException = res; - th->returnFromJNI(); + th->throwFromJNI(); return 1; END_JNI_EXCEPTION Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61488&r1=61487&r2=61488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Tue Dec 30 04:08:05 2008 @@ -37,7 +37,7 @@ } \ if (excp) { \ __th->pendingException = excp; \ - __th->returnFromNative(); \ + __th->throwFromNative(); \ } \ __th->endNative(); @@ -53,7 +53,7 @@ if (excp) { \ JavaThread* th = JavaThread::get(); \ th->pendingException = excp; \ - th->returnFromJNI(); \ + th->throwFromJNI(); \ } class NativeUtil { From nicolas.geoffray at lip6.fr Tue Dec 30 04:17:36 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 12:17:36 -0000 Subject: [vmkit-commits] [vmkit] r61489 - /vmkit/trunk/include/mvm/Threads/Thread.h Message-ID: <200812301217.mBUCHdAd003668@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 06:17:04 2008 New Revision: 61489 URL: http://llvm.org/viewvc/llvm-project?rev=61489&view=rev Log: Commentify. Modified: vmkit/trunk/include/mvm/Threads/Thread.h Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=61489&r1=61488&r2=61489&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 30 06:17:04 2008 @@ -15,31 +15,57 @@ #include "MvmGC.h" -class Collector; - namespace mvm { class VirtualMachine; +/// CircularBase - This class represents a circular list. Classes that extend +/// this class automatically place their instances in a circular list. +/// class CircularBase { + /// _next - The next object in the list. + /// CircularBase *_next; + + /// _prev - The previous object in the list. + /// CircularBase *_prev; public: + + /// next - Get the next object in the list. + /// inline CircularBase *next() { return _next; } + + /// prev - Get the previous object in the list. + /// inline CircularBase *prev() { return _prev; } + /// next - Set the next object in the list. + /// inline void next(CircularBase *n) { _next = n; } + + /// prev - Set the previous object in the list. + /// inline void prev(CircularBase *p) { _prev = p; } + /// CricularBase - Creates the object as a single element in the list. + /// inline CircularBase() { alone(); } + + /// CircularBase - Creates the object and place it in the given list. + /// inline explicit CircularBase(CircularBase *p) { append(p); } + /// remove - Remove the object from its list. + /// inline void remove() { _prev->_next = _next; _next->_prev = _prev; alone(); } + /// append - Add the object in the list. + /// inline void append(CircularBase *p) { _prev = p; _next = p->_next; @@ -47,6 +73,8 @@ _prev->_next = this; } + /// alone - Set the object as being part of a new empty list. + /// inline void alone() { _prev = _next = this; } }; @@ -124,11 +152,18 @@ static void internalThreadStart(mvm::Thread* th); /// internalClearException - Clear any pending exception. + /// virtual void internalClearException() {} public: - + + /// ~Thread - Give the class a home. + /// virtual ~Thread() {} + + /// tracer - Does nothing. Used for child classes which may defined + /// a tracer. + /// virtual void TRACER {} @@ -138,15 +173,26 @@ th->internalClearException(); } + /// IDMask - Apply this mask to the stack pointer to get the Thread object. + /// static const uint64_t IDMask = 0x7FF00000; + /// operator new - Allocate the Thread object as well as the stack for this + /// Thread. The thread object is inlined in the stack. + /// void* operator new(size_t sz); + /// operator delete - Free the stack so that another thread can use it. + /// void operator delete(void* obj); + /// routine - The function to invoke when the thread starts. + /// void (*routine)(mvm::Thread*); #ifdef SERVICE + /// stoppingService - The service that is currently stopping. + /// VirtualMachine* stoppingService; #endif From nicolas.geoffray at lip6.fr Tue Dec 30 04:19:15 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 12:19:15 -0000 Subject: [vmkit-commits] [vmkit] r61490 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMStackWalker.cpp VMCore/JavaMetaJIT.cpp VMCore/JavaThread.cpp VMCore/JavaThread.h VMCore/Jni.cpp VMCore/NativeUtil.h Message-ID: <200812301219.mBUCJHpT003743@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 06:18:59 2008 New Revision: 61490 URL: http://llvm.org/viewvc/llvm-project?rev=61490&view=rev Log: Code cleanup. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=61490&r1=61489&r2=61490&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Tue Dec 30 06:18:59 2008 @@ -8,7 +8,7 @@ // //===----------------------------------------------------------------------===// -#include +#include #include "types.h" @@ -107,7 +107,7 @@ BEGIN_NATIVE_EXCEPTION(0) JavaThread* th = JavaThread::get(); UserClass* cl = th->getCallingClass(); - if (cl) res = cl->classLoader->getJavaClassLoader(); + res = cl->classLoader->getJavaClassLoader(); END_NATIVE_EXCEPTION return res; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=61490&r1=61489&r2=61490&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Tue Dec 30 06:18:59 2008 @@ -71,18 +71,16 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = (((void***)obj)[0])[offset];\ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -101,18 +99,16 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, _buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -130,18 +126,16 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, _buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -158,18 +152,16 @@ \ Signdef* sign = getSignature(); \ void* func = (((void***)obj)[0])[offset];\ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -185,18 +177,16 @@ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -211,18 +201,16 @@ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -266,18 +254,16 @@ verifyNull(obj); \ void* func = (((void***)obj)[0])[offset];\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -293,18 +279,16 @@ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(cl->getConstantPool(), func, obj, ap);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -319,18 +303,16 @@ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(cl->getConstantPool(), func, ap);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -346,18 +328,16 @@ verifyNull(obj);\ void* func = (((void***)obj)[0])[offset];\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = false; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -373,18 +353,16 @@ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ + bool exc = 0; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(cl->getConstantPool(), func, obj, buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ @@ -399,18 +377,16 @@ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - JavaObject* excp = 0; \ JavaThread* th = JavaThread::get(); \ th->startJava(); \ + bool exc = false; \ TYPE res = 0; \ try { \ res = ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(cl->getConstantPool(), func, buf);\ } catch (...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + exc = true; \ } \ - if (excp) { \ - th->pendingException = excp; \ + if (exc) { \ th->throwFromJava(); \ } \ th->endJava(); \ Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61490&r1=61489&r2=61490&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 06:18:59 2008 @@ -108,8 +108,7 @@ JavaMethod* meth = getJVM()->IPToJavaMethod(ip); - if (meth) return meth->classDef; - else return 0; + return meth->classDef; } void JavaThread::getJavaFrameContext(std::vector& context) { @@ -128,7 +127,7 @@ void* ip = FRAME_IP(addr); context.push_back(ip); addr = (void**)addr[0]; - // End walking the stack when we cross a native -> Java call. Here + // We end walking the stack when we cross a native -> Java call. Here // the iterator points to a native -> Java call. We dereference addr twice // because a native -> Java call always contains the signature function. } while (((void***)addr)[0][0] != *it); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61490&r1=61489&r2=61490&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 06:18:59 2008 @@ -164,6 +164,7 @@ /// void throwFromJNI() { assert(sjlj_buffers.size()); + internalPendingException = 0; #if defined(__MACH__) longjmp((int*)sjlj_buffers.back(), 1); #else Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61490&r1=61489&r2=61490&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 06:18:59 2008 @@ -130,13 +130,13 @@ } -jint ThrowNew(JNIEnv* env, jclass clazz, const char *msg) { +jint ThrowNew(JNIEnv* env, jclass Cl, const char *msg) { BEGIN_JNI_EXCEPTION - JavaThread* th = JavaThread::get(); - Jnjvm* vm = th->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); + Jnjvm* vm = NativeUtil::myVM(env); + verifyNull(Cl); + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); if (!cl->asClass()) assert(0 && "implement me"); UserClass* realCl = cl->asClass(); JavaObject* res = realCl->doNew(vm); Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61490&r1=61489&r2=61490&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Tue Dec 30 06:18:59 2008 @@ -25,34 +25,30 @@ #define BEGIN_NATIVE_EXCEPTION(level) \ - JavaObject* excp = 0; \ JavaThread* __th = JavaThread::get(); \ __th->startNative(level); \ + bool __exc = false; \ try { #define END_NATIVE_EXCEPTION \ } catch(...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + __exc = true; \ } \ - if (excp) { \ - __th->pendingException = excp; \ + if (__exc) { \ __th->throwFromNative(); \ } \ __th->endNative(); #define BEGIN_JNI_EXCEPTION \ - JavaObject* excp = 0; \ + JavaThread* th = JavaThread::get(); \ + bool __exc = 0; \ try { #define END_JNI_EXCEPTION \ } catch(...) { \ - excp = JavaThread::getJavaException(); \ - JavaThread::clearException(); \ + __exc = true; \ } \ - if (excp) { \ - JavaThread* th = JavaThread::get(); \ - th->pendingException = excp; \ + if (__exc) { \ th->throwFromJNI(); \ } From nicolas.geoffray at lip6.fr Tue Dec 30 04:36:01 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 12:36:01 -0000 Subject: [vmkit-commits] [vmkit] r61491 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.h JavaJIT.cpp JnjvmClassLoader.cpp JnjvmClassLoader.h NativeUtil.cpp NativeUtil.h Message-ID: <200812301236.mBUCa9VS004387@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 06:35:32 2008 New Revision: 61491 URL: http://llvm.org/viewvc/llvm-project?rev=61491&view=rev Log: Code cleanup, no functionality changes. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61491&r1=61490&r2=61491&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Dec 30 06:35:32 2008 @@ -37,6 +37,7 @@ class JavaField; class JavaMethod; class JavaObject; +class Reader; class Signdef; class Typedef; class UTF8; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61491&r1=61490&r2=61491&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 06:35:32 2008 @@ -187,7 +187,7 @@ bool jnjvm = false; natPtr = natPtr ? natPtr : - NativeUtil::nativeLookup(compilingClass, compilingMethod, jnjvm); + compilingClass->classLoader->nativeLookup(compilingMethod, jnjvm); if (!natPtr && !module->isStaticCompiling()) { fprintf(stderr, "Native function %s not found. Probably " Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=61491&r1=61490&r2=61491&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Tue Dec 30 06:35:32 2008 @@ -884,3 +884,23 @@ intptr_t JnjvmClassLoader::loadInLib(const char* name, void* handle) { return (intptr_t)dlsym(handle, name); } + +intptr_t JnjvmClassLoader::nativeLookup(JavaMethod* meth, bool& jnjvm) { + + const UTF8* jniConsClName = meth->classDef->name; + const UTF8* jniConsName = meth->name; + const UTF8* jniConsType = meth->type; + sint32 clen = jniConsClName->size; + sint32 mnlen = jniConsName->size; + sint32 mtlen = jniConsType->size; + + char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + + ((mnlen + clen + mtlen) << 1)); + meth->jniConsFromMeth(buf); + intptr_t res = loadInLib(buf, jnjvm); + if (!res) { + meth->jniConsFromMethOverloaded(buf); + res = loadInLib(buf, jnjvm); + } + return res; +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=61491&r1=61490&r2=61491&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Tue Dec 30 06:35:32 2008 @@ -25,19 +25,18 @@ namespace jnjvm { class ArrayUInt8; -class Attribut; class UserClass; class UserClassArray; class ClassMap; class Classpath; class UserCommonClass; +class JavaMethod; class JavaObject; class JavaString; class Jnjvm; class JnjvmBootstrapLoader; class JnjvmModule; class JnjvmModuleProvider; -class Reader; class Signdef; class SignMap; class Typedef; @@ -260,6 +259,12 @@ /// loadLib - Loads the library with the given name. /// void* loadLib(const char* buf); + + /// nativeLookup - Lookup in the class loader a function pointer for the + /// method. Also set in the jnjvm parameter is the function is defined in + /// JnJVM. + /// + intptr_t nativeLookup(JavaMethod* meth, bool& jnjvm); }; /// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=61491&r1=61490&r2=61491&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Tue Dec 30 06:35:32 2008 @@ -147,26 +147,6 @@ } -intptr_t NativeUtil::nativeLookup(CommonClass* cl, JavaMethod* meth, - bool& jnjvm) { - const UTF8* jniConsClName = cl->name; - const UTF8* jniConsName = meth->name; - const UTF8* jniConsType = meth->type; - sint32 clen = jniConsClName->size; - sint32 mnlen = jniConsName->size; - sint32 mtlen = jniConsType->size; - - char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + - ((mnlen + clen + mtlen) << 1)); - meth->jniConsFromMeth(buf); - intptr_t res = cl->classLoader->loadInLib(buf, jnjvm); - if (!res) { - meth->jniConsFromMethOverloaded(buf); - res = cl->classLoader->loadInLib(buf, jnjvm); - } - return res; -} - UserCommonClass* NativeUtil::resolvedImplClass(Jnjvm* vm, jclass clazz, bool doClinit) { UserCommonClass* cl = ((JavaObjectClass*)clazz)->getClass(); Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61491&r1=61490&r2=61491&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Tue Dec 30 06:35:32 2008 @@ -15,12 +15,10 @@ namespace jnjvm { class ArrayObject; -class CommonClass; class JavaMethod; class JavaObject; class Jnjvm; class JnjvmClassLoader; -class Signdef; class Typedef; @@ -52,18 +50,41 @@ th->throwFromJNI(); \ } +/// NativeUtil - This class groups a set of static function useful when dealing +/// with Java objects in native code. +/// class NativeUtil { public: + /// myVM - Get the current virtual machine. + /// static Jnjvm* myVM(JNIEnv* env); - static intptr_t nativeLookup(CommonClass* cl, JavaMethod* meth, bool& jnjvm); + + /// resolvedImplClass - Return the internal representation of the + /// java.lang.Class object. The class must be resolved. + // static UserCommonClass* resolvedImplClass(Jnjvm* vm, jclass clazz, bool doClinit); + + /// decapsulePrimitive - Based on the signature argument, decapsule + /// obj as a primitive and put it in the buffer. + /// static void decapsulePrimitive(Jnjvm *vm, uintptr_t &buf, JavaObject* obj, const Typedef* signature); + /// getClassType - Return the java.lang.Class of the type, with the given + /// class loader. + /// static JavaObject* getClassType(JnjvmClassLoader* loader, Typedef* type); + + /// getParameterTypes - Get the java.lang.Class of the parameters of + /// the method, with the given class loader. + /// static ArrayObject* getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth); + + /// getExceptionTypes - Get the java.lang.Class of the exceptions of the + /// method, with the given class loader. + /// static ArrayObject* getExceptionTypes(UserClass* cl, JavaMethod* meth); }; From nicolas.geoffray at lip6.fr Tue Dec 30 05:08:12 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 13:08:12 -0000 Subject: [vmkit-commits] [vmkit] r61492 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathConstructor.cpp Classpath/ClasspathMethod.cpp VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/NativeUtil.cpp VMCore/NativeUtil.h Message-ID: <200812301308.mBUD8Ec6005468@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 07:08:02 2008 New Revision: 61492 URL: http://llvm.org/viewvc/llvm-project?rev=61492&view=rev Log: Reorganize code. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=61492&r1=61491&r2=61492&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Tue Dec 30 07:08:02 2008 @@ -57,7 +57,7 @@ UserClass* cl = internalGetClass(vm, meth, cons); JnjvmClassLoader* loader = cl->classLoader; - res = (jobject)(NativeUtil::getParameterTypes(loader, meth)); + res = (jobject)meth->getParameterTypes(loader); END_NATIVE_EXCEPTION return res; @@ -167,8 +167,9 @@ JavaField* field = vm->upcalls->constructorSlot; JavaMethod* meth = (JavaMethod*)field->getInt32Field((JavaObject*)cons); UserClass* cl = internalGetClass(vm, meth, cons); + JnjvmClassLoader* loader = cl->classLoader; - res = (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); + res = (jobjectArray)meth->getExceptionTypes(loader); END_NATIVE_EXCEPTION Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=61492&r1=61491&r2=61492&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Tue Dec 30 07:08:02 2008 @@ -77,8 +77,7 @@ JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; - Typedef* ret = meth->getSignature()->getReturnType(); - res = (jclass)NativeUtil::getClassType(loader, ret); + res = (jclass)meth->getReturnType(loader); END_NATIVE_EXCEPTION @@ -101,7 +100,8 @@ JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; - res = (jobject)(NativeUtil::getParameterTypes(loader, meth)); + + res = (jobject)(meth->getParameterTypes(loader)); END_NATIVE_EXCEPTION @@ -262,7 +262,8 @@ JavaField* slot = vm->upcalls->methodSlot; JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)_meth); UserClass* cl = internalGetClass(vm, meth, _meth); - res = (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); + JnjvmClassLoader* loader = cl->classLoader; + res = (jobjectArray)meth->getExceptionTypes(loader); END_NATIVE_EXCEPTION Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61492&r1=61491&r2=61492&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Tue Dec 30 07:08:02 2008 @@ -983,6 +983,59 @@ } } +static JavaObject* getClassType(Jnjvm* vm, JnjvmClassLoader* loader, + Typedef* type) { + UserCommonClass* res = type->assocClass(loader); + assert(res && "No associated class"); + return res->getClassDelegatee(vm); +} + +ArrayObject* JavaMethod::getParameterTypes(JnjvmClassLoader* loader) { + Jnjvm* vm = JavaThread::get()->getJVM(); + Signdef* sign = getSignature(); + Typedef* const* arguments = sign->getArgumentsType(); + ArrayObject* res = + (ArrayObject*)vm->upcalls->classArrayClass->doNew(sign->nbArguments, vm); + + for (uint32 index = 0; index < sign->nbArguments; ++index) { + res->elements[index] = getClassType(vm, loader, arguments[index]); + } + + return res; + +} + +JavaObject* JavaMethod::getReturnType(JnjvmClassLoader* loader) { + Jnjvm* vm = JavaThread::get()->getJVM(); + Typedef* ret = getSignature()->getReturnType(); + return getClassType(vm, loader, ret); +} + +ArrayObject* JavaMethod::getExceptionTypes(JnjvmClassLoader* loader) { + Attribut* exceptionAtt = lookupAttribut(Attribut::exceptionsAttribut); + Jnjvm* vm = JavaThread::get()->getJVM(); + if (exceptionAtt == 0) { + return (ArrayObject*)vm->upcalls->classArrayClass->doNew(0, vm); + } else { + UserConstantPool* ctp = classDef->getConstantPool(); + Reader reader(exceptionAtt, classDef->getBytes()); + uint16 nbe = reader.readU2(); + ArrayObject* res = + (ArrayObject*)vm->upcalls->classArrayClass->doNew(nbe, vm); + + for (uint16 i = 0; i < nbe; ++i) { + uint16 idx = reader.readU2(); + UserCommonClass* cl = ctp->loadClass(idx); + assert(cl->asClass() && "Wrong exception type"); + cl->asClass()->resolveClass(); + JavaObject* obj = cl->getClassDelegatee(vm); + res->elements[i] = obj; + } + return res; + } +} + + void Class::resolveStaticClass() { classLoader->getModule()->resolveStaticClass((Class*)this); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61492&r1=61491&r2=61492&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Dec 30 07:08:02 2008 @@ -28,6 +28,7 @@ namespace jnjvm { +class ArrayObject; class ArrayUInt8; class Enveloppe; class Class; @@ -1000,11 +1001,31 @@ /// const char* printString() const; - /// jniConsFromMeth - Construct the JNI name of this method. + /// jniConsFromMeth - Construct the JNI name of this method as if + /// there is no other function in the class with the same name. /// void jniConsFromMeth(char* buf) const; + + /// jniConsFromMethOverloaded - Construct the JNI name of this method + /// as if its name is overloaded in the class. + /// void jniConsFromMethOverloaded(char* buf) const; + /// getParameterTypes - Get the java.lang.Class of the parameters of + /// the method, with the given class loader. + /// + ArrayObject* getParameterTypes(JnjvmClassLoader* loader); + + /// getExceptionTypes - Get the java.lang.Class of the exceptions of the + /// method, with the given class loader. + /// + ArrayObject* getExceptionTypes(JnjvmClassLoader* loader); + + /// getReturnType - Get the java.lang.Class of the result of the method, + /// with the given class loader. + /// + JavaObject* getReturnType(JnjvmClassLoader* loader); + //===----------------------------------------------------------------------===// // Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=61492&r1=61491&r2=61492&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Tue Dec 30 07:08:02 2008 @@ -299,50 +299,3 @@ // can not be here return; } - -JavaObject* NativeUtil::getClassType(JnjvmClassLoader* loader, Typedef* type) { - Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* res = type->assocClass(loader); - assert(res && "No associated class"); - return res->getClassDelegatee(vm); -} - -ArrayObject* NativeUtil::getParameterTypes(JnjvmClassLoader* loader, - JavaMethod* meth) { - Jnjvm* vm = JavaThread::get()->getJVM(); - Signdef* sign = meth->getSignature(); - Typedef* const* arguments = sign->getArgumentsType(); - ArrayObject* res = - (ArrayObject*)vm->upcalls->classArrayClass->doNew(sign->nbArguments, vm); - - for (uint32 index = 0; index < sign->nbArguments; ++index) { - res->elements[index] = getClassType(loader, arguments[index]); - } - - return res; - -} - -ArrayObject* NativeUtil::getExceptionTypes(UserClass* cl, JavaMethod* meth) { - Attribut* exceptionAtt = meth->lookupAttribut(Attribut::exceptionsAttribut); - Jnjvm* vm = JavaThread::get()->getJVM(); - if (exceptionAtt == 0) { - return (ArrayObject*)vm->upcalls->classArrayClass->doNew(0, vm); - } else { - UserConstantPool* ctp = cl->getConstantPool(); - Reader reader(exceptionAtt, cl->getBytes()); - uint16 nbe = reader.readU2(); - ArrayObject* res = - (ArrayObject*)vm->upcalls->classArrayClass->doNew(nbe, vm); - - for (uint16 i = 0; i < nbe; ++i) { - uint16 idx = reader.readU2(); - UserCommonClass* cl = ctp->loadClass(idx); - assert(cl->asClass() && "Wrong exception type"); - cl->asClass()->resolveClass(); - JavaObject* obj = cl->getClassDelegatee(vm); - res->elements[i] = obj; - } - return res; - } -} Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61492&r1=61491&r2=61492&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Tue Dec 30 07:08:02 2008 @@ -72,21 +72,6 @@ static void decapsulePrimitive(Jnjvm *vm, uintptr_t &buf, JavaObject* obj, const Typedef* signature); - /// getClassType - Return the java.lang.Class of the type, with the given - /// class loader. - /// - static JavaObject* getClassType(JnjvmClassLoader* loader, Typedef* type); - - /// getParameterTypes - Get the java.lang.Class of the parameters of - /// the method, with the given class loader. - /// - static ArrayObject* getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth); - - /// getExceptionTypes - Get the java.lang.Class of the exceptions of the - /// method, with the given class loader. - /// - static ArrayObject* getExceptionTypes(UserClass* cl, JavaMethod* meth); - }; } From nicolas.geoffray at lip6.fr Tue Dec 30 06:01:45 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 14:01:45 -0000 Subject: [vmkit-commits] [vmkit] r61494 - in /vmkit/trunk/lib/JnJVM: Classpath/ VMCore/ Message-ID: <200812301401.mBUE1nI5007219@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 08:01:37 2008 New Revision: 61494 URL: http://llvm.org/viewvc/llvm-project?rev=61494&view=rev Log: Code cleanup. Get rid of JavaBacktrace.cpp and NativeUtil.{h,cpp} files. Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp vmkit/trunk/lib/JnJVM/Classpath/Classpath.h.in vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Tue Dec 30 08:01:37 2008 @@ -14,7 +14,6 @@ #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; @@ -34,7 +33,8 @@ verifyNull(Cl); Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, true); if (cl->isClass() && cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName, @@ -225,7 +225,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, target, true); + UserClass* cl = + (UserClass*)UserCommonClass::resolvedImplClass(vm, (JavaObject*)target, true); JavaObject* obj = cl->doNew(vm); JavaField* field = vm->upcalls->constructorSlot; JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); @@ -249,7 +250,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* base = NativeUtil::resolvedImplClass(vm, arrayType, true); + UserCommonClass* base = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)arrayType, true); JnjvmClassLoader* loader = base->classLoader; const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.h.in URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.h.in?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.h.in (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.h.in Tue Dec 30 08:01:37 2008 @@ -8,7 +8,12 @@ //===----------------------------------------------------------------------===// -const char* GNUClasspathLibs = "@classpathlibs@"; -const char* GNUClasspathGlibj = "@classpathglibj@"; -const char* GNUClasspathVersion = "@classpathversion@"; +#define GNUClasspathLibs "@classpathlibs@"; +#define GNUClasspathGlibj "@classpathglibj@"; +#define GNUClasspathVersion "@classpathversion@"; +#ifdef NATIVE_JNI +#define JNIEXPORT +#else +#include +#endif Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Tue Dec 30 08:01:37 2008 @@ -8,19 +8,16 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" #include "JnjvmClassLoader.h" -#include "NativeUtil.h" using namespace jnjvm; @@ -32,8 +29,8 @@ static UserClass* internalGetClass(Jnjvm* vm, JavaMethod* meth, jobject Meth) { #ifdef ISOLATE_SHARING JavaField* field = vm->upcalls->constructorClass; - jclass Cl = (jclass)field->getInt32Field((JavaObject*)Meth); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, Cl, false); + JavaObject* Cl = (JavaObject*)field->getInt32Field((JavaObject*)Meth); + UserClass* cl = (UserClass*)UserCommonClass::resolvedImplClass(vm, Cl, false); return cl; #else return meth->classDef; @@ -107,7 +104,8 @@ void* startBuf = (void*)buf; if (nbArgs == size) { - UserCommonClass* _cl = NativeUtil::resolvedImplClass(vm, Clazz, false); + UserCommonClass* _cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Clazz, false); UserClass* cl = _cl->asClass(); if (cl) { cl->initialiseClass(vm); @@ -118,7 +116,7 @@ Typedef* const* arguments = sign->getArgumentsType(); // Store the arguments, unboxing primitives if necessary. for (sint32 i = 0; i < size; ++i) { - NativeUtil::decapsulePrimitive(vm, buf, ptr[i], arguments[i]); + ptr[i]->decapsulePrimitive(vm, buf, arguments[i]); } JavaObject* excp = 0; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp Tue Dec 30 08:01:37 2008 @@ -7,13 +7,12 @@ // //===----------------------------------------------------------------------===// - +#include "Classpath.h" #include "JavaClass.h" #include "JavaThread.h" #include "JavaTypes.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; @@ -23,8 +22,8 @@ static UserClass* internalGetClass(Jnjvm* vm, JavaField* field, jobject Field) { #ifdef ISOLATE_SHARING JavaField* slot = vm->upcalls->fieldClass; - jclass Cl = (jclass)slot->getInt32Field((JavaObject*)Field); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, Cl, false); + JavaObject* Cl = (JavaObject*)slot->getInt32Field((JavaObject*)Field); + UserClass* cl = (UserClass*)UserCommonClass::resolvedImplClass(vm, Cl, false); return cl; #else return field->classDef; @@ -531,7 +530,7 @@ uintptr_t buf = (uintptr_t)alloca(sizeof(uint64)); void* _buf = (void*)buf; const Typedef* type = field->getSignature(); - NativeUtil::decapsulePrimitive(vm, buf, (JavaObject*)val, type); + ((JavaObject*)val)->decapsulePrimitive(vm, buf, type); void* Obj = (void*)obj; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Tue Dec 30 08:01:37 2008 @@ -8,10 +8,9 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" @@ -20,7 +19,6 @@ #include "JavaUpcalls.h" #include "Jnjvm.h" #include "JnjvmClassLoader.h" -#include "NativeUtil.h" using namespace jnjvm; @@ -32,8 +30,8 @@ static UserClass* internalGetClass(Jnjvm* vm, JavaMethod* meth, jobject Meth) { #ifdef ISOLATE_SHARING JavaField* field = vm->upcalls->methodClass; - jclass Cl = (jclass)field->getInt32Field((JavaObject*)Meth); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, Cl, false); + JavaObject* Cl = (JavaObject*)field->getInt32Field((JavaObject*)Meth); + UserClass* cl = (UserClass*)UserCommonClass::resolvedImplClass(vm, Cl, false); return cl; #else return meth->classDef; @@ -129,7 +127,8 @@ uintptr_t buf = (uintptr_t)alloca(size * sizeof(uint64)); void* _buf = (void*)buf; if (nbArgs == size) { - UserCommonClass* _cl = NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass* _cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); UserClass* cl = (UserClass*)_cl; if (isVirtual(meth->access)) { @@ -152,7 +151,7 @@ JavaObject** ptr = (JavaObject**)(void*)(args->elements); Typedef* const* arguments = sign->getArgumentsType(); for (sint32 i = 0; i < size; ++i) { - NativeUtil::decapsulePrimitive(vm, buf, ptr[i], arguments[i]); + ptr[i]->decapsulePrimitive(vm, buf, arguments[i]); } JavaObject* exc = 0; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Tue Dec 30 08:01:37 2008 @@ -7,23 +7,19 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" +#include "Classpath.h" #include "ClasspathReflect.h" #include "JavaAccess.h" #include "JavaArray.h" #include "JavaClass.h" -#include "JavaConstantPool.h" #include "JavaObject.h" #include "JavaString.h" #include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" -#include "Reader.h" using namespace jnjvm; @@ -88,7 +84,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) { result = (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm); @@ -130,7 +127,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); Classpath* upcalls = vm->upcalls; if (cl->isArray() || cl->isPrimitive()) { @@ -175,7 +173,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); res = cl->getAccess(); END_NATIVE_EXCEPTION @@ -237,7 +236,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); res = cl->isInterface(); @@ -369,7 +369,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); + UserClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass(); if (!cl) { result = (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm); @@ -410,7 +411,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); ArrayObject* ret = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces, vm); for (uint16 i = 0; i < cl->nbInterfaces; ++i) { @@ -436,7 +438,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); + UserClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass(); if (cl) { cl->resolveInnerOuterClasses(); UserClass* outer = cl->getOuterClass(); @@ -464,7 +467,8 @@ BEGIN_NATIVE_EXCEPTION(0) Jnjvm* vm = JavaThread::get()->getJVM(); - UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); + UserClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false)->asClass(); if (cl) { cl->resolveInnerOuterClasses(); UserClassArray* array = vm->upcalls->constructorArrayClass; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Tue Dec 30 08:01:37 2008 @@ -7,19 +7,15 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" #include "JavaString.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "Jnjvm.h" -#include "LockedMap.h" -#include "NativeUtil.h" using namespace jnjvm; @@ -148,7 +144,7 @@ verifyNull(Cl); Jnjvm* vm = JavaThread::get()->getJVM(); - NativeUtil::resolvedImplClass(vm, Cl, false); + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, false); END_NATIVE_EXCEPTION } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Tue Dec 30 08:01:37 2008 @@ -7,17 +7,14 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Tue Dec 30 08:01:37 2008 @@ -12,16 +12,14 @@ #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" #include "JavaString.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "LockedMap.h" -#include "NativeUtil.h" #include Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Tue Dec 30 08:01:37 2008 @@ -8,22 +8,16 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" -#include "mvm/JIT.h" - +#include "Classpath.h" #include "ClasspathReflect.h" #include "JavaArray.h" #include "JavaClass.h" -#include "JavaJIT.h" #include "JavaObject.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp Tue Dec 30 08:01:37 2008 @@ -7,17 +7,14 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Tue Dec 30 08:01:37 2008 @@ -8,19 +8,17 @@ // //===----------------------------------------------------------------------===// -#include #include #include "types.h" +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaObject.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Tue Dec 30 08:01:37 2008 @@ -7,21 +7,15 @@ // //===----------------------------------------------------------------------===// -#include - #include "types.h" -#include "mvm/Threads/Thread.h" - +#include "Classpath.h" #include "JavaArray.h" #include "JavaClass.h" -#include "JavaJIT.h" #include "JavaObject.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Tue Dec 30 08:01:37 2008 @@ -7,25 +7,20 @@ // //===----------------------------------------------------------------------===// -#include #include #include "types.h" -#include "mvm/JIT.h" - +#include "Classpath.h" #include "JavaAccess.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaConstantPool.h" -#include "JavaJIT.h" #include "JavaObject.h" #include "JavaString.h" -#include "JavaTypes.h" #include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" #include "Reader.h" using namespace jnjvm; Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=61493&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (removed) @@ -1,146 +0,0 @@ -//===---------- JavaBacktrace.cpp - Backtrace utilities -------------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include -#include - -#include "mvm/JIT.h" -#include "mvm/Object.h" - -#include "JavaClass.h" -#include "JavaJIT.h" -#include "JavaThread.h" -#include "Jnjvm.h" -#include "JnjvmModule.h" -#include "JnjvmModuleProvider.h" - -using namespace jnjvm; - -#if 0 -JavaMethod* JavaJIT::IPToJavaMethod(void* begIp) { - const llvm::Function* F = mvm::MvmModule::getCodeFromPointer(begIp); - if (F) { - JavaMethod* meth = LLVMMethodInfo::get(F); - return meth; - } - return 0; -} - -void JavaJIT::printBacktrace() { - int* ips[100]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100); - int n = 0; - while (n < real_size) { - JavaMethod* meth = IPToJavaMethod(ips[n++]); - if (meth) { - fprintf(stderr, "; %p in %s\n", (void*)ips[n - 1], meth->printString()); - } else { - Dl_info info; - int res = dladdr(ips[n++], &info); - if (res != 0) { - fprintf(stderr, "; %p in %s\n", (void*)ips[n - 1], info.dli_sname); - } else { - fprintf(stderr, "; %p in Unknown\n", (void*)ips[n - 1]); - } - } - } -} - - - - -#ifndef ISOLATE_SHARING -UserClass* JavaJIT::getCallingClass() { - int* ips[10]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 10); - int n = 0; - int i = 0; - while (n < real_size) { - JavaMethod* meth = IPToJavaMethod(ips[n++]); - if (meth) { - if (i == 1) { - return meth->classDef; - } else { - ++i; - } - } - } - return 0; -} - -UserClass* JavaJIT::getCallingClassWalker() { - int* ips[10]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 10); - int n = 0; - int i = 0; - while (n < real_size) { - JavaMethod* meth = IPToJavaMethod(ips[n++]); - if (meth) { - if (i == 1) { - return meth->classDef; - } else { - ++i; - } - } - } - return 0; -} -#else - -UserClass* JavaJIT::getCallingClass() { - Class* res = 0; - - int* ips[10]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 10); - int n = 0; - int i = 0; - while (n < real_size) { - JavaMethod* meth = IPToJavaMethod(ips[n++]); - if (meth) { - if (i == 1) { - res = meth->classDef; - break; - } else { - ++i; - } - } - } - - if (!res) return 0; - - unsigned int* top; - register unsigned int **cur = ⊤ - register unsigned int **max = (unsigned int**)mvm::Thread::get()->baseSP; - - for(; curgetVirtualTable() == UserConstantPool::VT) { - UserConstantPool* ctp = (UserConstantPool*)obj; - UserClass* cl = ctp->getClass(); - if (cl->classDef == res) { - return cl; - } - } - } - return 0; -} - -UserClass* JavaJIT::getCallingClassWalker() { - return getCallingClass(); -} -#endif - -JavaObject* JavaJIT::getCallingClassLoader() { - UserClass* cl = getCallingClassWalker(); - if (!cl) return 0; - else return cl->classLoader->getJavaClassLoader(); -} - -#endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Tue Dec 30 08:01:37 2008 @@ -17,6 +17,7 @@ #include "debug.h" #include "types.h" +#include "ClasspathReflect.h" #include "JavaArray.h" #include "JavaCache.h" #include "JavaClass.h" @@ -1070,3 +1071,132 @@ } #endif + + + +UserCommonClass* UserCommonClass::resolvedImplClass(Jnjvm* vm, + JavaObject* clazz, + bool doClinit) { + UserCommonClass* cl = ((JavaObjectClass*)clazz)->getClass(); + if (cl->asClass()) { + cl->asClass()->resolveClass(); + if (doClinit) cl->asClass()->initialiseClass(vm); + } + return cl; +} + +void JavaMethod::jniConsFromMeth(char* buf) const { + const UTF8* jniConsClName = classDef->name; + const UTF8* jniConsName = name; + sint32 clen = jniConsClName->size; + sint32 mnlen = jniConsName->size; + + uint32 cur = 0; + char* ptr = &(buf[JNI_NAME_PRE_LEN]); + + memcpy(buf, JNI_NAME_PRE, JNI_NAME_PRE_LEN); + + for (sint32 i =0; i < clen; ++i) { + cur = jniConsClName->elements[i]; + if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } + else ptr[0] = (uint8)cur; + ++ptr; + } + + ptr[0] = '_'; + ++ptr; + + for (sint32 i =0; i < mnlen; ++i) { + cur = jniConsName->elements[i]; + if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } + else ptr[0] = (uint8)cur; + ++ptr; + } + + ptr[0] = 0; + + +} + +void JavaMethod::jniConsFromMethOverloaded(char* buf) const { + const UTF8* jniConsClName = classDef->name; + const UTF8* jniConsName = name; + const UTF8* jniConsType = type; + sint32 clen = jniConsClName->size; + sint32 mnlen = jniConsName->size; + + uint32 cur = 0; + char* ptr = &(buf[JNI_NAME_PRE_LEN]); + + memcpy(buf, JNI_NAME_PRE, JNI_NAME_PRE_LEN); + + for (sint32 i =0; i < clen; ++i) { + cur = jniConsClName->elements[i]; + if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } + else ptr[0] = (uint8)cur; + ++ptr; + } + + ptr[0] = '_'; + ++ptr; + + for (sint32 i =0; i < mnlen; ++i) { + cur = jniConsName->elements[i]; + if (cur == '/') ptr[0] = '_'; + else if (cur == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ++ptr; + } + else ptr[0] = (uint8)cur; + ++ptr; + } + + sint32 i = 0; + while (i < jniConsType->size) { + char c = jniConsType->elements[i++]; + if (c == I_PARG) { + ptr[0] = '_'; + ptr[1] = '_'; + ptr += 2; + } else if (c == '/') { + ptr[0] = '_'; + ++ptr; + } else if (c == '_') { + ptr[0] = '_'; + ptr[1] = '1'; + ptr += 2; + } else if (c == I_END_REF) { + ptr[0] = '_'; + ptr[1] = '2'; + ptr += 2; + } else if (c == I_TAB) { + ptr[0] = '_'; + ptr[1] = '3'; + ptr += 2; + } else if (c == I_PARD) { + break; + } else { + ptr[0] = c; + ++ptr; + } + } + + ptr[0] = 0; + +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Dec 30 08:01:37 2008 @@ -354,7 +354,12 @@ JavaObject* getDelegatee(); #endif #endif - + + /// resolvedImplClass - Return the internal representation of the + /// java.lang.Class object. The class must be resolved. + // + static UserCommonClass* resolvedImplClass(Jnjvm* vm, JavaObject* delegatee, + bool doClinit); }; /// ClassPrimitive - This class represents internal classes for primitive Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 08:01:37 2008 @@ -38,7 +38,6 @@ #include "JavaUpcalls.h" #include "Jnjvm.h" #include "JnjvmModuleProvider.h" -#include "NativeUtil.h" #include "Reader.h" #include "Zip.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Tue Dec 30 08:01:37 2008 @@ -15,6 +15,7 @@ #include "JavaClass.h" #include "JavaObject.h" #include "JavaThread.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" using namespace jnjvm; @@ -152,3 +153,146 @@ JavaThread::get()->getJVM()->illegalMonitorStateException(this); } } + +void JavaObject::decapsulePrimitive(Jnjvm *vm, uintptr_t &buf, + const Typedef* signature) { + + JavaObject* obj = this; + if (!signature->isPrimitive()) { + if (obj && !(obj->classOf->isOfTypeName(vm, signature->getName()))) { + vm->illegalArgumentException("wrong type argument"); + } + ((JavaObject**)buf)[0] = obj; + buf += 8; + return; + } else if (obj == 0) { + vm->illegalArgumentException(""); + } else { + UserCommonClass* cl = obj->classOf; + UserClassPrimitive* value = cl->toPrimitive(vm); + PrimitiveTypedef* prim = (PrimitiveTypedef*)signature; + + if (value == 0) { + vm->illegalArgumentException(""); + } + + if (prim->isShort()) { + if (value == vm->upcalls->OfShort) { + ((uint16*)buf)[0] = vm->upcalls->shortValue->getInt16Field(obj); + buf += 8; + return; + } else if (value == vm->upcalls->OfByte) { + ((sint16*)buf)[0] = + (sint16)vm->upcalls->byteValue->getInt8Field(obj); + buf += 8; + return; + } else { + vm->illegalArgumentException(""); + } + } else if (prim->isByte()) { + if (value == vm->upcalls->OfByte) { + ((uint8*)buf)[0] = vm->upcalls->byteValue->getInt8Field(obj); + buf += 8; + return; + } else { + vm->illegalArgumentException(""); + } + } else if (prim->isBool()) { + if (value == vm->upcalls->OfBool) { + ((uint8*)buf)[0] = vm->upcalls->boolValue->getInt8Field(obj); + buf += 8; + return; + } else { + vm->illegalArgumentException(""); + } + } else if (prim->isInt()) { + sint32 val = 0; + if (value == vm->upcalls->OfInt) { + val = vm->upcalls->intValue->getInt32Field(obj); + } else if (value == vm->upcalls->OfByte) { + val = (sint32)vm->upcalls->byteValue->getInt8Field(obj); + } else if (value == vm->upcalls->OfChar) { + val = (uint32)vm->upcalls->charValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfShort) { + val = (sint32)vm->upcalls->shortValue->getInt16Field(obj); + } else { + vm->illegalArgumentException(""); + } + ((sint32*)buf)[0] = val; + buf += 8; + return; + } else if (prim->isChar()) { + uint16 val = 0; + if (value == vm->upcalls->OfChar) { + val = (uint16)vm->upcalls->charValue->getInt16Field(obj); + } else { + vm->illegalArgumentException(""); + } + ((uint16*)buf)[0] = val; + buf += 8; + return; + } else if (prim->isFloat()) { + float val = 0; + if (value == vm->upcalls->OfFloat) { + val = (float)vm->upcalls->floatValue->getFloatField(obj); + } else if (value == vm->upcalls->OfByte) { + val = (float)(sint32)vm->upcalls->byteValue->getInt8Field(obj); + } else if (value == vm->upcalls->OfChar) { + val = (float)(uint32)vm->upcalls->charValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfShort) { + val = (float)(sint32)vm->upcalls->shortValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfInt) { + val = (float)(sint32)vm->upcalls->intValue->getInt32Field(obj); + } else if (value == vm->upcalls->OfLong) { + val = (float)vm->upcalls->longValue->getLongField(obj); + } else { + vm->illegalArgumentException(""); + } + ((float*)buf)[0] = val; + buf += 8; + return; + } else if (prim->isDouble()) { + double val = 0; + if (value == vm->upcalls->OfDouble) { + val = (double)vm->upcalls->doubleValue->getDoubleField(obj); + } else if (value == vm->upcalls->OfFloat) { + val = (double)vm->upcalls->floatValue->getFloatField(obj); + } else if (value == vm->upcalls->OfByte) { + val = (double)(sint64)vm->upcalls->byteValue->getInt8Field(obj); + } else if (value == vm->upcalls->OfChar) { + val = (double)(uint64)vm->upcalls->charValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfShort) { + val = (double)(sint16)vm->upcalls->shortValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfInt) { + val = (double)(sint32)vm->upcalls->intValue->getInt32Field(obj); + } else if (value == vm->upcalls->OfLong) { + val = (double)(sint64)vm->upcalls->longValue->getLongField(obj); + } else { + vm->illegalArgumentException(""); + } + ((double*)buf)[0] = val; + buf += 8; + return; + } else if (prim->isLong()) { + sint64 val = 0; + if (value == vm->upcalls->OfByte) { + val = (sint64)vm->upcalls->byteValue->getInt8Field(obj); + } else if (value == vm->upcalls->OfChar) { + val = (sint64)(uint64)vm->upcalls->charValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfShort) { + val = (sint64)vm->upcalls->shortValue->getInt16Field(obj); + } else if (value == vm->upcalls->OfInt) { + val = (sint64)vm->upcalls->intValue->getInt32Field(obj); + } else if (value == vm->upcalls->OfLong) { + val = (sint64)vm->upcalls->intValue->getLongField(obj); + } else { + vm->illegalArgumentException(""); + } + ((sint64*)buf)[0] = val; + buf += 8; + return; + } + } + // can not be here + return; +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Tue Dec 30 08:01:37 2008 @@ -204,6 +204,12 @@ LockObj* lockObj() { return lock.getFatLock(); } + + /// decapsulePrimitive - Based on the signature argument, decapsule + /// obj as a primitive and put it in the buffer. + /// + void decapsulePrimitive(Jnjvm* vm, uintptr_t &buf, const Typedef* signature); + }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Dec 30 08:01:37 2008 @@ -23,7 +23,6 @@ #include "JavaTypes.h" #include "Jnjvm.h" #include "LockedMap.h" -#include "NativeUtil.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 08:01:37 2008 @@ -25,6 +25,36 @@ class JavaObject; class Jnjvm; + +#define BEGIN_NATIVE_EXCEPTION(level) \ + JavaThread* __th = JavaThread::get(); \ + __th->startNative(level); \ + bool __exc = false; \ + try { + +#define END_NATIVE_EXCEPTION \ + } catch(...) { \ + __exc = true; \ + } \ + if (__exc) { \ + __th->throwFromNative(); \ + } \ + __th->endNative(); + +#define BEGIN_JNI_EXCEPTION \ + JavaThread* th = JavaThread::get(); \ + bool __exc = 0; \ + try { + +#define END_JNI_EXCEPTION \ + } catch(...) { \ + __exc = true; \ + } \ + if (__exc) { \ + th->throwFromJNI(); \ + } + + /// JavaThread - This class is the internal representation of a Java thread. /// It maintains thread-specific information such as its state, the current /// exception if there is one, the layout of the stack, etc. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 08:01:37 2008 @@ -18,11 +18,14 @@ #include "JavaTypes.h" #include "JavaUpcalls.h" #include "Jnjvm.h" -#include "NativeUtil.h" using namespace jnjvm; - + +static Jnjvm* myVM(JNIEnv* env) { + return JavaThread::get()->getJVM(); +} + static UserClass* getClassFromStaticMethod(Jnjvm* vm, JavaMethod* meth, jclass clazz) { #ifdef ISOLATE_SHARING @@ -83,7 +86,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); Classpath* upcalls = vm->upcalls; JavaObject* meth = (JavaObject*)method; UserCommonClass* cl = meth->classOf; @@ -113,8 +116,10 @@ BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl2 = NativeUtil::resolvedImplClass(vm, sup, false); - UserCommonClass* cl1 = NativeUtil::resolvedImplClass(vm, sub, false); + UserCommonClass* cl2 = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)sup, false); + UserCommonClass* cl1 = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)sub, false); return cl1->isAssignableFrom(cl2); @@ -134,9 +139,10 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); verifyNull(Cl); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)Cl, true); if (!cl->asClass()) assert(0 && "implement me"); UserClass* realCl = cl->asClass(); JavaObject* res = realCl->doNew(vm); @@ -211,7 +217,8 @@ BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); if (cl->isArray()) JavaThread::get()->getJVM()->unknownError("implement me"); return (jobject)((UserClass*)cl)->doNew(JavaThread::get()->getJVM()); @@ -227,7 +234,8 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->getJVM(); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); JavaObject* res = cl->doNew(vm); meth->invokeIntSpecialAP(vm, cl, res, ap); va_end(ap); @@ -251,7 +259,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaMethod* meth = (JavaMethod*)methodID; - Class* cl = (Class*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); JavaObject* res = cl->doNew(vm); meth->invokeIntSpecialBuf(vm, cl, res, (void*)args); return (jobject)res; @@ -306,7 +315,7 @@ BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); const UTF8* name = vm->asciizToInternalUTF8(aname); const UTF8* type = vm->asciizToInternalUTF8(atype); JavaMethod* meth = cl->asClass() ? @@ -930,7 +939,8 @@ BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); return (jfieldID) (cl->asClass() ? cl->asClass()->lookupField(vm->asciizToUTF8(name), vm->asciizToUTF8(sig), 0, 1, @@ -1174,7 +1184,8 @@ BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); const UTF8* name = vm->asciizToInternalUTF8(aname); const UTF8* type = vm->asciizToInternalUTF8(atype); JavaMethod* meth = cl->asClass() ? @@ -1595,7 +1606,8 @@ BEGIN_JNI_EXCEPTION Jnjvm* vm = JavaThread::get()->getJVM(); - UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); + UserCommonClass* cl = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); return (jfieldID) (cl->asClass() ? cl->asClass()->lookupField(vm->asciizToUTF8(name), vm->asciizToUTF8(sig), @@ -1612,7 +1624,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jobject)field->getObjectField(Stat); @@ -1627,7 +1640,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jboolean)field->getInt8Field(Stat); @@ -1642,7 +1656,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jbyte)field->getInt8Field(Stat); @@ -1657,7 +1672,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jchar)field->getInt16Field(Stat); @@ -1672,7 +1688,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jshort)field->getInt16Field(Stat); @@ -1687,7 +1704,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jint)field->getInt32Field(Stat); @@ -1702,7 +1720,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jlong)field->getLongField(Stat); @@ -1717,7 +1736,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jfloat)field->getFloatField(Stat); @@ -1732,7 +1752,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); return (jdouble)field->getDoubleField(Stat); @@ -1748,7 +1769,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setObjectField(Stat, (JavaObject*)value); @@ -1763,7 +1785,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setInt8Field(Stat, (uint8)value); @@ -1778,7 +1801,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setInt8Field(Stat, (sint8)value); @@ -1793,7 +1817,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setInt16Field(Stat, (uint16)value); @@ -1808,7 +1833,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setInt16Field(Stat, (sint16)value); @@ -1823,7 +1849,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setInt32Field(Stat, (sint32)value); @@ -1838,7 +1865,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setLongField(Stat, (sint64)value); @@ -1853,7 +1881,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setFloatField(Stat, (float)value); @@ -1868,7 +1897,8 @@ Jnjvm* vm = JavaThread::get()->getJVM(); JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); + UserClass* cl = (UserClass*) + UserCommonClass::resolvedImplClass(vm, (JavaObject*)clazz, true); void* Stat = cl->getStaticInstance(); field->setDoubleField(Stat, (double)value); @@ -1903,7 +1933,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jstring)(vm->asciizToStr(bytes)); END_JNI_EXCEPTION @@ -1948,10 +1978,11 @@ jobjectArray NewObjectArray(JNIEnv *env, jsize length, jclass elementClass, jobject initialElement) { BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); if (length < 0) vm->negativeArraySizeException(length); - UserCommonClass* base = NativeUtil::resolvedImplClass(vm, elementClass, true); + UserCommonClass* base = + UserCommonClass::resolvedImplClass(vm, (JavaObject*)elementClass, true); JnjvmClassLoader* loader = base->classLoader; const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); @@ -2000,7 +2031,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jbooleanArray)vm->upcalls->ArrayOfByte->doNew(len, vm); END_JNI_EXCEPTION @@ -2012,7 +2043,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jbyteArray)vm->upcalls->ArrayOfByte->doNew(len, vm); END_JNI_EXCEPTION @@ -2024,7 +2055,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jcharArray)vm->upcalls->ArrayOfChar->doNew(len, vm); END_JNI_EXCEPTION @@ -2036,7 +2067,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jshortArray)vm->upcalls->ArrayOfShort->doNew(len, vm); END_JNI_EXCEPTION @@ -2048,7 +2079,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jintArray)vm->upcalls->ArrayOfInt->doNew(len, vm); END_JNI_EXCEPTION @@ -2060,7 +2091,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jlongArray)vm->upcalls->ArrayOfLong->doNew(len, vm); END_JNI_EXCEPTION @@ -2072,7 +2103,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jfloatArray)vm->upcalls->ArrayOfFloat->doNew(len, vm); END_JNI_EXCEPTION @@ -2084,7 +2115,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); return (jdoubleArray)vm->upcalls->ArrayOfDouble->doNew(len, vm); END_JNI_EXCEPTION @@ -2441,7 +2472,7 @@ jobject NewGlobalRef(JNIEnv* env, jobject obj) { - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); vm->globalRefsLock.lock(); vm->globalRefs.push_back((JavaObject*)obj); vm->globalRefsLock.unlock(); @@ -2450,7 +2481,7 @@ void DeleteGlobalRef(JNIEnv* env, jobject globalRef) { - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); vm->globalRefsLock.lock(); for (std::vector >::iterator i = vm->globalRefs.begin(), @@ -2480,7 +2511,7 @@ BEGIN_JNI_EXCEPTION - Jnjvm* vm = NativeUtil::myVM(env); + Jnjvm* vm = myVM(env); JavaObject* buf = (JavaObject*)_buf; JavaObject* address = vm->upcalls->bufferAddress->getObjectField(buf); if (address != 0) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=61494&r1=61493&r2=61494&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Tue Dec 30 08:01:37 2008 @@ -31,6 +31,7 @@ #include "mvm/Allocator.h" +#include "Classpath.h" #include "ClasspathReflect.h" #include "JavaClass.h" #include "JavaConstantPool.h" @@ -45,9 +46,6 @@ using namespace jnjvm; -extern const char* GNUClasspathGlibj; -extern const char* GNUClasspathLibs; - JnjvmBootstrapLoader::JnjvmBootstrapLoader(bool staticCompilation) { TheModule = new JnjvmModule("Bootstrap JnJVM", staticCompilation); Removed: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=61493&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (removed) @@ -1,301 +0,0 @@ -//===------ NativeUtil.cpp - Methods to call native functions -------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - - -#include "ClasspathReflect.h" -#include "JavaArray.h" -#include "JavaClass.h" -#include "JavaConstantPool.h" -#include "JavaJIT.h" -#include "JavaThread.h" -#include "JavaTypes.h" -#include "JavaUpcalls.h" -#include "Jnjvm.h" -#include "JnjvmClassLoader.h" -#include "NativeUtil.h" -#include "Reader.h" - -#include -#include - -using namespace jnjvm; - -Jnjvm* NativeUtil::myVM(JNIEnv* env) { - return JavaThread::get()->getJVM(); -} - -void JavaMethod::jniConsFromMeth(char* buf) const { - const UTF8* jniConsClName = classDef->name; - const UTF8* jniConsName = name; - sint32 clen = jniConsClName->size; - sint32 mnlen = jniConsName->size; - - uint32 cur = 0; - char* ptr = &(buf[JNI_NAME_PRE_LEN]); - - memcpy(buf, JNI_NAME_PRE, JNI_NAME_PRE_LEN); - - for (sint32 i =0; i < clen; ++i) { - cur = jniConsClName->elements[i]; - if (cur == '/') ptr[0] = '_'; - else if (cur == '_') { - ptr[0] = '_'; - ptr[1] = '1'; - ++ptr; - } - else ptr[0] = (uint8)cur; - ++ptr; - } - - ptr[0] = '_'; - ++ptr; - - for (sint32 i =0; i < mnlen; ++i) { - cur = jniConsName->elements[i]; - if (cur == '/') ptr[0] = '_'; - else if (cur == '_') { - ptr[0] = '_'; - ptr[1] = '1'; - ++ptr; - } - else ptr[0] = (uint8)cur; - ++ptr; - } - - ptr[0] = 0; - - -} - -void JavaMethod::jniConsFromMethOverloaded(char* buf) const { - const UTF8* jniConsClName = classDef->name; - const UTF8* jniConsName = name; - const UTF8* jniConsType = type; - sint32 clen = jniConsClName->size; - sint32 mnlen = jniConsName->size; - - uint32 cur = 0; - char* ptr = &(buf[JNI_NAME_PRE_LEN]); - - memcpy(buf, JNI_NAME_PRE, JNI_NAME_PRE_LEN); - - for (sint32 i =0; i < clen; ++i) { - cur = jniConsClName->elements[i]; - if (cur == '/') ptr[0] = '_'; - else if (cur == '_') { - ptr[0] = '_'; - ptr[1] = '1'; - ++ptr; - } - else ptr[0] = (uint8)cur; - ++ptr; - } - - ptr[0] = '_'; - ++ptr; - - for (sint32 i =0; i < mnlen; ++i) { - cur = jniConsName->elements[i]; - if (cur == '/') ptr[0] = '_'; - else if (cur == '_') { - ptr[0] = '_'; - ptr[1] = '1'; - ++ptr; - } - else ptr[0] = (uint8)cur; - ++ptr; - } - - sint32 i = 0; - while (i < jniConsType->size) { - char c = jniConsType->elements[i++]; - if (c == I_PARG) { - ptr[0] = '_'; - ptr[1] = '_'; - ptr += 2; - } else if (c == '/') { - ptr[0] = '_'; - ++ptr; - } else if (c == '_') { - ptr[0] = '_'; - ptr[1] = '1'; - ptr += 2; - } else if (c == I_END_REF) { - ptr[0] = '_'; - ptr[1] = '2'; - ptr += 2; - } else if (c == I_TAB) { - ptr[0] = '_'; - ptr[1] = '3'; - ptr += 2; - } else if (c == I_PARD) { - break; - } else { - ptr[0] = c; - ++ptr; - } - } - - ptr[0] = 0; - - -} - -UserCommonClass* NativeUtil::resolvedImplClass(Jnjvm* vm, jclass clazz, - bool doClinit) { - UserCommonClass* cl = ((JavaObjectClass*)clazz)->getClass(); - if (cl->asClass()) { - cl->asClass()->resolveClass(); - if (doClinit) cl->asClass()->initialiseClass(vm); - } - return cl; -} - -void NativeUtil::decapsulePrimitive(Jnjvm *vm, uintptr_t &buf, - JavaObject* obj, - const Typedef* signature) { - - if (!signature->isPrimitive()) { - if (obj && !(obj->classOf->isOfTypeName(vm, signature->getName()))) { - vm->illegalArgumentException("wrong type argument"); - } - ((JavaObject**)buf)[0] = obj; - buf += 8; - return; - } else if (obj == 0) { - vm->illegalArgumentException(""); - } else { - UserCommonClass* cl = obj->classOf; - UserClassPrimitive* value = cl->toPrimitive(vm); - PrimitiveTypedef* prim = (PrimitiveTypedef*)signature; - - if (value == 0) { - vm->illegalArgumentException(""); - } - - if (prim->isShort()) { - if (value == vm->upcalls->OfShort) { - ((uint16*)buf)[0] = vm->upcalls->shortValue->getInt16Field(obj); - buf += 8; - return; - } else if (value == vm->upcalls->OfByte) { - ((sint16*)buf)[0] = - (sint16)vm->upcalls->byteValue->getInt8Field(obj); - buf += 8; - return; - } else { - vm->illegalArgumentException(""); - } - } else if (prim->isByte()) { - if (value == vm->upcalls->OfByte) { - ((uint8*)buf)[0] = vm->upcalls->byteValue->getInt8Field(obj); - buf += 8; - return; - } else { - vm->illegalArgumentException(""); - } - } else if (prim->isBool()) { - if (value == vm->upcalls->OfBool) { - ((uint8*)buf)[0] = vm->upcalls->boolValue->getInt8Field(obj); - buf += 8; - return; - } else { - vm->illegalArgumentException(""); - } - } else if (prim->isInt()) { - sint32 val = 0; - if (value == vm->upcalls->OfInt) { - val = vm->upcalls->intValue->getInt32Field(obj); - } else if (value == vm->upcalls->OfByte) { - val = (sint32)vm->upcalls->byteValue->getInt8Field(obj); - } else if (value == vm->upcalls->OfChar) { - val = (uint32)vm->upcalls->charValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfShort) { - val = (sint32)vm->upcalls->shortValue->getInt16Field(obj); - } else { - vm->illegalArgumentException(""); - } - ((sint32*)buf)[0] = val; - buf += 8; - return; - } else if (prim->isChar()) { - uint16 val = 0; - if (value == vm->upcalls->OfChar) { - val = (uint16)vm->upcalls->charValue->getInt16Field(obj); - } else { - vm->illegalArgumentException(""); - } - ((uint16*)buf)[0] = val; - buf += 8; - return; - } else if (prim->isFloat()) { - float val = 0; - if (value == vm->upcalls->OfFloat) { - val = (float)vm->upcalls->floatValue->getFloatField(obj); - } else if (value == vm->upcalls->OfByte) { - val = (float)(sint32)vm->upcalls->byteValue->getInt8Field(obj); - } else if (value == vm->upcalls->OfChar) { - val = (float)(uint32)vm->upcalls->charValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfShort) { - val = (float)(sint32)vm->upcalls->shortValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfInt) { - val = (float)(sint32)vm->upcalls->intValue->getInt32Field(obj); - } else if (value == vm->upcalls->OfLong) { - val = (float)vm->upcalls->longValue->getLongField(obj); - } else { - vm->illegalArgumentException(""); - } - ((float*)buf)[0] = val; - buf += 8; - return; - } else if (prim->isDouble()) { - double val = 0; - if (value == vm->upcalls->OfDouble) { - val = (double)vm->upcalls->doubleValue->getDoubleField(obj); - } else if (value == vm->upcalls->OfFloat) { - val = (double)vm->upcalls->floatValue->getFloatField(obj); - } else if (value == vm->upcalls->OfByte) { - val = (double)(sint64)vm->upcalls->byteValue->getInt8Field(obj); - } else if (value == vm->upcalls->OfChar) { - val = (double)(uint64)vm->upcalls->charValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfShort) { - val = (double)(sint16)vm->upcalls->shortValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfInt) { - val = (double)(sint32)vm->upcalls->intValue->getInt32Field(obj); - } else if (value == vm->upcalls->OfLong) { - val = (double)(sint64)vm->upcalls->longValue->getLongField(obj); - } else { - vm->illegalArgumentException(""); - } - ((double*)buf)[0] = val; - buf += 8; - return; - } else if (prim->isLong()) { - sint64 val = 0; - if (value == vm->upcalls->OfByte) { - val = (sint64)vm->upcalls->byteValue->getInt8Field(obj); - } else if (value == vm->upcalls->OfChar) { - val = (sint64)(uint64)vm->upcalls->charValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfShort) { - val = (sint64)vm->upcalls->shortValue->getInt16Field(obj); - } else if (value == vm->upcalls->OfInt) { - val = (sint64)vm->upcalls->intValue->getInt32Field(obj); - } else if (value == vm->upcalls->OfLong) { - val = (sint64)vm->upcalls->intValue->getLongField(obj); - } else { - vm->illegalArgumentException(""); - } - ((sint64*)buf)[0] = val; - buf += 8; - return; - } - } - // can not be here - return; -} Removed: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=61493&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (removed) @@ -1,79 +0,0 @@ -//===------- NativeUtil.h - Methods to call native functions --------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef JNJVM_NATIVE_UTIL_H -#define JNJVM_NATIVE_UTIL_H - -#include - -namespace jnjvm { - -class ArrayObject; -class JavaMethod; -class JavaObject; -class Jnjvm; -class JnjvmClassLoader; -class Typedef; - - -#define BEGIN_NATIVE_EXCEPTION(level) \ - JavaThread* __th = JavaThread::get(); \ - __th->startNative(level); \ - bool __exc = false; \ - try { - -#define END_NATIVE_EXCEPTION \ - } catch(...) { \ - __exc = true; \ - } \ - if (__exc) { \ - __th->throwFromNative(); \ - } \ - __th->endNative(); - -#define BEGIN_JNI_EXCEPTION \ - JavaThread* th = JavaThread::get(); \ - bool __exc = 0; \ - try { - -#define END_JNI_EXCEPTION \ - } catch(...) { \ - __exc = true; \ - } \ - if (__exc) { \ - th->throwFromJNI(); \ - } - -/// NativeUtil - This class groups a set of static function useful when dealing -/// with Java objects in native code. -/// -class NativeUtil { -public: - - /// myVM - Get the current virtual machine. - /// - static Jnjvm* myVM(JNIEnv* env); - - /// resolvedImplClass - Return the internal representation of the - /// java.lang.Class object. The class must be resolved. - // - static UserCommonClass* resolvedImplClass(Jnjvm* vm, jclass clazz, - bool doClinit); - - /// decapsulePrimitive - Based on the signature argument, decapsule - /// obj as a primitive and put it in the buffer. - /// - static void decapsulePrimitive(Jnjvm *vm, uintptr_t &buf, JavaObject* obj, - const Typedef* signature); - -}; - -} - -#endif From nicolas.geoffray at lip6.fr Tue Dec 30 06:23:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 14:23:29 -0000 Subject: [vmkit-commits] [vmkit] r61495 - in /vmkit/trunk: include/mvm/Threads/Thread.h lib/JnJVM/Classpath/ClasspathConstructor.cpp lib/JnJVM/Classpath/ClasspathMethod.cpp lib/JnJVM/Classpath/ClasspathVMClass.cpp lib/JnJVM/Classpath/ClasspathVMThread.cpp lib/JnJVM/VMCore/JavaRuntimeJIT.cpp lib/JnJVM/VMCore/JavaThread.h lib/JnJVM/VMCore/Jni.cpp lib/JnJVM/VMCore/Jnjvm.cpp lib/Mvm/GCMmap2/gccollector.cpp lib/N3/VMCore/CLIRuntimeJIT.cpp Message-ID: <200812301423.mBUENW4c007852@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 08:23:26 2008 New Revision: 61495 URL: http://llvm.org/viewvc/llvm-project?rev=61495&view=rev Log: Code cleanup: make static functions in JavaThread and mvm::Thread instance functions. Modified: vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 30 08:23:26 2008 @@ -168,9 +168,8 @@ /// clearException - Clear any pending exception of the current thread. - static void clearException() { - Thread* th = Thread::get(); - th->internalClearException(); + void clearException() { + internalClearException(); } /// IDMask - Apply this mask to the stack pointer to get the Thread object. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Tue Dec 30 08:23:26 2008 @@ -120,11 +120,12 @@ } JavaObject* excp = 0; + JavaThread* th = JavaThread::get(); try { meth->invokeIntSpecialBuf(vm, cl, obj, startBuf); }catch(...) { - excp = JavaThread::getJavaException(); - JavaThread::clearException(); + excp = th->getJavaException(); + th->clearException(); } if (excp) { if (excp->classOf->isAssignableFrom(vm->upcalls->newException)) { @@ -133,7 +134,7 @@ vm->invocationTargetException(excp); } else { // If it's an error, throw it again. - JavaThread::throwException(excp); + th->throwException(excp); } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Tue Dec 30 08:23:26 2008 @@ -155,6 +155,7 @@ } JavaObject* exc = 0; + JavaThread* th = JavaThread::get(); #define RUN_METH(TYPE) \ try{ \ @@ -169,16 +170,16 @@ val = meth->invoke##TYPE##StaticBuf(vm, cl, _buf); \ } \ }catch(...) { \ - exc = JavaThread::getJavaException(); \ + exc = th->getJavaException(); \ assert(exc && "no exception?"); \ - JavaThread::clearException(); \ + th->clearException(); \ } \ \ if (exc) { \ if (exc->classOf->isAssignableFrom(vm->upcalls->newException)) { \ - JavaThread::get()->getJVM()->invocationTargetException(exc); \ + th->getJVM()->invocationTargetException(exc); \ } else { \ - JavaThread::throwException(exc); \ + th->throwException(exc); \ } \ } \ Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Tue Dec 30 08:23:26 2008 @@ -494,7 +494,7 @@ jclass clazz, #endif jobject throwable) { - JavaThread::throwException((JavaObject*)throwable); + JavaThread::get()->throwException((JavaObject*)throwable); } JNIEXPORT jobjectArray Java_java_lang_VMClass_getDeclaredAnnotations( Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Tue Dec 30 08:23:26 2008 @@ -29,7 +29,7 @@ jclass clazz #endif ) { - return (jobject)(JavaThread::currentThread()); + return (jobject)(JavaThread::get()->currentThread()); } static void start(JavaThread* thread) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Dec 30 08:23:26 2008 @@ -394,27 +394,27 @@ // Never throws. extern "C" void* JavaThreadGetException() { - return JavaThread::getException(); + return JavaThread::get()->getException(); } // Never throws. extern "C" JavaObject* JavaThreadGetJavaException() { - return JavaThread::getJavaException(); + return JavaThread::get()->getJavaException(); } // Does not call any Java code. extern "C" void JavaThreadThrowException(JavaObject* obj) { - return JavaThread::throwException(obj); + return JavaThread::get()->throwException(obj); } // Never throws. extern "C" bool JavaThreadCompareException(UserClass* cl) { - return JavaThread::compareException(cl); + return JavaThread::get()->compareException(cl); } // Never throws. extern "C" void JavaThreadClearException() { - return JavaThread::clearException(); + return JavaThread::get()->clearException(); } // Never throws. @@ -426,66 +426,71 @@ extern "C" void jnjvmNullPointerException() { JavaObject *exc = 0; + JavaThread *th = JavaThread::get(); BEGIN_NATIVE_EXCEPTION(1) - exc = JavaThread::get()->getJVM()->CreateNullPointerException(); + exc = th->getJVM()->CreateNullPointerException(); END_NATIVE_EXCEPTION - JavaThread::throwException(exc); + th->throwException(exc); } // Creates a Java object and then throws it. extern "C" void negativeArraySizeException(sint32 val) { JavaObject *exc = 0; + JavaThread *th = JavaThread::get(); BEGIN_NATIVE_EXCEPTION(1) - exc = JavaThread::get()->getJVM()->CreateNegativeArraySizeException(); + exc = th->getJVM()->CreateNegativeArraySizeException(); END_NATIVE_EXCEPTION - JavaThread::throwException(exc); + th->throwException(exc); } // Creates a Java object and then throws it. extern "C" void outOfMemoryError(sint32 val) { JavaObject *exc = 0; + JavaThread *th = JavaThread::get(); BEGIN_NATIVE_EXCEPTION(1) - exc = JavaThread::get()->getJVM()->CreateOutOfMemoryError(); + exc = th->getJVM()->CreateOutOfMemoryError(); END_NATIVE_EXCEPTION - JavaThread::throwException(exc); + th->throwException(exc); } // Creates a Java object and then throws it. extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) { JavaObject *exc = 0; + JavaThread *th = JavaThread::get(); BEGIN_NATIVE_EXCEPTION(1) - exc = JavaThread::get()->getJVM()->CreateClassCastException(obj, cl); + exc = th->getJVM()->CreateClassCastException(obj, cl); END_NATIVE_EXCEPTION - JavaThread::throwException(exc); + th->throwException(exc); } // Creates a Java object and then throws it. extern "C" void indexOutOfBoundsException(JavaObject* obj, sint32 index) { JavaObject *exc = 0; + JavaThread *th = JavaThread::get(); BEGIN_NATIVE_EXCEPTION(1) - exc = JavaThread::get()->getJVM()->CreateIndexOutOfBoundsException(index); + exc = th->getJVM()->CreateIndexOutOfBoundsException(index); END_NATIVE_EXCEPTION - JavaThread::throwException(exc); + th->throwException(exc); } extern "C" void printMethodStart(JavaMethod* meth) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 08:23:26 2008 @@ -150,7 +150,7 @@ /// currentThread - Return the current thread as a Java object. /// - static JavaObject* currentThread() { + JavaObject* currentThread() { JavaThread* result = get(); if (result != 0) return result->javaThread; @@ -160,7 +160,7 @@ /// getException - Return the C++ specific exception object. /// - static void* getException() { + void* getException() { // 32 = sizeof(_Unwind_Exception) in libgcc... return (void*) ((uintptr_t)JavaThread::get()->internalPendingException - 32); @@ -168,17 +168,17 @@ /// throwException - Throw the given exception in the current thread. /// - static void throwException(JavaObject* obj); + void throwException(JavaObject* obj); /// throwPendingException - Throw a pending exception created by JNI. /// - static void throwPendingException(); + void throwPendingException(); /// compareException - Compare the pending exception's class with the /// given class. /// - static bool compareException(UserClass* cl) { - JavaObject* pe = JavaThread::get()->pendingException; + bool compareException(UserClass* cl) { + JavaObject* pe = pendingException; assert(pe && "no pending exception?"); bool val = pe->classOf->subclassOf(cl); return val; @@ -186,8 +186,8 @@ /// getJavaException - Return the pending exception. /// - static JavaObject* getJavaException() { - return JavaThread::get()->pendingException; + JavaObject* getJavaException() { + return pendingException; } /// throwFromJNI - Throw an exception after executing JNI code. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 08:23:26 2008 @@ -2560,8 +2560,9 @@ BEGIN_JNI_EXCEPTION - JavaObject* th = JavaThread::currentThread(); - Jnjvm* myvm = JavaThread::get()->getJVM(); + JavaThread* _th = JavaThread::get(); + JavaObject* th = _th->currentThread(); + Jnjvm* myvm = _th->getJVM(); if (th != 0) { (*env) = &(myvm->jniEnv); return JNI_OK; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 30 08:23:26 2008 @@ -74,7 +74,7 @@ // current thread can obtain the lock for that object // (Java specification §8.13). acquire(); - mvm::Thread* self = mvm::Thread::get(); + JavaThread* self = JavaThread::get(); if (getInitializationState() == inClinit) { // 2. If initialization by some other thread is in progress for the @@ -147,9 +147,9 @@ try { super->initialiseClass(vm); } catch(...) { - exc = JavaThread::getJavaException(); + exc = self->getJavaException(); assert(exc && "no exception?"); - JavaThread::clearException(); + self->clearException(); } if (exc) { @@ -158,7 +158,7 @@ setOwnerClass(0); broadcastClass(); release(); - JavaThread::throwException(exc); + self->throwException(exc); } } @@ -196,9 +196,9 @@ try{ meth->invokeIntStatic(vm, cl); } catch(...) { - exc = JavaThread::getJavaException(); + exc = self->getJavaException(); assert(exc && "no exception?"); - JavaThread::clearException(); + self->clearException(); } } #ifdef SERVICE @@ -228,7 +228,7 @@ if (exc->classOf->isAssignableFrom(vm->upcalls->newException)) { Classpath* upcalls = classLoader->bootstrapLoader->upcalls; UserClass* clExcp = upcalls->ExceptionInInitializerError; - Jnjvm* vm = JavaThread::get()->getJVM(); + Jnjvm* vm = self->getJVM(); JavaObject* obj = clExcp->doNew(vm); if (!obj) { fprintf(stderr, "implement me"); @@ -247,7 +247,7 @@ setOwnerClass(0); broadcastClass(); release(); - JavaThread::throwException(exc); + self->throwException(exc); } } @@ -255,7 +255,7 @@ const JavaObject* excp) { JavaObject* obj = cl->doNew(this); init->invokeIntSpecial(this, cl, obj, excp); - JavaThread::throwException(obj); + JavaThread::get()->throwException(obj); } JavaObject* Jnjvm::CreateError(UserClass* cl, JavaMethod* init, @@ -274,7 +274,7 @@ if (cl && !bootstrapLoader->getModule()->isStaticCompiling()) { JavaObject* obj = CreateError(cl, init, tmp); - JavaThread::throwException(obj); + JavaThread::get()->throwException(obj); } else { throw std::string(tmp); } @@ -864,7 +864,7 @@ #endif mapInitialThread(); loadAppClassLoader(); - JavaObject* obj = JavaThread::currentThread(); + JavaObject* obj = JavaThread::get()->currentThread(); JavaObject* javaLoader = appClassLoader->getJavaClassLoader(); #ifdef SERVICE if (!IsolateID) @@ -895,8 +895,9 @@ JavaObject* exc = JavaThread::get()->pendingException; if (exc) { - JavaThread::clearException(); - JavaObject* obj = JavaThread::currentThread(); + JavaThread* th = JavaThread::get(); + th->clearException(); + JavaObject* obj = th->currentThread(); JavaObject* group = upcalls->group->getObjectField(obj); try{ Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp Tue Dec 30 08:23:26 2008 @@ -94,7 +94,7 @@ try { dest(c); } catch(...) { - mvm::Thread::clearException(); + mvm::Thread::get()->clearException(); } } } Modified: vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp?rev=61495&r1=61494&r2=61495&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp Tue Dec 30 08:23:26 2008 @@ -77,7 +77,7 @@ } extern "C" void ClearException() { - return VMThread::clearException(); + return VMThread::get()->clearException(); } static VMObject* doMultiNewIntern(VMClassArray* cl, uint32 dim, sint32* buf) { From nicolas.geoffray at lip6.fr Tue Dec 30 07:10:55 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 15:10:55 -0000 Subject: [vmkit-commits] [vmkit] r61496 - in /vmkit/trunk: include/mvm/JIT.h include/mvm/Threads/Thread.h include/mvm/VirtualMachine.h lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp lib/JnJVM/Classpath/ClasspathVMThrowable.cpp lib/JnJVM/VMCore/JavaThread.cpp lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/Jnjvm.h lib/Mvm/Runtime/JIT.cpp lib/N3/VMCore/BackTrace.cpp lib/N3/VMCore/MSCorlib.cpp lib/N3/VMCore/N3ModuleProvider.cpp Message-ID: <200812301511.mBUFB2xU009211@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 09:10:36 2008 New Revision: 61496 URL: http://llvm.org/viewvc/llvm-project?rev=61496&view=rev Log: Move the function map one up in the virtual machine hierarchy so that N3 can also use it. Modified: vmkit/trunk/include/mvm/JIT.h vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/include/mvm/VirtualMachine.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h vmkit/trunk/lib/Mvm/Runtime/JIT.cpp vmkit/trunk/lib/N3/VMCore/BackTrace.cpp vmkit/trunk/lib/N3/VMCore/MSCorlib.cpp vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Tue Dec 30 09:10:36 2008 @@ -28,7 +28,6 @@ class LockNormal; class MvmMemoryManager; -class Thread; const double MaxDouble = +INFINITY; //1.0 / 0.0; const double MinDouble = -INFINITY;//-1.0 / 0.0; @@ -166,7 +165,6 @@ static int disassemble(unsigned int* addr); - static int getBacktrace(void** stack, int size); static const llvm::Function* getCodeFromPointer(void* addr); static void addMethodInfo(void* end, const llvm::Function* F); Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 30 09:10:36 2008 @@ -195,6 +195,18 @@ VirtualMachine* stoppingService; #endif + /// getBacktrace - Return the back trace of this thread. + /// + int getBacktrace(void** stack, int size) { + void** addr = (void**)__builtin_frame_address(0); + int cpt = 0; + while (addr && cpt < size && addr < baseSP && addr < addr[0]) { + addr = (void**)addr[0]; + stack[cpt++] = (void**)FRAME_IP(addr); + } + return cpt; + } + }; Modified: vmkit/trunk/include/mvm/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/include/mvm/VirtualMachine.h (original) +++ vmkit/trunk/include/mvm/VirtualMachine.h Tue Dec 30 09:10:36 2008 @@ -20,6 +20,9 @@ #include "mvm/Object.h" #include "mvm/Threads/Locks.h" +#include +#include + namespace mvm { /// VirtualMachine - This class is the root of virtual machine classes. It @@ -56,7 +59,41 @@ static CompilationUnit* initialiseCLIVM(); static VirtualMachine* createCLIVM(CompilationUnit* C = 0); + +protected: + + /// JavaFunctionMap - Map of Java method to function pointers. This map is + /// used when walking the stack so that VMKit knows which Java method is + /// executing on the stack. + /// + std::map Functions; + + /// FunctionMapLock - Spin lock to protect the JavaFunctionMap. + /// + mvm::SpinLock FunctionMapLock; + +public: + /// addMethodInFunctionMap - A new method pointer in the function map. + /// + template + void addMethodInFunctionMap(T* meth, void* addr) { + FunctionMapLock.acquire(); + Functions.insert(std::make_pair((void*)addr, meth)); + FunctionMapLock.release(); + } + /// IPToJavaMethod - Map an instruction pointer to the Java method. + /// + template T* IPToMethod(void* ip) { + FunctionMapLock.acquire(); + std::map::iterator I = Functions.upper_bound(ip); + assert(I != Functions.begin() && "Wrong value in function map"); + FunctionMapLock.release(); + + // Decrement because we had the "greater than" value. + I--; + return (T*)I->second; + } #ifdef ISOLATE size_t IsolateID; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Tue Dec 30 09:10:36 2008 @@ -47,7 +47,7 @@ uint32 index = 0; for (; i != e; ++i) { - JavaMethod* meth = vm->IPToJavaMethod(*i); + JavaMethod* meth = vm->IPToMethod(*i); assert(meth && "Wrong stack trace"); res->elements[index++] = meth->classDef->getClassDelegatee(vm); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Tue Dec 30 09:10:36 2008 @@ -104,7 +104,7 @@ std::vector::iterator i = stack->begin(), e = stack->end(); uint32 index = 0; while (i != e) { - JavaMethod* meth = vm->IPToJavaMethod(*i); + JavaMethod* meth = vm->IPToMethod(*i); assert(meth && "Wrong stack trace"); if (meth->classDef->subclassOf(vm->upcalls->newThrowable)) { ++i; @@ -117,7 +117,7 @@ index = 0; for (; i != e; ++i) { - JavaMethod* meth = vm->IPToJavaMethod(*i); + JavaMethod* meth = vm->IPToMethod(*i); assert(meth && "Wrong stack trace"); res->elements[index++] = consStackElement(meth, *i); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 09:10:36 2008 @@ -106,7 +106,7 @@ addr = (void**)addr[0]; void* ip = FRAME_IP(addr); - JavaMethod* meth = getJVM()->IPToJavaMethod(ip); + JavaMethod* meth = getJVM()->IPToMethod(ip); return meth->classDef; } @@ -168,7 +168,7 @@ do { void* ip = FRAME_IP(addr); - JavaMethod* meth = vm->IPToJavaMethod(ip); + JavaMethod* meth = vm->IPToMethod(ip); assert(meth && "Wrong stack"); fprintf(stderr, "; %p in %s\n", ip, meth->printString()); addr = (void**)addr[0]; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 30 09:10:36 2008 @@ -1199,38 +1199,20 @@ -void Jnjvm::addMethodInFunctionMap(JavaMethod* meth, void* addr) { - FunctionMapLock.acquire(); - JavaFunctionMap.insert(std::make_pair(addr, meth)); - FunctionMapLock.release(); -} - void Jnjvm::removeMethodsInFunctionMap(JnjvmClassLoader* loader) { // Loop over all methods in the map to find which ones belong // to this class loader. FunctionMapLock.acquire(); - std::map::iterator temp; - for (std::map::iterator i = JavaFunctionMap.begin(), - e = JavaFunctionMap.end(); i != e;) { - if (i->second->classDef->classLoader == loader) { + std::map::iterator temp; + for (std::map::iterator i = Functions.begin(), + e = Functions.end(); i != e;) { + if (((JavaMethod*)i->second)->classDef->classLoader == loader) { temp = i; ++i; - JavaFunctionMap.erase(temp); + Functions.erase(temp); } else { ++i; } } FunctionMapLock.release(); } - -JavaMethod* Jnjvm::IPToJavaMethod(void* Addr) { - FunctionMapLock.acquire(); - std::map::iterator I = JavaFunctionMap.upper_bound(Addr); - assert(I != JavaFunctionMap.begin() && "Wrong value in function map"); - FunctionMapLock.release(); - - // Decrement because we had the "greater than" value. - I--; - return I->second; - -} Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Tue Dec 30 09:10:36 2008 @@ -342,32 +342,11 @@ /// virtual void waitForExit(); -private: - - /// JavaFunctionMap - Map of Java method to function pointers. This map is - /// used when walking the stack so that VMKit knows which Java method is - /// executing on the stack. - /// - std::map JavaFunctionMap; - - /// FunctionMapLock - Spin lock to protect the JavaFunctionMap. - /// - mvm::SpinLock FunctionMapLock; - -public: - /// addMethodInFunctionMap - A new method pointer in the function map. - /// - void addMethodInFunctionMap(JavaMethod* meth, void* addr); - /// removeMethodsInFunctionMap - Removes all methods compiled by this /// class loader from the function map. /// void removeMethodsInFunctionMap(JnjvmClassLoader* loader); - /// IPToJavaMethod - Map an instruction pointer to the Java method. - /// - JavaMethod* IPToJavaMethod(void* ip); - #ifdef ISOLATE static Jnjvm* RunningIsolates[NR_ISOLATES]; static mvm::LockNormal IsolateLock; Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Tue Dec 30 09:10:36 2008 @@ -266,17 +266,6 @@ pm->run(*func); } -int MvmModule::getBacktrace(void** stack, int size) { - void** addr = (void**)__builtin_frame_address(0); - int cpt = 0; - void* baseSP = mvm::Thread::get()->baseSP; - while (addr && cpt < size && addr < baseSP && addr < addr[0]) { - addr = (void**)addr[0]; - stack[cpt++] = (void**)FRAME_IP(addr); - } - return cpt; -} - static LockNormal lock; static std::map pointerMap; Modified: vmkit/trunk/lib/N3/VMCore/BackTrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/BackTrace.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/BackTrace.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/BackTrace.cpp Tue Dec 30 09:10:36 2008 @@ -23,64 +23,18 @@ using namespace n3; +// Do a backtrace until we know when we cross native -> CLI boundaries. void CLIJit::printBacktrace() { int* ips[100]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100); + int real_size = mvm::Thread::get()->getBacktrace((void**)(void*)ips, 100); int n = 0; while (n < real_size) { - const llvm::Function* F = mvm::MvmModule::getCodeFromPointer(ips[n++]); - if (F) { - VMMethod* meth = CLIJit::getMethod(F); - if (meth) { - printf("; %p in %s\n", (void*)ips[n - 1], meth->printString()); - } else { - printf("; %p in %s\n", (void*)ips[n - 1], "unknown"); - } + Dl_info info; + int res = dladdr(ips[n++], &info); + if (res != 0) { + fprintf(stderr, "; %p in %s\n", (void*)ips[n - 1], info.dli_sname); } else { - Dl_info info; - int res = dladdr(ips[n++], &info); - if (res != 0) { - printf("; %p in %s\n", (void*)ips[n - 1], info.dli_sname); - } else { - printf("; %p in Unknown\n", (void*)ips[n - 1]); - } + fprintf(stderr, "; %p in .Net method\n", (void*)ips[n - 1]); } } } - - - -Assembly* Assembly::getExecutingAssembly() { - int* ips[5]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 5); - int n = 0; - while (n < real_size) { - const llvm::Function* F = mvm::MvmModule::getCodeFromPointer(ips[n++]); - if (F) { - VMMethod* meth = CLIJit::getMethod(F); - if (meth) { - return meth->classDef->assembly; - } - } - } - return 0; -} - -Assembly* Assembly::getCallingAssembly() { - int* ips[5]; - int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 5); - int n = 0; - int i = 0; - while (n < real_size) { - const llvm::Function* F = mvm::MvmModule::getCodeFromPointer(ips[n++]); - if (F) { - VMMethod* meth = CLIJit::getMethod(F); - if (meth && i >= 1) { - return meth->classDef->assembly; - } else { - ++i; - } - } - } - return 0; -} Modified: vmkit/trunk/lib/N3/VMCore/MSCorlib.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/MSCorlib.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/MSCorlib.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/MSCorlib.cpp Tue Dec 30 09:10:36 2008 @@ -74,15 +74,44 @@ extern "C" VMObject* System_Reflection_Assembly_GetCallingAssembly() { - Assembly* ass = Assembly::getCallingAssembly(); - assert(ass); - return ass->getAssemblyDelegatee(); + // Call to this function. + void** cur = (void**)__builtin_frame_address(0); + + // Stub from CLI to native. + cur = (void**)cur[0]; + + // The CLI function. + cur = (void**)cur[0]; + + // The caller of the CLI function; + cur = (void**)cur[0]; + + VirtualMachine* vm = VMThread::get()->vm; + + VMMethod* meth = vm->IPToMethod(FRAME_IP(cur)); + + assert(meth && "Wrong stack"); + + return meth->classDef->assembly->getAssemblyDelegatee(); } extern "C" VMObject* System_Reflection_Assembly_GetExecutingAssembly() { - Assembly* ass = Assembly::getExecutingAssembly(); - assert(ass); - return ass->getAssemblyDelegatee(); + // Call to this function. + void** cur = (void**)__builtin_frame_address(0); + + // Stub from CLI to native. + cur = (void**)cur[0]; + + // The CLI function. + cur = (void**)cur[0]; + + VirtualMachine* vm = VMThread::get()->vm; + + VMMethod* meth = vm->IPToMethod(FRAME_IP(cur)); + + assert(meth && "Wrong stack"); + + return meth->classDef->assembly->getAssemblyDelegatee(); } extern "C" void System_Reflection_Assembly_LoadFromFile() { Modified: vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp?rev=61496&r1=61495&r2=61496&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp Tue Dec 30 09:10:36 2008 @@ -15,7 +15,9 @@ #include "Assembly.h" #include "CLIJit.h" #include "N3ModuleProvider.h" +#include "VirtualMachine.h" #include "VMClass.h" +#include "VMThread.h" using namespace llvm; using namespace n3; @@ -38,6 +40,8 @@ CLIJit::compile(meth->classDef, meth); void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(meth->methPtr); meth->code = res; + VirtualMachine* vm = VMThread::get()->vm; + vm->addMethodInFunctionMap(meth, res); } meth->classDef->release(); meth->classDef->resolveStatic(true, NULL); From nicolas.geoffray at lip6.fr Tue Dec 30 07:25:37 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 15:25:37 -0000 Subject: [vmkit-commits] [vmkit] r61497 - in /vmkit/trunk: include/mvm/JIT.h include/mvm/MvmMemoryManager.h lib/Mvm/Runtime/JIT.cpp lib/Mvm/Runtime/MvmMemoryManager.cpp lib/Mvm/Runtime/Object.cpp Message-ID: <200812301525.mBUFPfri009738@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 09:25:26 2008 New Revision: 61497 URL: http://llvm.org/viewvc/llvm-project?rev=61497&view=rev Log: Finally, get rid of MvmMemoryManager.{cpp,h}. Removed: vmkit/trunk/include/mvm/MvmMemoryManager.h vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp Modified: vmkit/trunk/include/mvm/JIT.h vmkit/trunk/lib/Mvm/Runtime/JIT.cpp vmkit/trunk/lib/Mvm/Runtime/Object.cpp Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=61497&r1=61496&r2=61497&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Tue Dec 30 09:25:26 2008 @@ -27,7 +27,6 @@ namespace mvm { class LockNormal; -class MvmMemoryManager; const double MaxDouble = +INFINITY; //1.0 / 0.0; const double MinDouble = -INFINITY;//-1.0 / 0.0; @@ -161,13 +160,9 @@ static llvm::Module *globalModule; static llvm::ExistingModuleProvider *globalModuleProvider; - static mvm::MvmMemoryManager *memoryManager; static int disassemble(unsigned int* addr); - static const llvm::Function* getCodeFromPointer(void* addr); - static void addMethodInfo(void* end, const llvm::Function* F); - }; Removed: vmkit/trunk/include/mvm/MvmMemoryManager.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/MvmMemoryManager.h?rev=61496&view=auto ============================================================================== --- vmkit/trunk/include/mvm/MvmMemoryManager.h (original) +++ vmkit/trunk/include/mvm/MvmMemoryManager.h (removed) @@ -1,122 +0,0 @@ -//===------- MvmMemoryManager.h - LLVM Memory manager for Mvm -------------===// -// -// Mvm -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - - -#ifndef MVM_MEMORY_MANAGER_H -#define MVM_MEMORY_MANAGER_H - -#include - -#include - -using namespace llvm; - -namespace mvm { - -/// MvmMemoryManager - This class is a wrapper to the default JITMemoryManager -/// in LLVM. It creates Code objects for backtraces and getting virtual machine -/// information out of dynamically generated native code. -/// -class MvmMemoryManager : public JITMemoryManager { - - /// realMemoryManager - The real allocator - JITMemoryManager* realMemoryManager; - -public: - - MvmMemoryManager() : JITMemoryManager() { - realMemoryManager = JITMemoryManager::CreateDefaultMemManager(); - } - - /// startFunctionBody - When we start JITing a function, the JIT calls this - /// method to allocate a block of free RWX memory, which returns a pointer to - /// it. The JIT doesn't know ahead of time how much space it will need to - /// 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) { - return realMemoryManager->startFunctionBody(F, ActualSize); - } - - /// allocateStub - This method is called by the JIT to allocate space for a - /// function stub (used to handle limited branch displacements) while it is - /// JIT compiling a function. For example, if foo calls bar, and if bar - /// either needs to be lazily compiled or is a native function that exists too - /// far away from the call site to work, this method will be used to make a - /// 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* GV, unsigned StubSize, - unsigned Alignment) { - return realMemoryManager->allocateStub(GV, StubSize, Alignment); - } - - /// 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 - /// compiled function. This passes in FunctionStart (which was returned by - /// 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); - - /// deallocateMemForFunction - Free JIT memory for the specified function. - /// This is never called when the JIT is currently emitting a function. - virtual void deallocateMemForFunction(const Function *F) { - return realMemoryManager->deallocateMemForFunction(F); - } - - /// AllocateGOT - If the current table requires a Global Offset Table, this - /// method is invoked to allocate it. This method is required to set HasGOT - /// to true. - virtual void AllocateGOT() { - return realMemoryManager->AllocateGOT(); - } - - /// getGOTBase - If this is managing a Global Offset Table, this method should - /// return a pointer to its base. - virtual unsigned char *getGOTBase() const { - return realMemoryManager->getGOTBase(); - } - - - /// 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) { - return realMemoryManager->startExceptionTable(F, ActualSize); - } - - /// 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) { - return realMemoryManager->endExceptionTable(F, TableStart, TableEnd, - FrameRegister); - } - - virtual void setMemoryWritable() { - realMemoryManager->setMemoryWritable(); - } - - virtual void setMemoryExecutable() { - realMemoryManager->setMemoryExecutable(); - } - - virtual unsigned char* allocateSpace(intptr_t Size, unsigned int Align) { - return realMemoryManager->allocateSpace(Size, Align); - } - -}; - -} // End mvm namespace - -#endif Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=61497&r1=61496&r2=61497&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Tue Dec 30 09:25:26 2008 @@ -19,11 +19,8 @@ #include "llvm/Target/TargetOptions.h" -#include - #include "mvm/CompilationUnit.h" #include "mvm/JIT.h" -#include "mvm/MvmMemoryManager.h" #include "mvm/Object.h" #include "mvm/Threads/Locks.h" #include "mvm/Threads/Thread.h" @@ -32,26 +29,6 @@ using namespace llvm; -extern "C" void printFloat(float f) { - fprintf(stderr, "%f\n", f); -} - -extern "C" void printDouble(double d) { - fprintf(stderr, "%f\n", d); -} - -extern "C" void printLong(sint64 l) { - fprintf(stderr, "%lld\n", (long long int)l); -} - -extern "C" void printInt(sint32 i) { - fprintf(stderr, "%d\n", i); -} - -extern "C" void printObject(mvm::Object* obj) { - fprintf(stderr, "%s\n", obj->printString()); -} - namespace mvm { namespace llvm_runtime { #include "LLVMRuntime.inc" @@ -63,12 +40,11 @@ llvm::ExceptionHandling = true; globalModule = new llvm::Module("bootstrap module"); globalModuleProvider = new ExistingModuleProvider (globalModule); - memoryManager = new MvmMemoryManager(); executionEngine = ExecutionEngine::createJIT(globalModuleProvider, 0, - memoryManager, Fast); + 0, Fast); std::string str = executionEngine->getTargetData()->getStringRepresentation(); @@ -254,7 +230,6 @@ llvm::Module *MvmModule::globalModule; llvm::ExistingModuleProvider *MvmModule::globalModuleProvider; -mvm::MvmMemoryManager *MvmModule::memoryManager; uint64 MvmModule::getTypeSize(const llvm::Type* type) { @@ -266,31 +241,6 @@ pm->run(*func); } -static LockNormal lock; -static std::map pointerMap; - -const llvm::Function* MvmModule::getCodeFromPointer(void* Addr) { - lock.lock(); - std::map::iterator I = - pointerMap.lower_bound(Addr); - - lock.unlock(); - if (I != pointerMap.end()) { - const llvm::Function* F = I->second; - if (Addr >= executionEngine->getPointerToGlobal(F)) return F; - } - - return 0; -} - -void MvmModule::addMethodInfo(void* Addr, const llvm::Function* F) { - lock.lock(); - pointerMap.insert(std::make_pair(Addr, F)); - lock.unlock(); -} - - - static void addPass(FunctionPassManager *PM, Pass *P) { // Add the pass to the pass manager... PM->add(P); Removed: vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp?rev=61496&view=auto ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp (removed) @@ -1,23 +0,0 @@ -//===----- MvmMemoryManager.cpp - LLVM Memory manager for Mvm -------------===// -// -// Mvm -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "mvm/JIT.h" -#include "mvm/Object.h" - -#include "mvm/MvmMemoryManager.h" - -using namespace mvm; -using namespace llvm; - -void MvmMemoryManager::endFunctionBody(const Function *F, - unsigned char *FunctionStart, - unsigned char *FunctionEnd) { - MvmModule::addMethodInfo((void*)FunctionEnd, F); - realMemoryManager->endFunctionBody(F, FunctionStart, FunctionEnd); -} Modified: vmkit/trunk/lib/Mvm/Runtime/Object.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Object.cpp?rev=61497&r1=61496&r2=61497&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/Object.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/Object.cpp Tue Dec 30 09:25:26 2008 @@ -7,6 +7,7 @@ // //===----------------------------------------------------------------------===// +#include #include #include "MvmGC.h" @@ -21,6 +22,26 @@ VirtualTable *NativeString::VT = 0; VirtualTable *PrintBuffer::VT = 0; +extern "C" void printFloat(float f) { + fprintf(stderr, "%f\n", f); +} + +extern "C" void printDouble(double d) { + fprintf(stderr, "%f\n", d); +} + +extern "C" void printLong(sint64 l) { + fprintf(stderr, "%lld\n", (long long int)l); +} + +extern "C" void printInt(sint32 i) { + fprintf(stderr, "%d\n", i); +} + +extern "C" void printObject(mvm::Object* obj) { + fprintf(stderr, "%s\n", obj->printString()); +} + void Object::initialise() { # define INIT(X) { \ From nicolas.geoffray at lip6.fr Tue Dec 30 07:33:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 15:33:29 -0000 Subject: [vmkit-commits] [vmkit] r61498 - in /vmkit/trunk: include/mvm/Sigsegv.h lib/Mvm/Runtime/Sigsegv.cpp Message-ID: <200812301533.mBUFXUPP010011@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 09:33:23 2008 New Revision: 61498 URL: http://llvm.org/viewvc/llvm-project?rev=61498&view=rev Log: Remove unused file. Removed: vmkit/trunk/include/mvm/Sigsegv.h Modified: vmkit/trunk/lib/Mvm/Runtime/Sigsegv.cpp Removed: vmkit/trunk/include/mvm/Sigsegv.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Sigsegv.h?rev=61497&view=auto ============================================================================== --- vmkit/trunk/include/mvm/Sigsegv.h (original) +++ vmkit/trunk/include/mvm/Sigsegv.h (removed) @@ -1,28 +0,0 @@ -//===------------ Sigsegv.h - Sgsegv handler for mvm ---------------------===// -// -// The Micro Virtual Machine -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - - -#ifndef MVM_SIGSEGV_H -#define MVM_SIGSEGV_H - -#include - -namespace mvm { - -__BEGIN_DECLS - -void register_sigsegv_handler(void (*fct)(int, void *)); - -__END_DECLS - -} // end namespace mvm; - -#endif //MVM_SIGSEGV_H - - Modified: vmkit/trunk/lib/Mvm/Runtime/Sigsegv.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Sigsegv.cpp?rev=61498&r1=61497&r2=61498&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/Sigsegv.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/Sigsegv.cpp Tue Dec 30 09:33:23 2008 @@ -9,11 +9,10 @@ #include "MvmGC.h" -#include "mvm/Sigsegv.h" #include "mvm/Threads/Thread.h" -#include -#include +#include +#include using namespace mvm; From nicolas.geoffray at lip6.fr Tue Dec 30 07:47:25 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 15:47:25 -0000 Subject: [vmkit-commits] [vmkit] r61499 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaClass.h JavaConstantPool.cpp JavaConstantPool.h JavaMetaJIT.cpp JavaObject.cpp JavaRuntimeJIT.cpp JavaThread.cpp JavaTypes.cpp JavaUpcalls.cpp Jni.cpp Jnjvm.cpp JnjvmClassLoader.h LowerConstantCalls.cpp Message-ID: <200812301547.mBUFlSDc010435@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 09:47:17 2008 New Revision: 61499 URL: http://llvm.org/viewvc/llvm-project?rev=61499&view=rev Log: Cleanup includes. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Tue Dec 30 09:47:17 2008 @@ -13,7 +13,6 @@ #include -#include "mvm/JIT.h" #include "debug.h" #include "types.h" @@ -22,12 +21,12 @@ #include "JavaCache.h" #include "JavaClass.h" #include "JavaConstantPool.h" -#include "JavaJIT.h" #include "JavaObject.h" #include "JavaThread.h" #include "JavaTypes.h" #include "JavaUpcalls.h" #include "Jnjvm.h" +#include "JnjvmModule.h" #include "JnjvmModuleProvider.h" #include "LockedMap.h" #include "Reader.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Dec 30 09:47:17 2008 @@ -10,12 +10,10 @@ #ifndef JNJVM_JAVA_CLASS_H #define JNJVM_JAVA_CLASS_H -#include #include "types.h" #include "mvm/Allocator.h" -#include "mvm/JIT.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" #include "mvm/Threads/Cond.h" @@ -23,9 +21,11 @@ #include "JavaAccess.h" #include "JnjvmClassLoader.h" - #include "JnjvmConfig.h" +#include +#include + namespace jnjvm { class ArrayObject; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Tue Dec 30 09:47:17 2008 @@ -19,8 +19,8 @@ #include "JavaArray.h" #include "JavaClass.h" #include "JavaConstantPool.h" -#include "JavaJIT.h" #include "Jnjvm.h" +#include "JnjvmModule.h" #include "JnjvmModuleProvider.h" #include "JavaThread.h" #include "JavaTypes.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Tue Dec 30 09:47:17 2008 @@ -10,7 +10,6 @@ #ifndef JNJVM_JAVA_CONSTANT_POOL_H #define JNJVM_JAVA_CONSTANT_POOL_H -#include "mvm/JIT.h" #include "mvm/Object.h" #include "types.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Tue Dec 30 09:47:17 2008 @@ -10,17 +10,12 @@ #include #include -#include "mvm/JIT.h" - #include "debug.h" -#include "JavaArray.h" #include "JavaClass.h" -#include "JavaJIT.h" #include "JavaObject.h" #include "JavaThread.h" #include "JavaTypes.h" #include "Jnjvm.h" -#include "JnjvmModule.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Tue Dec 30 09:47:17 2008 @@ -9,7 +9,6 @@ #include -#include "mvm/JIT.h" #include "mvm/Threads/Locks.h" #include "JavaClass.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Dec 30 09:47:17 2008 @@ -10,14 +10,12 @@ #include -#include "mvm/JIT.h" #include "mvm/Threads/Thread.h" #include "JavaArray.h" #include "JavaCache.h" #include "JavaClass.h" #include "JavaConstantPool.h" -#include "JavaJIT.h" #include "JavaString.h" #include "JavaThread.h" #include "JavaTypes.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 09:47:17 2008 @@ -7,13 +7,11 @@ // //===----------------------------------------------------------------------===// -#include "mvm/JIT.h" #include "mvm/PrintBuffer.h" #include "mvm/Threads/Locks.h" #include "mvm/Threads/Thread.h" #include "JavaClass.h" -#include "JavaJIT.h" #include "JavaObject.h" #include "JavaThread.h" #include "JavaUpcalls.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Tue Dec 30 09:47:17 2008 @@ -9,17 +9,10 @@ #include -#include "mvm/JIT.h" - -#include "JavaAccess.h" #include "JavaArray.h" #include "JavaClass.h" -#include "JavaConstantPool.h" -#include "JavaJIT.h" -#include "JavaThread.h" #include "JavaTypes.h" -#include "JavaUpcalls.h" -#include "Jnjvm.h" +#include "JnjvmModule.h" using namespace jnjvm; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Tue Dec 30 09:47:17 2008 @@ -9,12 +9,9 @@ #include -#include "mvm/JIT.h" - #include "ClasspathReflect.h" #include "JavaAccess.h" #include "JavaClass.h" -#include "JavaJIT.h" #include "JavaObject.h" #include "JavaString.h" #include "JavaThread.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Tue Dec 30 09:47:17 2008 @@ -11,7 +11,6 @@ #include "JavaArray.h" #include "JavaClass.h" -#include "JavaJIT.h" #include "JavaObject.h" #include "JavaString.h" #include "JavaThread.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 30 09:47:17 2008 @@ -17,19 +17,18 @@ #include #include "debug.h" -#include "mvm/JIT.h" #include "mvm/Threads/Thread.h" #include "ClasspathReflect.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaConstantPool.h" -#include "JavaJIT.h" #include "JavaString.h" #include "JavaThread.h" #include "JavaTypes.h" #include "JavaUpcalls.h" #include "Jnjvm.h" +#include "JnjvmModule.h" #include "JnjvmModuleProvider.h" #include "LockedMap.h" #include "Reader.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Tue Dec 30 09:47:17 2008 @@ -11,6 +11,7 @@ #ifndef JNJVM_CLASSLOADER_H #define JNJVM_CLASSLOADER_H +#include #include #include "types.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=61499&r1=61498&r2=61499&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Dec 30 09:47:17 2008 @@ -15,8 +15,6 @@ #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" -#include "mvm/JIT.h" - #include "JnjvmModule.h" using namespace llvm; From nicolas.geoffray at lip6.fr Tue Dec 30 08:06:52 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 16:06:52 -0000 Subject: [vmkit-commits] [vmkit] r61500 - /vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Message-ID: <200812301606.mBUG6sYE011044@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 10:06:41 2008 New Revision: 61500 URL: http://llvm.org/viewvc/llvm-project?rev=61500&view=rev Log: Inline the initialization of java.lang.Class objects in JnJVM. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61500&r1=61499&r2=61500&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Dec 30 10:06:41 2008 @@ -473,16 +473,18 @@ postProperties.push_back(std::make_pair(key, value)); } +// Mimic what's happening in Classpath when creating a java.lang.Class object. JavaObject* UserCommonClass::getClassDelegatee(Jnjvm* vm, JavaObject* pd) { if (!getDelegatee()) { UserClass* cl = vm->upcalls->newClass; - JavaObject* delegatee = cl->doNew(vm); - if (!pd) { - vm->upcalls->initClass->invokeIntSpecial(vm, cl, delegatee, this); + JavaObjectClass* delegatee = (JavaObjectClass*)cl->doNew(vm); + delegatee->vmdata = this; + if (!pd && isArray()) { + JavaObjectClass* base = (JavaObjectClass*) + asArrayClass()->baseClass()->getClassDelegatee(vm, pd); + delegatee->pd = base->pd; } else { - vm->upcalls->initClassWithProtectionDomain->invokeIntSpecial(vm, cl, - delegatee, - this, pd); + delegatee->pd = pd; } setDelegatee(delegatee); } From nicolas.geoffray at lip6.fr Tue Dec 30 09:50:55 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 17:50:55 -0000 Subject: [vmkit-commits] [vmkit] r61501 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Message-ID: <200812301750.mBUHotmj014444@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 11:50:52 2008 New Revision: 61501 URL: http://llvm.org/viewvc/llvm-project?rev=61501&view=rev Log: Prune includes. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61501&r1=61500&r2=61501&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Tue Dec 30 11:50:52 2008 @@ -12,22 +12,24 @@ #include -#include "llvm/Constant.h" -#include "llvm/DerivedTypes.h" -#include "llvm/Function.h" -#include "llvm/GlobalVariable.h" -#include "llvm/Module.h" -#include "llvm/Type.h" -#include "llvm/Value.h" - -#include "mvm/JIT.h" - #include "JavaClass.h" #include "JavaConstantPool.h" #include "JavaTypes.h" +#include "llvm/Module.h" + +namespace llvm { + class Constant; + class ConstantInt; + class Function; + class GlobalVariable; + class Type; + class Value; +} + namespace jnjvm { +class Attribut; class CacheNode; class CommonClass; class Class; @@ -36,7 +38,6 @@ class JavaMethod; class JavaObject; class JnjvmModule; -class Signdef; class LLVMAssessorInfo { public: From nicolas.geoffray at lip6.fr Tue Dec 30 10:46:53 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 18:46:53 -0000 Subject: [vmkit-commits] [vmkit] r61502 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMStackWalker.cpp Classpath/ClasspathVMSystemProperties.cpp VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/JavaJIT.cpp VMCore/JavaUpcalls.cpp VMCore/JnjvmModule.cpp VMCore/JnjvmModule.h VMCore/JnjvmModuleProvider.cpp Message-ID: <200812301846.mBUIkt21016464@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 12:46:51 2008 New Revision: 61502 URL: http://llvm.org/viewvc/llvm-project?rev=61502&view=rev Log: Tell that a method has a method pointer directly to the method instead of the module. The method is responsible for inserting the pointer to the map. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Tue Dec 30 12:46:51 2008 @@ -79,32 +79,4 @@ return res; } -extern "C" JavaObject* getCallingClass() { - - JavaObject* res = 0; - - BEGIN_NATIVE_EXCEPTION(0) - - JavaThread* th = JavaThread::get(); - UserClass* cl = th->getCallingClass(); - if (cl) res = cl->getClassDelegatee(th->getJVM()); - - END_NATIVE_EXCEPTION - - return res; -} - -extern "C" JavaObject* getCallingClassLoader() { - - JavaObject *res = 0; - - BEGIN_NATIVE_EXCEPTION(0) - JavaThread* th = JavaThread::get(); - UserClass* cl = th->getCallingClass(); - res = cl->classLoader->getJavaClassLoader(); - END_NATIVE_EXCEPTION - - return res; -} - } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Tue Dec 30 12:46:51 2008 @@ -123,7 +123,7 @@ END_NATIVE_EXCEPTION } -extern "C" void propertiesPostInit(JavaObject* prop) { +extern "C" void nativePropertiesPostInit(JavaObject* prop) { BEGIN_NATIVE_EXCEPTION(0) Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Tue Dec 30 12:46:51 2008 @@ -9,10 +9,6 @@ #define JNJVM_LOAD 0 -#include - -#include - #include "debug.h" #include "types.h" @@ -31,6 +27,9 @@ #include "LockedMap.h" #include "Reader.h" +#include +#include + using namespace jnjvm; const UTF8* Attribut::codeAttribut = 0; @@ -372,12 +371,24 @@ if (code == 0) { code = classDef->classLoader->getModuleProvider()->materializeFunction(this); + Jnjvm* vm = JavaThread::get()->getJVM(); + vm->addMethodInFunctionMap(this, code); } classDef->release(); return code; } } +void JavaMethod::setCompiledPtr(void* ptr) { + classDef->acquire(); + assert(code == 0 && "Code of Java method already set!"); + code = ptr; + Jnjvm* vm = JavaThread::get()->getJVM(); + vm->addMethodInFunctionMap(this, code); + classDef->classLoader->getModule()->setMethod(this, ptr); + classDef->release(); +} + const char* JavaMethod::printString() const { mvm::PrintBuffer *buf= mvm::PrintBuffer::alloc(); buf->write("JavaMethod<"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Dec 30 12:46:51 2008 @@ -944,6 +944,10 @@ /// void* compiledPtr(); + /// setCompiledPtr - Set the pointer function to the method. + /// + void setCompiledPtr(void*); + /// JavaMethod - Delete the method as well as the cache enveloppes and /// attributes of the method. /// @@ -958,7 +962,7 @@ Attribut* attributs; uint16 nbAttributs; - /// caches - List of caches in this method. For all invokeinterface bytecode + /// enveloppes - List of caches in this method. For all invokeinterface bytecode /// there is a corresponding cache. /// Enveloppe* enveloppes; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 12:46:51 2008 @@ -198,7 +198,7 @@ Function* func = llvmFunction; if (jnjvm) { - module->executionEngine->addGlobalMapping(func, (void*)natPtr); + compilingMethod->setCompiledPtr((void*)natPtr); return llvmFunction; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Tue Dec 30 12:46:51 2008 @@ -242,6 +242,48 @@ finaliseCreateInitialThread->invokeIntStatic(vm, inheritableThreadLocal, th); } +extern "C" JavaString* nativeInternString(JavaString* obj) { + Jnjvm* vm = JavaThread::get()->getJVM(); + const UTF8* utf8 = obj->strToUTF8(vm); + return vm->UTF8ToStr(utf8); +} + +extern "C" uint8 nativeIsArray(JavaObject* klass) { + UserCommonClass* cl = ((JavaObjectClass*)klass)->getClass(); + return (uint8)cl->isArray(); +} + +extern "C" JavaObject* nativeGetCallingClass() { + + JavaObject* res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + + JavaThread* th = JavaThread::get(); + UserClass* cl = th->getCallingClass(); + if (cl) res = cl->getClassDelegatee(th->getJVM()); + + END_NATIVE_EXCEPTION + + return res; +} + +extern "C" JavaObject* nativeGetCallingClassLoader() { + + JavaObject *res = 0; + + BEGIN_NATIVE_EXCEPTION(0) + JavaThread* th = JavaThread::get(); + UserClass* cl = th->getCallingClass(); + res = cl->classLoader->getJavaClassLoader(); + END_NATIVE_EXCEPTION + + return res; +} + +extern "C" void nativePropertiesPostInit(JavaObject* prop); + + void Classpath::initialiseClasspath(JnjvmClassLoader* loader) { newClassLoader = @@ -427,11 +469,11 @@ JavaMethod* internString = UPCALL_METHOD(loader, "java/lang/VMString", "intern", "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC); - loader->getModule()->setMethod(internString, "internString"); + internString->setCompiledPtr((void*)(intptr_t)nativeInternString); JavaMethod* isArray = UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL); - loader->getModule()->setMethod(isArray, "isArray"); + isArray->setCompiledPtr((void*)(intptr_t)nativeIsArray); UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException); @@ -591,26 +633,17 @@ JavaMethod* getCallingClass = UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass", "()Ljava/lang/Class;", ACC_STATIC); - loader->getModule()->setMethod(getCallingClass, "getCallingClass"); + getCallingClass->setCompiledPtr((void*)(intptr_t)nativeGetCallingClass); JavaMethod* getCallingClassLoader = UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClassLoader", "()Ljava/lang/ClassLoader;", ACC_STATIC); - loader->getModule()->setMethod(getCallingClassLoader, "getCallingClassLoader"); + getCallingClassLoader->setCompiledPtr((void*)(intptr_t) + nativeGetCallingClassLoader); JavaMethod* postProperties = UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit", "(Ljava/util/Properties;)V", ACC_STATIC); - loader->getModule()->setMethod(postProperties, "propertiesPostInit"); + postProperties->setCompiledPtr((void*)(intptr_t)nativePropertiesPostInit); } -extern "C" JavaString* internString(JavaString* obj) { - Jnjvm* vm = JavaThread::get()->getJVM(); - const UTF8* utf8 = obj->strToUTF8(vm); - return vm->UTF8ToStr(utf8); -} - -extern "C" uint8 isArray(JavaObject* klass) { - UserCommonClass* cl = ((JavaObjectClass*)klass)->getClass(); - return (uint8)cl->isArray(); -} Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 30 12:46:51 2008 @@ -1819,10 +1819,11 @@ return PrimitiveArrayVT; } -void JnjvmModule::setMethod(JavaMethod* meth, const char* name) { - llvm::Function* func = getMethodInfo(meth)->getMethod(); - func->setName(name); - func->setLinkage(llvm::GlobalValue::ExternalLinkage); +void JnjvmModule::setMethod(JavaMethod* meth, void* ptr) { + Function* func = getMethodInfo(meth)->getMethod(); + assert(ptr && "No value given"); + executionEngine->addGlobalMapping(func, ptr); + func->setLinkage(GlobalValue::ExternalLinkage); } void JnjvmModule::printStats() { @@ -1846,7 +1847,7 @@ } -void* JnjvmModule::getMethod(JavaMethod* meth) { +Function* JnjvmModule::getMethod(JavaMethod* meth) { return getMethodInfo(meth)->getMethod(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Tue Dec 30 12:46:51 2008 @@ -367,8 +367,8 @@ static void resolveVirtualClass(Class* cl); static void resolveStaticClass(Class* cl); - static void setMethod(JavaMethod* meth, const char* name); - static void* getMethod(JavaMethod* meth); + static void setMethod(JavaMethod* meth, void* ptr); + static llvm::Function* getMethod(JavaMethod* meth); static LLVMSignatureInfo* getSignatureInfo(Signdef* sign) { return sign->getInfo(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=61502&r1=61501&r2=61502&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Tue Dec 30 12:46:51 2008 @@ -108,9 +108,6 @@ void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(func); func->deleteBody(); - - Jnjvm* vm = JavaThread::get()->getJVM(); - vm->addMethodInFunctionMap(meth, res); return res; } From nicolas.geoffray at lip6.fr Tue Dec 30 15:16:19 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 23:16:19 -0000 Subject: [vmkit-commits] [vmkit] r61507 - /vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Message-ID: <200812302316.mBUNGMEX026326@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 17:16:14 2008 New Revision: 61507 URL: http://llvm.org/viewvc/llvm-project?rev=61507&view=rev Log: Also set the display when setting super after reading the class. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61507&r1=61506&r2=61507&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Dec 30 17:16:14 2008 @@ -325,6 +325,7 @@ /// void setSuper(Class* S) { super = S; + display[0] = (CommonClass*)S; } /// toPrimitive - Returns the primitive class which represents From nicolas.geoffray at lip6.fr Tue Dec 30 15:39:13 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 23:39:13 -0000 Subject: [vmkit-commits] [vmkit] r61509 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200812302339.mBUNdGLE027190@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 17:38:54 2008 New Revision: 61509 URL: http://llvm.org/viewvc/llvm-project?rev=61509&view=rev Log: Don't parse finalizers so early when static compiling. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61509&r1=61508&r2=61509&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 30 17:38:54 2008 @@ -281,6 +281,8 @@ } Constant* JnjvmModule::getVirtualTable(Class* classDef) { + LLVMClassInfo* LCI = getClassInfo((Class*)classDef); + LCI->getVirtualType(); if (staticCompilation) { llvm::Constant* res = 0; virtual_table_iterator End = virtualTables.end(); @@ -297,7 +299,6 @@ 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, Finalizer, @@ -310,8 +311,6 @@ } } else { - LLVMClassInfo* LCI = getClassInfo((Class*)classDef); - LCI->getVirtualType(); assert(classDef->virtualVT && "Virtual VT not created"); void* ptr = classDef->virtualVT; ConstantInt* CI = ConstantInt::get(Type::Int64Ty, uint64_t(ptr)); @@ -1153,7 +1152,7 @@ // Special handling for finalize method. Don't put a finalizer // if there is none, or if it is empty. - if (meth.offset == 0) { + if (meth.offset == 0 && !staticCompilation) { #ifdef ISOLATE_SHARING ((void**)VT)[0] = 0; #else @@ -1167,7 +1166,7 @@ BasicBlock::iterator I = BB->begin(); if (isa(I)) { ((void**)VT)[0] = 0; - } else if (!staticCompilation) { + } else { // LLVM does not allow recursive compilation. Create the code now. ((void**)VT)[0] = EE->getPointerToFunction(func); } From nicolas.geoffray at lip6.fr Tue Dec 30 15:41:34 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 23:41:34 -0000 Subject: [vmkit-commits] [vmkit] r61510 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Message-ID: <200812302341.mBUNfbM1027278@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 17:41:15 2008 New Revision: 61510 URL: http://llvm.org/viewvc/llvm-project?rev=61510&view=rev Log: 80-col violation. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61510&r1=61509&r2=61510&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 17:41:15 2008 @@ -236,7 +236,8 @@ currentBlock); threadId = BinaryOperator::CreateAnd(threadId, module->constantThreadIDMask, "", currentBlock); - threadId = new IntToPtrInst(threadId, module->JavaThreadType, "", currentBlock); + threadId = new IntToPtrInst(threadId, module->JavaThreadType, "", + currentBlock); Value* geps[2] = { module->constantZero, module->constantEight }; From nicolas.geoffray at lip6.fr Tue Dec 30 15:14:47 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 23:14:47 -0000 Subject: [vmkit-commits] [vmkit] r61506 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200812302314.mBUNEoxQ026256@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 17:14:35 2008 New Revision: 61506 URL: http://llvm.org/viewvc/llvm-project?rev=61506&view=rev Log: Fix type of array VTs. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61506&r1=61505&r2=61506&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 30 17:14:35 2008 @@ -1791,9 +1791,7 @@ if (staticCompilation) { - const ArrayType* ATy = dyn_cast(VTType->getContainedType(0)); - const PointerType* PTy = dyn_cast(ATy->getContainedType(0)); - ATy = ArrayType::get(PTy, 16); + const Type* ATy = VTType->getContainedType(0); PrimitiveArrayVT = new GlobalVariable(ATy, true, GlobalValue::ExternalLinkage, 0, "JavaArrayVT", this); From nicolas.geoffray at lip6.fr Tue Dec 30 15:13:46 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 23:13:46 -0000 Subject: [vmkit-commits] [vmkit] r61505 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Message-ID: <200812302313.mBUNDog6026217@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 17:13:29 2008 New Revision: 61505 URL: http://llvm.org/viewvc/llvm-project?rev=61505&view=rev Log: Fix type of a class when setting it to a Java object. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=61505&r1=61504&r2=61505&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Tue Dec 30 17:13:29 2008 @@ -1839,6 +1839,9 @@ compilingClass->classLoader->bootstrapLoader; UserClassArray* dcl = loader->getArrayClass(id); valCl = module->getNativeClass(dcl); + if (valCl->getType() != module->JavaCommonClassType) + valCl = new BitCastInst(valCl, module->JavaCommonClassType, "", + currentBlock); #else Value* args[2] = { isolateLocal, ConstantInt::get(Type::Int32Ty, id - 4) }; @@ -1860,6 +1863,9 @@ UserCommonClass* dcl = JCL->constructArray(arrayName); valCl = module->getNativeClass(dcl); + if (valCl->getType() != module->JavaCommonClassType) + valCl = new BitCastInst(valCl, module->JavaCommonClassType, "", + currentBlock); } else { const llvm::Type* Ty = From nicolas.geoffray at lip6.fr Tue Dec 30 12:44:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 20:44:29 -0000 Subject: [vmkit-commits] [vmkit] r61503 - in /vmkit/trunk/lib/JnJVM/VMCore: JnjvmModuleProvider.cpp LowerConstantCalls.cpp Message-ID: <200812302044.mBUKifcg020633@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 14:43:57 2008 New Revision: 61503 URL: http://llvm.org/viewvc/llvm-project?rev=61503&view=rev Log: Merge LowerForcedCalls with LowerConstantCalls and remove LowerForcedCalls. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=61503&r1=61502&r2=61503&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Tue Dec 30 14:43:57 2008 @@ -167,7 +167,6 @@ namespace jnjvm { llvm::FunctionPass* createLowerConstantCallsPass(); - llvm::FunctionPass* createLowerForcedCallsPass(); } JnjvmModuleProvider::JnjvmModuleProvider(JnjvmModule *m) { @@ -187,7 +186,6 @@ Function* func = m->JavaObjectAllocateFunction; JavaFunctionPasses->add(mvm::createEscapeAnalysisPass(func)); JavaFunctionPasses->add(createLowerConstantCallsPass()); - JavaFunctionPasses->add(createLowerForcedCallsPass()); nbCallbacks = 0; } Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=61503&r1=61502&r2=61503&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Dec 30 14:43:57 2008 @@ -449,8 +449,10 @@ BranchInst::Create(NBB, OKBlock); break; } + } else if (V == module->ForceInitialisationCheckFunction) { + Changed = true; + CI->eraseFromParent(); } - #ifdef ISOLATE_SHARING else if (V == module->GetCtpClassFunction) { Changed = true; @@ -504,41 +506,5 @@ FunctionPass* createLowerConstantCallsPass() { return new LowerConstantCalls(); } - -class VISIBILITY_HIDDEN LowerForcedCalls : public FunctionPass { - public: - static char ID; - LowerForcedCalls() : FunctionPass((intptr_t)&ID) { } - - virtual bool runOnFunction(Function &F); - private: - }; - char LowerForcedCalls::ID = 0; - static RegisterPass Y("LowerForcedCalls", - "Lower Forced calls"); - -bool LowerForcedCalls::runOnFunction(Function& F) { - JnjvmModule* module = (JnjvmModule*)F.getParent(); - bool Changed = false; - for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; BI++) { - BasicBlock *Cur = BI; - for (BasicBlock::iterator II = Cur->begin(), IE = Cur->end(); II != IE;) { - Instruction *I = II; - II++; - if (CallInst *CI = dyn_cast(I)) { - Value* V = CI->getOperand(0); - if (V == module->ForceInitialisationCheckFunction) { - Changed = true; - CI->eraseFromParent(); - } - } - } - } - return Changed; -} - -FunctionPass* createLowerForcedCallsPass() { - return new LowerForcedCalls(); -} } From nicolas.geoffray at lip6.fr Tue Dec 30 14:00:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 30 Dec 2008 22:00:26 -0000 Subject: [vmkit-commits] [vmkit] r61504 - in /vmkit/trunk: include/mvm/Threads/Thread.h lib/JnJVM/LLVMRuntime/runtime-default.ll lib/JnJVM/LLVMRuntime/runtime-single.ll lib/JnJVM/VMCore/JavaJIT.cpp lib/JnJVM/VMCore/JavaThread.cpp lib/JnJVM/VMCore/JavaThread.h lib/JnJVM/VMCore/JnjvmModule.cpp lib/JnJVM/VMCore/JnjvmModule.h Message-ID: <200812302200.mBUM0pkH023250@zion.cs.uiuc.edu> Author: geoffray Date: Tue Dec 30 15:59:50 2008 New Revision: 61504 URL: http://llvm.org/viewvc/llvm-project?rev=61504&view=rev Log: Use a JavaThread type to fetch the jni environment for native methods. Modified: vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Dec 30 15:59:50 2008 @@ -122,10 +122,8 @@ public: -#ifdef ISOLATE /// IsolateID - The Isolate ID of the thread's VM. size_t IsolateID; -#endif /// MyVM - The VM attached to this Thread. VirtualMachine* MyVM; 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=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Tue Dec 30 15:59:50 2008 @@ -33,6 +33,19 @@ ;;; Field 2: The static instance %TaskClassMirror = type { i32, i8* } +;;; Field 0: the VT of threads +;;; Field 1: next +;;; Field 2: prev +;;; Field 3: IsolateID +;;; Field 4: MyVM +;;; Field 5: baseSP +;;; Field 6: internalThreadID +;;; field 7: routine +;;; field 8: jnienv +%JavaThread = type { %VT*, %JavaThread*, %JavaThread*, i8*, i8*, i8*, i8*, i8*, + i8* } + + %Attribut = type { %UTF8*, i32, i32 } %UTF8 = type { %JavaObject, i8*, [0 x i16] } Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-single.ll Tue Dec 30 15:59:50 2008 @@ -11,4 +11,3 @@ %JavaMethod*, i16, i8*, %ArrayUInt8*, i8*, %Attribut*, i16, %JavaClass**, i16, %JavaClass*, i16, i8, i32, i32, i8*, void (i8*)* } - Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Dec 30 15:59:50 2008 @@ -230,10 +230,23 @@ uint32 nargs = func->arg_size() + 1 + (stat ? 1 : 0); std::vector nativeArgs; - int64_t jniEnv = (int64_t)&(JavaThread::get()->getJVM()->jniEnv); - nativeArgs.push_back( - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, jniEnv), - module->ptrType)); + Value* threadId = CallInst::Create(module->llvm_frameaddress, + module->constantZero, "", currentBlock); + threadId = new PtrToIntInst(threadId, module->pointerSizeType, "", + currentBlock); + threadId = BinaryOperator::CreateAnd(threadId, module->constantThreadIDMask, + "", currentBlock); + threadId = new IntToPtrInst(threadId, module->JavaThreadType, "", currentBlock); + + + Value* geps[2] = { module->constantZero, module->constantEight }; + + Value* jniEnv = GetElementPtrInst::Create(threadId, geps, geps + 2, "", + currentBlock); + + jniEnv = new BitCastInst(jniEnv, module->ptrType, "", currentBlock); + + nativeArgs.push_back(jniEnv); uint32 index = 0; if (stat) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Dec 30 15:59:50 2008 @@ -31,6 +31,7 @@ interruptFlag = 0; state = StateRunning; pendingException = 0; + jniEnv = isolate->jniEnv; #ifdef SERVICE eipIndex = 0; replacedEIPs = new void*[100]; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Dec 30 15:59:50 2008 @@ -69,6 +69,10 @@ /// static VirtualTable *VT; + /// jniEnv - The JNI environment of the thread. + /// + void* jniEnv; + /// javaThread - The Java representation of this thread. /// JavaObject* javaThread; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Dec 30 15:59:50 2008 @@ -60,6 +60,7 @@ const llvm::Type* JnjvmModule::JavaFieldType = 0; const llvm::Type* JnjvmModule::JavaMethodType = 0; const llvm::Type* JnjvmModule::AttributType = 0; +const llvm::Type* JnjvmModule::JavaThreadType = 0; #ifdef ISOLATE_SHARING const llvm::Type* JnjvmModule::JnjvmType = 0; @@ -1758,6 +1759,8 @@ PointerType::getUnqual(module->getTypeByName("UTF8")); AttributType = PointerType::getUnqual(module->getTypeByName("Attribut")); + JavaThreadType = + PointerType::getUnqual(module->getTypeByName("JavaThread")); #ifdef WITH_TRACER MarkAndTraceType = module->getFunction("MarkAndTrace")->getFunctionType(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61504&r1=61503&r2=61504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Tue Dec 30 15:59:50 2008 @@ -268,6 +268,7 @@ static const llvm::Type* JavaMethodType; static const llvm::Type* JavaFieldType; static const llvm::Type* AttributType; + static const llvm::Type* JavaThreadType; #ifdef ISOLATE_SHARING static const llvm::Type* JnjvmType; From nicolas.geoffray at lip6.fr Wed Dec 31 01:05:55 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 31 Dec 2008 09:05:55 -0000 Subject: [vmkit-commits] [vmkit] r61518 - /vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Message-ID: <200812310905.mBV95u6C030265@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 31 03:05:53 2008 New Revision: 61518 URL: http://llvm.org/viewvc/llvm-project?rev=61518&view=rev Log: Do a try catch when loading the class, because it may raise an exception. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=61518&r1=61517&r2=61518&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Wed Dec 31 03:05:53 2008 @@ -880,16 +880,16 @@ } void Jnjvm::executeClass(const char* className, ArrayObject* args) { - const UTF8* name = appClassLoader->asciizConstructUTF8(className); - UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true); - cl->initialiseClass(this); - - const UTF8* funcSign = - appClassLoader->asciizConstructUTF8("([Ljava/lang/String;)V"); - const UTF8* funcName = appClassLoader->asciizConstructUTF8("main"); - JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0); - try { + const UTF8* name = appClassLoader->asciizConstructUTF8(className); + UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true); + cl->initialiseClass(this); + + const UTF8* funcSign = + appClassLoader->asciizConstructUTF8("([Ljava/lang/String;)V"); + const UTF8* funcName = appClassLoader->asciizConstructUTF8("main"); + JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0); + method->invokeIntStatic(this, method->classDef, args); }catch(...) { } @@ -913,16 +913,20 @@ void Jnjvm::executePremain(const char* className, JavaString* args, JavaObject* instrumenter) { - const UTF8* name = appClassLoader->asciizConstructUTF8(className); - UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true); - cl->initialiseClass(this); + try { + const UTF8* name = appClassLoader->asciizConstructUTF8(className); + UserClass* cl = (UserClass*)appClassLoader->loadName(name, true, true); + cl->initialiseClass(this); - const UTF8* funcSign = appClassLoader->asciizConstructUTF8( + const UTF8* funcSign = appClassLoader->asciizConstructUTF8( "(Ljava/lang/String;Ljava/lang/instrument/Instrumentation;)V"); - const UTF8* funcName = appClassLoader->asciizConstructUTF8("premain"); - JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0); + const UTF8* funcName = appClassLoader->asciizConstructUTF8("premain"); + JavaMethod* method = cl->lookupMethod(funcName, funcSign, true, true, 0); - method->invokeIntStatic(this, method->classDef, args, instrumenter); + method->invokeIntStatic(this, method->classDef, args, instrumenter); + } catch(...) { + JavaThread::get()->clearException(); + } } void Jnjvm::waitForExit() { From nicolas.geoffray at lip6.fr Wed Dec 31 02:45:03 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 31 Dec 2008 10:45:03 -0000 Subject: [vmkit-commits] [vmkit] r61520 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaClass.h JavaJIT.cpp JnjvmClassLoader.cpp JnjvmClassLoader.h JnjvmModule.cpp Message-ID: <200812311045.mBVAj4KJ002145@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 31 04:45:01 2008 New Revision: 61520 URL: http://llvm.org/viewvc/llvm-project?rev=61520&view=rev Log: Fix names of Java and JNI functions when static compiling. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61520&r1=61519&r2=61520&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Wed Dec 31 04:45:01 2008 @@ -1210,3 +1210,20 @@ ptr[0] = 0; } + +bool UserClass::isNativeOverloaded(JavaMethod* meth) { + + for (uint32 i = 0; i < nbVirtualMethods; ++i) { + JavaMethod& cur = virtualMethods[i]; + if (&cur != meth && cur.name->equals(meth->name)) + return true; + } + + for (uint32 i = 0; i < nbStaticMethods; ++i) { + JavaMethod& cur = staticMethods[i]; + if (&cur != meth && cur.name->equals(meth->name)) + return true; + } + + return false; +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61520&r1=61519&r2=61520&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Wed Dec 31 04:45:01 2008 @@ -874,6 +874,7 @@ } #endif + bool isNativeOverloaded(JavaMethod* meth); }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61520&r1=61519&r2=61520&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Dec 31 04:45:01 2008 @@ -185,8 +185,19 @@ const FunctionType *funcType = llvmFunction->getFunctionType(); bool jnjvm = false; - natPtr = natPtr ? natPtr : - compilingClass->classLoader->nativeLookup(compilingMethod, jnjvm); + + const UTF8* jniConsClName = compilingClass->name; + const UTF8* jniConsName = compilingMethod->name; + const UTF8* jniConsType = compilingMethod->type; + sint32 clen = jniConsClName->size; + sint32 mnlen = jniConsName->size; + sint32 mtlen = jniConsType->size; + + char* functionName = (char*)alloca(3 + JNI_NAME_PRE_LEN + + ((mnlen + clen + mtlen) << 1)); + if (!natPtr) + natPtr = compilingClass->classLoader->nativeLookup(compilingMethod, jnjvm, + functionName); if (!natPtr && !module->isStaticCompiling()) { fprintf(stderr, "Native function %s not found. Probably " Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=61520&r1=61519&r2=61520&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Wed Dec 31 04:45:01 2008 @@ -883,17 +883,9 @@ return (intptr_t)dlsym(handle, name); } -intptr_t JnjvmClassLoader::nativeLookup(JavaMethod* meth, bool& jnjvm) { +intptr_t JnjvmClassLoader::nativeLookup(JavaMethod* meth, bool& jnjvm, + char* buf) { - const UTF8* jniConsClName = meth->classDef->name; - const UTF8* jniConsName = meth->name; - const UTF8* jniConsType = meth->type; - sint32 clen = jniConsClName->size; - sint32 mnlen = jniConsName->size; - sint32 mtlen = jniConsType->size; - - char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + - ((mnlen + clen + mtlen) << 1)); meth->jniConsFromMeth(buf); intptr_t res = loadInLib(buf, jnjvm); if (!res) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=61520&r1=61519&r2=61520&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Wed Dec 31 04:45:01 2008 @@ -265,7 +265,7 @@ /// method. Also set in the jnjvm parameter is the function is defined in /// JnJVM. /// - intptr_t nativeLookup(JavaMethod* meth, bool& jnjvm); + intptr_t nativeLookup(JavaMethod* meth, bool& jnjvm, char* buf); }; /// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61520&r1=61519&r2=61520&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Dec 31 04:45:01 2008 @@ -327,12 +327,25 @@ LLVMSignatureInfo* LSI = getSignatureInfo(meth->getSignature()); const llvm::Type* valPtrType = LSI->getNativeType(); + + const UTF8* jniConsClName = meth->classDef->name; + const UTF8* jniConsName = meth->name; + const UTF8* jniConsType = meth->type; + sint32 clen = jniConsClName->size; + sint32 mnlen = jniConsName->size; + sint32 mtlen = jniConsType->size; + + char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + 1 + + ((mnlen + clen + mtlen) << 1)); - assert((ptr || isStaticCompiling()) && "No native function given"); + if (meth->classDef->isNativeOverloaded(meth)) + meth->jniConsFromMethOverloaded(buf); + else + meth->jniConsFromMeth(buf); - varGV = new GlobalVariable(valPtrType, false, + varGV = new GlobalVariable(valPtrType, true, GlobalValue::ExternalLinkage, - 0, "", this); + 0, buf, this); nativeFunctions.insert(std::make_pair(meth, varGV)); return varGV; @@ -1329,6 +1342,7 @@ JnjvmClassLoader* JCL = methodDef->classDef->classLoader; JnjvmModule* Mod = JCL->getModule(); if (Mod->isStaticCompiling()) { + const UTF8* jniConsClName = methodDef->classDef->name; const UTF8* jniConsName = methodDef->name; const UTF8* jniConsType = methodDef->type; @@ -1336,9 +1350,21 @@ sint32 mnlen = jniConsName->size; sint32 mtlen = jniConsType->size; - char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + + char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + 1 + ((mnlen + clen + mtlen) << 1)); - methodDef->jniConsFromMethOverloaded(buf); + + if (isNative(methodDef->access)) { + bool jnjvm = false; + JCL->nativeLookup(methodDef, jnjvm, buf); + if (!jnjvm) { + methodDef->jniConsFromMethOverloaded(buf + 1); + memcpy(buf, "JnJVM", 5); + } + } else { + methodDef->jniConsFromMethOverloaded(buf + 1); + memcpy(buf, "JnJVM", 5); + } + methodFunction = Function::Create(getFunctionType(), GlobalValue::GhostLinkage, buf, Mod); From nicolas.geoffray at lip6.fr Wed Dec 31 08:08:18 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 31 Dec 2008 16:08:18 -0000 Subject: [vmkit-commits] [vmkit] r61522 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaClass.h JavaJIT.cpp JavaUpcalls.cpp JnjvmModule.cpp JnjvmModule.h Message-ID: <200812311608.mBVG8IQ1011591@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 31 10:08:16 2008 New Revision: 61522 URL: http://llvm.org/viewvc/llvm-project?rev=61522&view=rev Log: Also set the name when setting the compiled method pointer. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61522&r1=61521&r2=61522&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Wed Dec 31 10:08:16 2008 @@ -379,13 +379,14 @@ } } -void JavaMethod::setCompiledPtr(void* ptr) { +void JavaMethod::setCompiledPtr(void* ptr, const char* name) { classDef->acquire(); assert(code == 0 && "Code of Java method already set!"); code = ptr; Jnjvm* vm = JavaThread::get()->getJVM(); vm->addMethodInFunctionMap(this, code); - classDef->classLoader->getModule()->setMethod(this, ptr); + classDef->classLoader->getModule()->setMethod(this, ptr, name); + access |= ACC_NATIVE; classDef->release(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=61522&r1=61521&r2=61522&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Wed Dec 31 10:08:16 2008 @@ -948,7 +948,7 @@ /// setCompiledPtr - Set the pointer function to the method. /// - void setCompiledPtr(void*); + void setCompiledPtr(void*, const char*); /// JavaMethod - Delete the method as well as the cache enveloppes and /// attributes of the method. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=61522&r1=61521&r2=61522&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Dec 31 10:08:16 2008 @@ -209,7 +209,7 @@ Function* func = llvmFunction; if (jnjvm) { - compilingMethod->setCompiledPtr((void*)natPtr); + compilingMethod->setCompiledPtr((void*)natPtr, functionName); return llvmFunction; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=61522&r1=61521&r2=61522&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Wed Dec 31 10:08:16 2008 @@ -469,11 +469,12 @@ JavaMethod* internString = UPCALL_METHOD(loader, "java/lang/VMString", "intern", "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC); - internString->setCompiledPtr((void*)(intptr_t)nativeInternString); + internString->setCompiledPtr((void*)(intptr_t)nativeInternString, + "nativeInternString"); JavaMethod* isArray = UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL); - isArray->setCompiledPtr((void*)(intptr_t)nativeIsArray); + isArray->setCompiledPtr((void*)(intptr_t)nativeIsArray, "nativeIsArray"); UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException); @@ -633,17 +634,20 @@ JavaMethod* getCallingClass = UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass", "()Ljava/lang/Class;", ACC_STATIC); - getCallingClass->setCompiledPtr((void*)(intptr_t)nativeGetCallingClass); + getCallingClass->setCompiledPtr((void*)(intptr_t)nativeGetCallingClass, + "nativeGetCallingClass"); JavaMethod* getCallingClassLoader = UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClassLoader", "()Ljava/lang/ClassLoader;", ACC_STATIC); getCallingClassLoader->setCompiledPtr((void*)(intptr_t) - nativeGetCallingClassLoader); + nativeGetCallingClassLoader, + "nativeGetCallingClassLoader"); JavaMethod* postProperties = UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit", "(Ljava/util/Properties;)V", ACC_STATIC); - postProperties->setCompiledPtr((void*)(intptr_t)nativePropertiesPostInit); + postProperties->setCompiledPtr((void*)(intptr_t)nativePropertiesPostInit, + "nativePropertiesPostInit"); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=61522&r1=61521&r2=61522&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Dec 31 10:08:16 2008 @@ -1353,17 +1353,8 @@ char* buf = (char*)alloca(3 + JNI_NAME_PRE_LEN + 1 + ((mnlen + clen + mtlen) << 1)); - if (isNative(methodDef->access)) { - bool jnjvm = false; - JCL->nativeLookup(methodDef, jnjvm, buf); - if (!jnjvm) { - methodDef->jniConsFromMethOverloaded(buf + 1); - memcpy(buf, "JnJVM", 5); - } - } else { - methodDef->jniConsFromMethOverloaded(buf + 1); - memcpy(buf, "JnJVM", 5); - } + methodDef->jniConsFromMethOverloaded(buf + 1); + memcpy(buf, "JnJVM", 5); methodFunction = Function::Create(getFunctionType(), GlobalValue::GhostLinkage, buf, Mod); @@ -1845,8 +1836,9 @@ return PrimitiveArrayVT; } -void JnjvmModule::setMethod(JavaMethod* meth, void* ptr) { +void JnjvmModule::setMethod(JavaMethod* meth, void* ptr, const char* name) { Function* func = getMethodInfo(meth)->getMethod(); + func->setName(name); assert(ptr && "No value given"); executionEngine->addGlobalMapping(func, ptr); func->setLinkage(GlobalValue::ExternalLinkage); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=61522&r1=61521&r2=61522&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Wed Dec 31 10:08:16 2008 @@ -368,7 +368,7 @@ static void resolveVirtualClass(Class* cl); static void resolveStaticClass(Class* cl); - static void setMethod(JavaMethod* meth, void* ptr); + static void setMethod(JavaMethod* meth, void* ptr, const char* name); static llvm::Function* getMethod(JavaMethod* meth); static LLVMSignatureInfo* getSignatureInfo(Signdef* sign) { From nicolas.geoffray at lip6.fr Wed Dec 31 08:14:38 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 31 Dec 2008 16:14:38 -0000 Subject: [vmkit-commits] [vmkit] r61524 - /vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Message-ID: <200812311614.mBVGEcuN011806@zion.cs.uiuc.edu> Author: geoffray Date: Wed Dec 31 10:14:38 2008 New Revision: 61524 URL: http://llvm.org/viewvc/llvm-project?rev=61524&view=rev Log: Bugfix for isNativeOverloaded. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=61524&r1=61523&r2=61524&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Wed Dec 31 10:14:38 2008 @@ -1216,13 +1216,13 @@ for (uint32 i = 0; i < nbVirtualMethods; ++i) { JavaMethod& cur = virtualMethods[i]; - if (&cur != meth && cur.name->equals(meth->name)) + if (&cur != meth && isNative(cur.access) && cur.name->equals(meth->name)) return true; } for (uint32 i = 0; i < nbStaticMethods; ++i) { JavaMethod& cur = staticMethods[i]; - if (&cur != meth && cur.name->equals(meth->name)) + if (&cur != meth && isNative(cur.access) && cur.name->equals(meth->name)) return true; }