From nicolas.geoffray at lip6.fr Thu Oct 2 15:42:01 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:42:01 -0000 Subject: [vmkit-commits] [vmkit] r56971 - /vmkit/branches/isolate/lib/Mvm/Runtime/JIT.cpp Message-ID: <200810022242.m92Mg1Oo023938@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:42:01 2008 New Revision: 56971 URL: http://llvm.org/viewvc/llvm-project?rev=56971&view=rev Log: Don't use __builtin_frame_addr with a level of 1, as suggested by the GCC documentation. Modified: vmkit/branches/isolate/lib/Mvm/Runtime/JIT.cpp Modified: vmkit/branches/isolate/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/Mvm/Runtime/JIT.cpp?rev=56971&r1=56970&r2=56971&view=diff ============================================================================== --- vmkit/branches/isolate/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/branches/isolate/lib/Mvm/Runtime/JIT.cpp Thu Oct 2 17:42:01 2008 @@ -315,12 +315,12 @@ #endif int mvm::jit::getBacktrace(void** stack, int size) { - void** addr = (void**)__builtin_frame_address(1); + 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]) { - stack[cpt++] = (void**)FRAME_IP(addr); addr = (void**)addr[0]; + stack[cpt++] = (void**)FRAME_IP(addr); } return cpt; } From nicolas.geoffray at lip6.fr Thu Oct 2 15:45:30 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:45:30 -0000 Subject: [vmkit-commits] [vmkit] r56972 - /vmkit/branches/isolate/lib/Mvm/GCMmap2/gc.cpp Message-ID: <200810022245.m92MjUht024059@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:45:30 2008 New Revision: 56972 URL: http://llvm.org/viewvc/llvm-project?rev=56972&view=rev Log: Use the address of the setjmp buffer as the starting pointer to the stack. This makes us less dependent on GCC's optimizations. Modified: vmkit/branches/isolate/lib/Mvm/GCMmap2/gc.cpp Modified: vmkit/branches/isolate/lib/Mvm/GCMmap2/gc.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/Mvm/GCMmap2/gc.cpp?rev=56972&r1=56971&r2=56972&view=diff ============================================================================== --- vmkit/branches/isolate/lib/Mvm/GCMmap2/gc.cpp (original) +++ vmkit/branches/isolate/lib/Mvm/GCMmap2/gc.cpp Thu Oct 2 17:45:30 2008 @@ -234,8 +234,7 @@ if(!loc) /* a key is being destroyed */ COLLECTOR threads->another_mark(); else { - unsigned int* top; - register unsigned int **cur = ⊤ + register unsigned int **cur = (unsigned int**)&buf; register unsigned int **max = loc->base_sp(); GCChunkNode *node; From nicolas.geoffray at lip6.fr Thu Oct 2 15:47:54 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:47:54 -0000 Subject: [vmkit-commits] [vmkit] r56973 - /vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Message-ID: <200810022247.m92MlsDO024140@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:47:54 2008 New Revision: 56973 URL: http://llvm.org/viewvc/llvm-project?rev=56973&view=rev Log: Provide safe implementations of casting. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h?rev=56973&r1=56972&r2=56973&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Thu Oct 2 17:47:54 2008 @@ -216,18 +216,41 @@ return array; } - /// isPrimitive - Is the class a primitive class? - /// bool primitive; + /// isPrimitive - Is the class a primitive class? + /// bool isPrimitive() { return primitive; } - + + /// isInterface - Is the class an interface? + /// bool isInterface() { return jnjvm::isInterface(access); } + /// asClass - Returns the class as a user-defined class + /// if it is not a primitive or an array. + UserClass* asClass() { + if (!primitive && !array) return (UserClass*)this; + return 0; + } + + /// asPrimitiveClass - Returns the class if it's a primitive class. + /// + UserClassPrimitive* asPrimitiveClass() { + if (primitive) return (UserClassPrimitive*)this; + return 0; + } + + /// asArrayClass - Returns the class if it's an array class. + /// + UserClassArray* asArrayClass() { + if (array) return (UserClassArray*)this; + return 0; + } + /// interfaces - The interfaces this class implements. /// std::vector interfaces; From nicolas.geoffray at lip6.fr Thu Oct 2 15:48:30 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:48:30 -0000 Subject: [vmkit-commits] [vmkit] r56974 - /vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Message-ID: <200810022248.m92MmUJK024170@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:48:30 2008 New Revision: 56974 URL: http://llvm.org/viewvc/llvm-project?rev=56974&view=rev Log: Use safe casting of classes. Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=56974&r1=56973&r2=56974&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original) +++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Thu Oct 2 17:48:30 2008 @@ -56,7 +56,7 @@ Jnjvm* vm = JavaThread::get()->isolate; JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, - true, false); + true, false); if (cl != 0) { if (clinit) { cl->initialiseClass(vm); @@ -271,9 +271,9 @@ #endif jclass Cl, jboolean publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); - if (cl->isArray()) { + if (!cl) { return (jobject)ArrayObject::acons(0, vm->upcalls->fieldArrayClass, &(vm->allocator)); } else { std::vector res; @@ -323,14 +323,16 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); - cl->resolveInnerOuterClasses(); - UserClass* outer = cl->getOuterClass(); - if (outer) { - return (jclass)outer->getClassDelegatee(vm); - } else { - return 0; + UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + if (cl) { + cl->resolveInnerOuterClasses(); + UserClass* outer = cl->getOuterClass(); + if (outer) { + return (jclass)outer->getClassDelegatee(vm); + } } + + return 0; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses( @@ -340,17 +342,21 @@ #endif jclass Cl, bool publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); - cl->resolveInnerOuterClasses(); - std::vector* innerClasses = cl->getInnerClasses(); - ArrayObject* res = ArrayObject::acons(innerClasses->size(), vm->upcalls->constructorArrayClass, &(vm->allocator)); - uint32 index = 0; - for (std::vector::iterator i = innerClasses->begin(), - e = innerClasses->end(); i!= e; i++) { - res->elements[index++] = (*i)->getClassDelegatee(vm); + UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + if (cl) { + cl->resolveInnerOuterClasses(); + std::vector* innerClasses = cl->getInnerClasses(); + ArrayObject* res = ArrayObject::acons(innerClasses->size(), vm->upcalls->constructorArrayClass, &(vm->allocator)); + uint32 index = 0; + for (std::vector::iterator i = innerClasses->begin(), + e = innerClasses->end(); i!= e; i++) { + res->elements[index++] = (*i)->getClassDelegatee(vm); + } + return (jobject)res; } - return (jobject)res; + return 0; + } From nicolas.geoffray at lip6.fr Thu Oct 2 15:57:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:57:26 -0000 Subject: [vmkit-commits] [vmkit] r56976 - in /vmkit/branches/isolate/lib/JnJVM/VMCore: JavaArray.cpp JavaArray.h Message-ID: <200810022257.m92MvQfn024451@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:57:26 2008 New Revision: 56976 URL: http://llvm.org/viewvc/llvm-project?rev=56976&view=rev Log: Implement UTF8::checkedJavaToInternal, UTF8::printString, and malloc instead of gcmalloc when debugging UTF8ToAsciiz. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp?rev=56976&r1=56975&r2=56976&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp Thu Oct 2 17:57:26 2008 @@ -88,6 +88,19 @@ return map->lookupOrCreateReader(java, len); } +const UTF8* UTF8::checkedJavaToInternal(UTF8Map* map, unsigned int start, + unsigned int len) const { + uint16* java = (uint16*) alloca(len * sizeof(uint16)); + for (uint32 i = 0; i < len; i++) { + uint16 cur = elements[start + i]; + if (cur == '.') java[i] = '/'; + else if (cur == '/') return 0; + else java[i] = cur; + } + + return map->lookupOrCreateReader(java, len); +} + const UTF8* UTF8::internalToJava(UTF8Map* map, unsigned int start, unsigned int len) const { uint16* java = (uint16*) alloca(len * sizeof(uint16)); @@ -112,12 +125,21 @@ } char* UTF8::UTF8ToAsciiz() const { +#ifndef DEBUG mvm::NativeString* buf = mvm::NativeString::alloc(size + 1); for (sint32 i = 0; i < size; ++i) { buf->setAt(i, elements[i]); } buf->setAt(size, 0); return buf->cString(); +#else + char* buf = (char*)malloc(size + 1); + for (sint32 i = 0; i < size; ++i) { + buf[i] = elements[i]; + } + buf[size] = 0; + return buf; +#endif } /// Currently, this uses malloc/free. This should use a custom memory pool. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h?rev=56976&r1=56975&r2=56976&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h Thu Oct 2 17:57:26 2008 @@ -137,8 +137,18 @@ const UTF8* javaToInternal(UTF8Map* map, unsigned int start, unsigned int len) const; + /// checkedJavaToInternal - Replaces all '/' into '.'. Returns null if the + /// UTF8 contains a '/', as Java does not allow things like + /// Class.forName("java/lang/Object") + const UTF8* checkedJavaToInternal(UTF8Map* map, unsigned int start, + unsigned int len) const; + /// UTF8ToAsciiz - Allocates a C string with the contents of this UTF8. char* UTF8ToAsciiz() const; + + char* printString() const { + return UTF8ToAsciiz(); + } /// extract - Creates an UTF8 by extracting the contents at the given size /// of this. From nicolas.geoffray at lip6.fr Thu Oct 2 15:58:13 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:58:13 -0000 Subject: [vmkit-commits] [vmkit] r56977 - in /vmkit/branches/isolate/lib/JnJVM/VMCore: JnjvmClassLoader.cpp JnjvmClassLoader.h Message-ID: <200810022258.m92MwDs6024480@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:58:13 2008 New Revision: 56977 URL: http://llvm.org/viewvc/llvm-project?rev=56977&view=rev Log: Let callers of resolveClassFromUTF8 decide which UTF8 to give. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=56977&r1=56976&r2=56977&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Oct 2 17:58:13 2008 @@ -179,12 +179,12 @@ return cl; } -UserCommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* utf8, unsigned int start, - unsigned int len, - bool doResolve, - bool doThrow) { +UserCommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* name, + bool doResolve, + bool doThrow) { + uint32 len = name->size; + uint32 start = 0; uint32 origLen = len; - const UTF8* name = utf8->javaToInternal(hashUTF8, start, len); bool doLoop = true; UserCommonClass* ret = 0; @@ -203,10 +203,10 @@ uint32 size = (uint32)name->size; if ((size == (start + 1)) || (size == (start + 2)) || (name->elements[start + 1] == I_TAB) || - (utf8->elements[origLen - 1] != I_END_REF)) { + (name->elements[origLen - 1] != I_END_REF)) { doLoop = false; } else { - const UTF8* componentName = utf8->javaToInternal(hashUTF8, + const UTF8* componentName = name->javaToInternal(hashUTF8, start + 1, len - 2); if (loadName(componentName, doResolve, doThrow)) { @@ -245,8 +245,19 @@ UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, bool doResolve, bool doThrow) { - return lookupClassFromUTF8(str->value, str->offset, str->count, - doResolve, doThrow); + + const UTF8* name = 0; + + if (str->value->elements[str->offset] != I_TAB) + name = str->value->checkedJavaToInternal(hashUTF8, str->offset, + str->count); + else + name = str->value->javaToInternal(hashUTF8, str->offset, str->count); + + if (name) + return lookupClassFromUTF8(name, doResolve, doThrow); + + return 0; } UserCommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) { Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=56977&r1=56976&r2=56977&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h Thu Oct 2 17:58:13 2008 @@ -140,9 +140,8 @@ /// lookupClassFromUTF8 - Lookup a class from an UTF8 name and load it. /// - UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, unsigned int start, - unsigned int len, bool doResolve, - bool doThrow); + UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, bool doResolve, + bool doThrow); /// lookupClassFromJavaString - Lookup a class from a Java String and load it. /// From nicolas.geoffray at lip6.fr Thu Oct 2 15:59:54 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 22:59:54 -0000 Subject: [vmkit-commits] [vmkit] r56978 - /vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Message-ID: <200810022259.m92MxsdB024539@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 17:59:54 2008 New Revision: 56978 URL: http://llvm.org/viewvc/llvm-project?rev=56978&view=rev Log: Cleanup. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=56978&r1=56977&r2=56978&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Thu Oct 2 17:59:54 2008 @@ -119,22 +119,6 @@ mvm::Code* m = mvm::jit::getCodeFromPointer(res); if (m) m->setMetaInfo(meth); func->deleteBody(); -/* - if (meth->name->equals( - JavaThread::get()->isolate->bootstrapLoader->asciizConstructUTF8("getDeclaredConstructors"))) { - func->print(std::cout); - printf("\n"); - void* res = mvm::jit::executionEngine->getPointerToGlobal(llvmFunction); - void* base = res; - while (base < (void*)((char*)res + 100)) { - printf("%08x\t", (unsigned)base); - int n= mvm::jit::disassemble((unsigned int *)base); - printf("\n"); - base= ((void *)((char *)base + n)); - } - printf("\n"); - fflush(stdout); - }*/ return res; } From nicolas.geoffray at lip6.fr Thu Oct 2 16:01:08 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 23:01:08 -0000 Subject: [vmkit-commits] [vmkit] r56979 - /vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp Message-ID: <200810022301.m92N19ut024593@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 18:01:08 2008 New Revision: 56979 URL: http://llvm.org/viewvc/llvm-project?rev=56979&view=rev Log: Use the new interface of lookupClassFromUTF8. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp?rev=56979&r1=56978&r2=56979&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp Thu Oct 2 18:01:08 2008 @@ -71,8 +71,8 @@ const UTF8* utf8 = loader->asciizConstructUTF8(asciiz); sint32 len = utf8->size; - - UserCommonClass* cl = loader->lookupClassFromUTF8(utf8, 0, len, true, true); + const UTF8* internal = utf8->javaToInternal(loader->hashUTF8, 0, len); + UserCommonClass* cl = loader->lookupClassFromUTF8(internal, true, true); cl->initialiseClass(vm); return (jclass)(cl->getClassDelegatee(vm)); From nicolas.geoffray at lip6.fr Thu Oct 2 16:02:21 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 23:02:21 -0000 Subject: [vmkit-commits] [vmkit] r56980 - /vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Message-ID: <200810022302.m92N2Ln7024665@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 18:02:21 2008 New Revision: 56980 URL: http://llvm.org/viewvc/llvm-project?rev=56980&view=rev Log: Fix access flags for classes and arrays. Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp?rev=56980&r1=56979&r2=56980&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Thu Oct 2 18:02:21 2008 @@ -301,7 +301,7 @@ display = (CommonClass**)malloc(2 * sizeof(CommonClass*)); display[0] = ClassArray::SuperArray; display[1] = this; - access = ACC_FINAL | ACC_ABSTRACT; + access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC; if (base->isPrimitive()) { virtualVT = JavaArray::VT; } else { @@ -736,6 +736,8 @@ ctpInfo = new JavaConstantPool(this, reader); access = reader.readU2(); + if (!isPublic(access)) access |= ACC_PRIVATE; + const UTF8* thisClassName = ctpInfo->resolveClassName(reader.readU2()); From nicolas.geoffray at lip6.fr Thu Oct 2 16:02:55 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 23:02:55 -0000 Subject: [vmkit-commits] [vmkit] r56981 - /vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp Message-ID: <200810022302.m92N2tIF024687@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 18:02:55 2008 New Revision: 56981 URL: http://llvm.org/viewvc/llvm-project?rev=56981&view=rev Log: Also initialize equivalent primitive classes (e.g. java/lang/Integer). Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp?rev=56981&r1=56980&r2=56981&view=diff ============================================================================== --- vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp Thu Oct 2 18:02:55 2008 @@ -675,6 +675,14 @@ LOAD_CLASS(upcalls->newField); LOAD_CLASS(upcalls->newStackTraceElement); LOAD_CLASS(upcalls->newVMThrowable); + LOAD_CLASS(upcalls->boolClass); + LOAD_CLASS(upcalls->byteClass); + LOAD_CLASS(upcalls->charClass); + LOAD_CLASS(upcalls->shortClass); + LOAD_CLASS(upcalls->intClass); + LOAD_CLASS(upcalls->longClass); + LOAD_CLASS(upcalls->floatClass); + LOAD_CLASS(upcalls->doubleClass); LOAD_CLASS(upcalls->InvocationTargetException); LOAD_CLASS(upcalls->ArrayStoreException); LOAD_CLASS(upcalls->ClassCastException); From nicolas.geoffray at lip6.fr Thu Oct 2 16:28:37 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 02 Oct 2008 23:28:37 -0000 Subject: [vmkit-commits] [vmkit] r56982 - in /vmkit/trunk: include/mvm/ lib/JnJVM/ lib/JnJVM/Classpath/ lib/JnJVM/Isolate/ lib/JnJVM/LLVMRuntime/ lib/JnJVM/VMCore/ lib/Mvm/GCMmap2/ lib/Mvm/Runtime/ lib/N3/ lib/N3/LLVMRuntime/ lib/N3/VMCore/ tools/jnjvm/ tools/vmkit/ Message-ID: <200810022328.m92NSd9G025601@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 2 18:28:36 2008 New Revision: 56982 URL: http://llvm.org/viewvc/llvm-project?rev=56982&view=rev Log: Merge with the isolate branch. Added: vmkit/trunk/lib/JnJVM/Isolate/ - copied from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/ vmkit/trunk/lib/JnJVM/Isolate/IsolateCommonClass.cpp - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp vmkit/trunk/lib/JnJVM/Isolate/IsolateCommonClass.h - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h vmkit/trunk/lib/JnJVM/Isolate/IsolateSharedLoader.cpp - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp vmkit/trunk/lib/JnJVM/Isolate/IsolateSharedLoader.h - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.h vmkit/trunk/lib/JnJVM/Isolate/Makefile - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/Makefile vmkit/trunk/lib/JnJVM/Isolate/SharedMaps.h - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h - copied unchanged from r56981, vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmConfig.h vmkit/trunk/lib/N3/LLVMRuntime/ - copied from r56981, vmkit/branches/isolate/lib/N3/LLVMRuntime/ vmkit/trunk/lib/N3/LLVMRuntime/Makefile - copied unchanged from r56981, vmkit/branches/isolate/lib/N3/LLVMRuntime/Makefile vmkit/trunk/lib/N3/LLVMRuntime/runtime.ll - copied unchanged from r56981, vmkit/branches/isolate/lib/N3/LLVMRuntime/runtime.ll vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp Modified: vmkit/trunk/include/mvm/Object.h vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/Makefile vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll vmkit/trunk/lib/JnJVM/Makefile vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h 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/JavaInitialise.cpp 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/JavaMetaJIT.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/JavaString.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp vmkit/trunk/lib/JnJVM/VMCore/Makefile vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp vmkit/trunk/lib/JnJVM/VMCore/Reader.h vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp vmkit/trunk/lib/Mvm/Runtime/JIT.cpp vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll vmkit/trunk/lib/N3/Makefile vmkit/trunk/lib/N3/VMCore/CLIJit.cpp vmkit/trunk/lib/N3/VMCore/CLISignature.cpp vmkit/trunk/lib/N3/VMCore/Makefile vmkit/trunk/lib/N3/VMCore/VMCache.cpp vmkit/trunk/lib/N3/VMCore/VMClass.cpp vmkit/trunk/lib/N3/VMCore/VMClass.h vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp vmkit/trunk/tools/jnjvm/Makefile vmkit/trunk/tools/vmkit/Makefile Modified: vmkit/trunk/include/mvm/Object.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Object.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Object.h (original) +++ vmkit/trunk/include/mvm/Object.h Thu Oct 2 18:28:36 2008 @@ -23,6 +23,7 @@ #define VT_TRACER_OFFSET 2 #define VT_PRINT_OFFSET 3 #define VT_HASHCODE_OFFSET 4 +#define VT_NB_FUNCS 5 #define VT_SIZE 5 * sizeof(void*) Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Thu Oct 2 18:28:36 2008 @@ -44,8 +44,10 @@ #endif jclass Cl) { - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, true); - if (cl->lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, false)) + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, true); + UserClass* methodCl = 0; + if (cl->lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, + false, methodCl)) return true; else return false; @@ -57,8 +59,9 @@ jclass clazz, #endif jobject Field, jobject obj, jboolean val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualInt8Field((JavaObject*)obj, (uint8)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setInt8Field((JavaObject*)obj, (uint8)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative( @@ -67,8 +70,9 @@ jclass clazz, #endif jobject Field, jobject obj, jbyte val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualInt8Field((JavaObject*)obj, (uint8)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setInt8Field((JavaObject*)obj, (uint8)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative( @@ -77,8 +81,9 @@ jclass clazz, #endif jobject Field, jobject obj, jchar val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualInt16Field((JavaObject*)obj, (uint16)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setInt16Field((JavaObject*)obj, (uint16)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative( @@ -87,8 +92,9 @@ jclass clazz, #endif jobject Field, jobject obj, jshort val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualInt16Field((JavaObject*)obj, (sint16)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setInt16Field((JavaObject*)obj, (sint16)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative( @@ -97,8 +103,9 @@ jclass clazz, #endif jobject Field, jobject obj, jint val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualInt32Field((JavaObject*)obj, (sint32)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setInt32Field((JavaObject*)obj, (sint32)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative( @@ -107,8 +114,9 @@ jclass clazz, #endif jobject Field, jobject obj, jlong val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualLongField((JavaObject*)obj, (sint64)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setLongField((JavaObject*)obj, (sint64)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative( @@ -117,8 +125,9 @@ jclass clazz, #endif jobject Field, jobject obj, jfloat val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualFloatField((JavaObject*)obj, (float)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setFloatField((JavaObject*)obj, (float)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative( @@ -127,8 +136,9 @@ jclass clazz, #endif jobject Field, jobject obj, jdouble val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualDoubleField((JavaObject*)obj, (double)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setDoubleField((JavaObject*)obj, (double)val); } JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative( @@ -137,8 +147,9 @@ jclass clazz, #endif jobject Field, jobject obj, jobject val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - field->setVirtualObjectField((JavaObject*)obj, (JavaObject*)val); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + field->setObjectField((JavaObject*)obj, (JavaObject*)val); } JNIEXPORT jobject JNICALL Java_java_io_VMObjectInputStream_allocateObject( @@ -148,10 +159,10 @@ #endif jclass target, jclass constr, jobject cons) { Jnjvm* vm = JavaThread::get()->isolate; - Class* cl = (Class*)NativeUtil::resolvedImplClass(target, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(target, true); JavaObject* res = cl->doNew(vm); - JavaMethod* meth = (JavaMethod*)(Classpath::constructorSlot->getVirtualInt32Field((JavaObject*)cons)); - meth->invokeIntSpecial(vm, res); + JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); + meth->invokeIntSpecial(vm, cl, res); return (jobject)res; } @@ -165,11 +176,11 @@ jclass arrayType, jint arrayLength) { Jnjvm* vm = JavaThread::get()->isolate; - CommonClass* base = NativeUtil::resolvedImplClass(arrayType, true); + UserCommonClass* base = NativeUtil::resolvedImplClass(arrayType, true); JnjvmClassLoader* loader = base->classLoader; - const UTF8* name = base->name; - const UTF8* arrayName = AssessorDesc::constructArrayName(loader, 0, 1, name); - ClassArray* array = loader->constructArray(arrayName); + const UTF8* name = base->getName(); + const UTF8* arrayName = loader->constructArrayName(1, name); + UserClassArray* array = loader->constructArray(arrayName, base); ArrayObject* res = ArrayObject::acons(arrayLength, array, &(vm->allocator)); return (jobject) res; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc Thu Oct 2 18:28:36 2008 @@ -32,8 +32,16 @@ JNIEnv *env, #endif jobject cons) { - JavaMethod* meth = (JavaMethod*)(Classpath::constructorSlot->getVirtualInt32Field((JavaObject*)cons)); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->constructorClass->getInt32Field((JavaObject*)cons); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + JnjvmClassLoader* loader = cl->classLoader; +#else JnjvmClassLoader* loader = meth->classDef->classLoader; +#endif + return (jobject)(NativeUtil::getParameterTypes(loader, meth)); } @@ -42,7 +50,8 @@ JNIEnv *env, #endif jobject cons) { - JavaMethod* meth = (JavaMethod*)(Classpath::constructorSlot->getVirtualInt32Field((JavaObject*)cons)); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); return meth->access; } @@ -64,10 +73,10 @@ void* _buf = (void*)buf; sint32 index = 0; if (nbArgs == size) { - CommonClass* _cl = NativeUtil::resolvedImplClass(Clazz, false); - if (!_cl->isArray) { - Class* cl = (Class*)_cl; - vm->initialiseClass(cl); + UserCommonClass* _cl = NativeUtil::resolvedImplClass(Clazz, false); + if (!_cl->isArray()) { + UserClass* cl = (UserClass*)_cl; + cl->initialiseClass(vm); JavaObject* res = cl->doNew(vm); JavaObject** ptr = (JavaObject**)(void*)(args->elements); @@ -78,14 +87,14 @@ JavaObject* excp = 0; try { - meth->invokeIntSpecialBuf(vm, res, _buf); + meth->invokeIntSpecialBuf(vm, cl, res, _buf); }catch(...) { excp = JavaThread::getJavaException(); JavaThread::clearException(); } if (excp) { - if (excp->classOf->isAssignableFrom(Classpath::newException)) { - JavaThread::get()->isolate->invocationTargetException(excp); + if (excp->classOf->isAssignableFrom(vm->upcalls->newException)) { + vm->invocationTargetException(excp); } else { JavaThread::throwException(excp); } @@ -104,8 +113,17 @@ #endif jobject cons) { verifyNull(cons); - JavaMethod* meth = (JavaMethod*)Classpath::constructorSlot->getVirtualInt32Field((JavaObject*)cons); - return (jobjectArray)NativeUtil::getExceptionTypes(meth); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)cons); + cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); +#else + cl = meth->classDef; +#endif + + return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc Thu Oct 2 18:28:36 2008 @@ -30,8 +30,9 @@ #ifdef NATIVE_JNI JNIEnv *env, #endif - jobject Meth) { - JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)Meth); + jobject Meth) { + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); return meth->access; } @@ -40,8 +41,15 @@ JNIEnv *env, #endif jobject Meth) { - JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)Meth); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + JnjvmClassLoader* loader = cl->classLoader; +#else JnjvmClassLoader* loader = meth->classDef->classLoader; +#endif return (jclass)NativeUtil::getClassType(loader, meth->getSignature()->ret); } @@ -52,8 +60,15 @@ #endif jobject Meth) { - JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)Meth); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + JnjvmClassLoader* loader = cl->classLoader; +#else JnjvmClassLoader* loader = meth->classDef->classLoader; +#endif return (jobject)(NativeUtil::getParameterTypes(loader, meth)); } @@ -74,17 +89,25 @@ void* _buf = (void*)buf; sint32 index = 0; if (nbArgs == size) { - CommonClass* _cl = NativeUtil::resolvedImplClass(Cl, false); - Class* cl = (Class*)_cl; + UserCommonClass* _cl = NativeUtil::resolvedImplClass(Cl, false); + UserClass* cl = (UserClass*)_cl; if (isVirtual(meth->access)) { verifyNull(obj); - if (!(obj->classOf->isAssignableFrom(meth->classDef))) { - vm->illegalArgumentExceptionForMethod(meth, meth->classDef, obj->classOf); + if (!(obj->classOf->isAssignableFrom(cl))) { + vm->illegalArgumentExceptionForMethod(meth, cl, obj->classOf); + } +#ifdef MULTIPLE_VM + if (isInterface(cl->classDef->access)) { + cl = obj->classOf->lookupClassFromMethod(meth); + } else { + jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); + cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); } +#endif } else { - vm->initialiseClass(cl); + cl->initialiseClass(vm); } JavaObject** ptr = (JavaObject**)(void*)(args->elements); @@ -98,13 +121,13 @@ #define RUN_METH(TYPE) \ try{ \ if (isVirtual(meth->access)) { \ - if (isPublic(meth->access)) { \ - val = meth->invoke##TYPE##VirtualBuf(vm, obj, _buf); \ + if (isPublic(meth->access) && !isFinal(meth->access) && !isFinal(meth->classDef->access)) { \ + val = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, _buf); \ } else { \ - val = meth->invoke##TYPE##SpecialBuf(vm, obj, _buf); \ + val = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, _buf); \ } \ } else { \ - val = meth->invoke##TYPE##StaticBuf(vm, _buf); \ + val = meth->invoke##TYPE##StaticBuf(vm, cl, _buf); \ } \ }catch(...) { \ exc = JavaThread::getJavaException(); \ @@ -113,7 +136,7 @@ } \ \ if (exc) { \ - if (exc->classOf->isAssignableFrom(Classpath::newException)) { \ + if (exc->classOf->isAssignableFrom(vm->upcalls->newException)) { \ JavaThread::get()->isolate->invocationTargetException(exc); \ } else { \ JavaThread::throwException(exc); \ @@ -121,58 +144,59 @@ } \ JavaObject* res = 0; - const AssessorDesc* retType = meth->getSignature()->ret->funcs; - if (retType == AssessorDesc::dVoid) { - res = 0; - uint32 val = 0; - RUN_METH(Int); - } else if (retType == AssessorDesc::dBool) { - uint32 val = 0; - RUN_METH(Int); - res = Classpath::boolClass->doNew(vm); - Classpath::boolValue->setVirtualInt8Field(res, val); - } else if (retType == AssessorDesc::dByte) { - uint32 val = 0; - RUN_METH(Int); - res = Classpath::byteClass->doNew(vm); - Classpath::byteValue->setVirtualInt8Field(res, val); - } else if (retType == AssessorDesc::dChar) { - uint32 val = 0; - RUN_METH(Int); - res = Classpath::charClass->doNew(vm); - Classpath::charValue->setVirtualInt16Field(res, val); - } else if (retType == AssessorDesc::dShort) { - uint32 val = 0; - RUN_METH(Int); - res = Classpath::shortClass->doNew(vm); - Classpath::shortValue->setVirtualInt16Field(res, val); - } else if (retType == AssessorDesc::dInt) { - uint32 val = 0; - RUN_METH(Int); - res = Classpath::intClass->doNew(vm); - Classpath::intValue->setVirtualInt32Field(res, val); - } else if (retType == AssessorDesc::dLong) { - sint64 val = 0; - RUN_METH(Long); - res = Classpath::longClass->doNew(vm); - Classpath::longValue->setVirtualLongField(res, val); - } else if (retType == AssessorDesc::dFloat) { - float val = 0; - RUN_METH(Float); - res = Classpath::floatClass->doNew(vm); - Classpath::floatValue->setVirtualFloatField(res, val); - } else if (retType == AssessorDesc::dDouble) { - double val = 0; - RUN_METH(Double); - res = Classpath::doubleClass->doNew(vm); - Classpath::doubleValue->setVirtualDoubleField(res, val); - } else if (retType == AssessorDesc::dTab || retType == AssessorDesc::dRef) { + Typedef* retType = meth->getSignature()->ret; + if (retType->isPrimitive()) { + PrimitiveTypedef* prim = (PrimitiveTypedef*)retType; + if (prim->isVoid()) { + res = 0; + uint32 val = 0; + RUN_METH(Int); + } else if (prim->isBool()) { + uint32 val = 0; + RUN_METH(Int); + res = vm->upcalls->boolClass->doNew(vm); + vm->upcalls->boolValue->setInt8Field(res, val); + } else if (prim->isByte()) { + uint32 val = 0; + RUN_METH(Int); + res = vm->upcalls->byteClass->doNew(vm); + vm->upcalls->byteValue->setInt8Field(res, val); + } else if (prim->isChar()) { + uint32 val = 0; + RUN_METH(Int); + res = vm->upcalls->charClass->doNew(vm); + vm->upcalls->charValue->setInt16Field(res, val); + } else if (prim->isShort()) { + uint32 val = 0; + RUN_METH(Int); + res = vm->upcalls->shortClass->doNew(vm); + vm->upcalls->shortValue->setInt16Field(res, val); + } else if (prim->isInt()) { + uint32 val = 0; + RUN_METH(Int); + res = vm->upcalls->intClass->doNew(vm); + vm->upcalls->intValue->setInt32Field(res, val); + } else if (prim->isLong()) { + sint64 val = 0; + RUN_METH(Long); + res = vm->upcalls->longClass->doNew(vm); + vm->upcalls->longValue->setLongField(res, val); + } else if (prim->isFloat()) { + float val = 0; + RUN_METH(Float); + res = vm->upcalls->floatClass->doNew(vm); + vm->upcalls->floatValue->setFloatField(res, val); + } else if (prim->isDouble()) { + double val = 0; + RUN_METH(Double); + res = vm->upcalls->doubleClass->doNew(vm); + vm->upcalls->doubleValue->setDoubleField(res, val); + } + } else { JavaObject* val = 0; RUN_METH(JavaObject); res = val; - } else { - vm->unknownError("should not be here"); - } + } return (jobject)res; } vm->illegalArgumentExceptionForMethod(meth, 0, 0); @@ -187,8 +211,16 @@ #endif jobject _meth) { verifyNull(_meth); - JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)_meth); - return (jobjectArray)NativeUtil::getExceptionTypes(meth); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)_meth); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)_meth); + cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); +#else + cl = meth->classDef; +#endif + return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Thu Oct 2 18:28:36 2008 @@ -35,10 +35,11 @@ #endif jobject klass) { - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)klass); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)klass); - return cl->isArray; + return cl->isArray(); } @@ -52,17 +53,17 @@ jboolean clinit, jobject loader) { - - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader); - CommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, - true, false); + Jnjvm* vm = JavaThread::get()->isolate; + JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); + UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, + true, false); if (cl != 0) { if (clinit) { - JavaThread::get()->isolate->initialiseClass(cl); + cl->initialiseClass(vm); } - return (jclass)(cl->getClassDelegatee()); + return (jclass)(cl->getClassDelegatee(vm)); } else { - JavaThread::get()->isolate->classNotFoundException((JavaString*)str); + vm->classNotFoundException((JavaString*)str); return 0; } } @@ -76,23 +77,24 @@ jclass Cl, jboolean publicOnly) { - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); Jnjvm* vm = JavaThread::get()->isolate; - if (cl->isArray || isInterface(cl->access)) { - return (jobject)ArrayObject::acons(0, Classpath::constructorArrayClass, &(vm->allocator)); + if (cl->isArray() || cl->isInterface()) { + return (jobject)ArrayObject::acons(0, vm->upcalls->constructorArrayClass, &(vm->allocator)); } else { std::vector res; cl->getDeclaredConstructors(res, publicOnly); - ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::constructorArrayClass, &(vm->allocator)); + ArrayObject* ret = ArrayObject::acons(res.size(), vm->upcalls->constructorArrayClass, &(vm->allocator)); sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { JavaMethod* meth = *i; // TODO: check parameter types - JavaObject* tmp = Classpath::newConstructor->doNew(vm); - Classpath::initConstructor->invokeIntSpecial(vm, tmp, Cl, meth); + UserClass* Cons = vm->upcalls->newConstructor; + JavaObject* tmp = Cons->doNew(vm); + vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, Cl, meth); ret->elements[index] = tmp; } return (jobject)ret; @@ -109,22 +111,23 @@ jboolean publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - if (cl->isArray) { - return (jobject)ArrayObject::acons(0, Classpath::methodArrayClass, &(vm->allocator)); + if (cl->isArray()) { + return (jobject)ArrayObject::acons(0, vm->upcalls->methodArrayClass, &(vm->allocator)); } else { std::vector res; cl->getDeclaredMethods(res, publicOnly); - ArrayObject* ret = ArrayObject::acons(res.size(), Classpath::methodArrayClass, &(vm->allocator)); + ArrayObject* ret = ArrayObject::acons(res.size(), vm->upcalls->methodArrayClass, &(vm->allocator)); sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { JavaMethod* meth = *i; // TODO: check parameter types - JavaObject* tmp = Classpath::newMethod->doNew(vm); - Classpath::initMethod->invokeIntSpecial(vm, tmp, Cl, + UserClass* Meth = vm->upcalls->newMethod; + JavaObject* tmp = Meth->doNew(vm); + vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, vm->UTF8ToStr(meth->name), meth); ret->elements[index] = tmp; } @@ -140,8 +143,8 @@ jclass Cl, jboolean ignore) { - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - return cl->access; + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + return cl->getAccess(); } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName( @@ -151,10 +154,10 @@ #endif jobject Cl) { Jnjvm* vm = JavaThread::get()->isolate; - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl); + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - const UTF8* iname = cl->name; + const UTF8* iname = cl->getName(); const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, iname->size); return (jobject)(vm->UTF8ToStr(res)); @@ -166,10 +169,11 @@ jclass clazz, #endif jclass Cl) { - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - return cl->isPrimitive; + return cl->isPrimitive(); } JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface( @@ -178,9 +182,9 @@ jclass clazz, #endif jclass Cl) { - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - return isInterface(cl->access); + return cl->isInterface(); } JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType( @@ -189,12 +193,13 @@ jclass clazz, #endif jclass Cl) { - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - if (cl->isArray) { - CommonClass* bc = ((ClassArray*)cl)->baseClass(); - return (jclass)(bc->getClassDelegatee()); + if (cl->isArray()) { + UserCommonClass* bc = ((UserClassArray*)cl)->baseClass(); + return (jclass)(bc->getClassDelegatee(vm)); } else { return 0; } @@ -206,8 +211,9 @@ jclass clazz, #endif jclass Cl) { - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); return (jobject)cl->classLoader->getJavaClassLoader(); } @@ -217,10 +223,11 @@ jclass clazz, #endif jclass Cl1, jclass Cl2) { - CommonClass* cl1 = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl1); - CommonClass* cl2 = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl2); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl1 = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl1); + UserCommonClass* cl2 = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl2); cl2->resolveClass(); return cl2->isAssignableFrom(cl1); @@ -233,13 +240,14 @@ jclass clazz, #endif jclass Cl) { - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl); - if (isInterface(cl->access)) + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + if (cl->isInterface()) return 0; else { cl->resolveClass(); - if (cl->super) return (jobject)JavaThread::get()->isolate->getClassDelegatee(cl->super); + if (cl->getSuper()) return (jobject)cl->getSuper()->getClassDelegatee(vm); else return 0; } } @@ -250,8 +258,9 @@ jclass clazz, #endif jclass Cl, jobject obj) { - CommonClass* cl = - (CommonClass*)Classpath::vmdataClass->getVirtualObjectField((JavaObject*)Cl); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); return ((JavaObject*)obj)->instanceOf(cl); } @@ -262,23 +271,24 @@ #endif jclass Cl, jboolean publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); - if (cl->isArray) { - return (jobject)ArrayObject::acons(0, Classpath::fieldArrayClass, &(vm->allocator)); + if (!cl) { + return (jobject)ArrayObject::acons(0, vm->upcalls->fieldArrayClass, &(vm->allocator)); } else { std::vector res; cl->getDeclaredFields(res, publicOnly); ArrayObject* ret = ArrayObject::acons(res.size(), - Classpath::fieldArrayClass, &(vm->allocator)); + vm->upcalls->fieldArrayClass, &(vm->allocator)); sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { JavaField* field = *i; // TODO: check parameter types - JavaObject* tmp = Classpath::newField->doNew(vm); - Classpath::initField->invokeIntSpecial(vm, tmp, Cl, + UserClass* Field = vm->upcalls->newField; + JavaObject* tmp = Field->doNew(vm); + vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, vm->UTF8ToStr(field->name), field); ret->elements[index] = tmp; } @@ -293,14 +303,14 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - CommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - std::vector & interfaces = cl->interfaces; - ArrayObject* ret = ArrayObject::acons(interfaces.size(), Classpath::classArrayClass, &(vm->allocator)); + UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + std::vector * interfaces = cl->getInterfaces(); + ArrayObject* ret = ArrayObject::acons(interfaces->size(), vm->upcalls->classArrayClass, &(vm->allocator)); sint32 index = 0; - for (std::vector::iterator i = interfaces.begin(), e = interfaces.end(); + for (std::vector::iterator i = interfaces->begin(), e = interfaces->end(); i != e; ++i, ++index) { - Class* klass = *i; - ret->elements[index] = vm->getClassDelegatee(klass); + UserClass* klass = *i; + ret->elements[index] = klass->getClassDelegatee(vm); } return (jobject)ret; } @@ -313,14 +323,16 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - Class* cl = (Class*)NativeUtil::resolvedImplClass(Cl, false); - cl->resolveInnerOuterClasses(); - Class* outer = cl->getOuterClass(); - if (outer) { - return (jclass)vm->getClassDelegatee(outer); - } else { - return 0; + UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + if (cl) { + cl->resolveInnerOuterClasses(); + UserClass* outer = cl->getOuterClass(); + if (outer) { + return (jclass)outer->getClassDelegatee(vm); + } } + + return 0; } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses( @@ -330,17 +342,21 @@ #endif jclass Cl, bool publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - Class* cl = (Class*)NativeUtil::resolvedImplClass(Cl, false); - cl->resolveInnerOuterClasses(); - std::vector* innerClasses = cl->getInnerClasses(); - ArrayObject* res = ArrayObject::acons(innerClasses->size(), Classpath::constructorArrayClass, &(vm->allocator)); - uint32 index = 0; - for (std::vector::iterator i = innerClasses->begin(), - e = innerClasses->end(); i!= e; i++) { - res->elements[index++] = vm->getClassDelegatee(*i); + UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + if (cl) { + cl->resolveInnerOuterClasses(); + std::vector* innerClasses = cl->getInnerClasses(); + ArrayObject* res = ArrayObject::acons(innerClasses->size(), vm->upcalls->constructorArrayClass, &(vm->allocator)); + uint32 index = 0; + for (std::vector::iterator i = innerClasses->begin(), + e = innerClasses->end(); i!= e; i++) { + res->elements[index++] = (*i)->getClassDelegatee(vm); + } + return (jobject)res; } - return (jobject)res; + return 0; + } @@ -361,7 +377,7 @@ jclass Cl) { // TODO implement me Jnjvm* vm = JavaThread::get()->isolate; - ArrayObject* res = ArrayObject::acons(0, Classpath::constructorArrayAnnotation, &(vm->allocator)); + ArrayObject* res = ArrayObject::acons(0, vm->upcalls->constructorArrayAnnotation, &(vm->allocator)); return (jobjectArray)res; } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc Thu Oct 2 18:28:36 2008 @@ -32,12 +32,13 @@ #endif jchar byteId) { - AssessorDesc* ass = AssessorDesc::byteIdToPrimitive(byteId); Jnjvm* vm = JavaThread::get()->isolate; - if (!ass) + UserClassPrimitive* prim = + UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls); + if (!prim) vm->unknownError("unknown byte primitive %c", byteId); - return (jobject)ass->classType->getClassDelegatee(); + return (jobject)prim->getClassDelegatee(vm); } @@ -52,10 +53,10 @@ Jnjvm* vm = JavaThread::get()->isolate; JavaString* name = (JavaString*)_name; const UTF8* utf8 = name->strToUTF8(vm); - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader); - CommonClass* cl = JCL->lookupClass(utf8); + JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); + UserCommonClass* cl = JCL->lookupClass(utf8); - if (cl) return (jclass)(cl->getClassDelegatee()); + if (cl) return (jclass)(cl->getClassDelegatee(vm)); else return 0; } @@ -66,13 +67,14 @@ #endif jobject _str, jboolean doResolve) { + Jnjvm* vm = JavaThread::get()->isolate; JavaString* str = (JavaString*)_str; - JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader; - CommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false); + JnjvmClassLoader* JCL = vm->bootstrapLoader; + UserCommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false); if (cl != 0) { - return (jclass)cl->getClassDelegatee(); + return (jclass)cl->getClassDelegatee(vm); } else { return 0; } @@ -89,12 +91,13 @@ jint off, jint len, jobject pd) { - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader); + Jnjvm* vm = JavaThread::get()->isolate; + JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); JavaString* str = (JavaString*)_str; const UTF8* name = str->value->javaToInternal(JCL->hashUTF8, str->offset, str->count); - Class* cl = JCL->constructClass(name, (ArrayUInt8*)bytes); + UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes); - return (jclass)(cl->getClassDelegatee((JavaObject*)pd)); + return (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd)); } JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass( Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc Thu Oct 2 18:28:36 2008 @@ -19,12 +19,24 @@ extern "C" { + +static UserClass* internalGetClass(Jnjvm* vm, JavaField* field, jobject Field) { +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->fieldClass->getInt32Field((JavaObject*)Field); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); + return cl; +#else + return field->classDef; +#endif +} + JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal( #ifdef NATIVE_JNI JNIEnv *env, #endif jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)obj); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); return field->access; } @@ -33,10 +45,17 @@ JNIEnv *env, #endif jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)obj); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); +#ifdef MULTIPLE_VM + jclass Cl = (jclass)vm->upcalls->fieldClass->getInt32Field((JavaObject*)obj); + UserClass* fieldCl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); + JnjvmClassLoader* loader = fieldCl->classLoader; +#else JnjvmClassLoader* loader = field->classDef->classLoader; - CommonClass* cl = field->getSignature()->assocClass(loader); - return (jclass)cl->getClassDelegatee(); +#endif + UserCommonClass* cl = field->getSignature()->assocClass(loader); + return (jclass)cl->getClassDelegatee(vm); } JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt( @@ -44,32 +63,32 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + const Typedef* type = field->getSignature(); + + JavaObject* Obj = (JavaObject*)obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } - switch (ass->numId) { - case INT_ID : - return isStatic(field->access) ? - (sint32)field->getStaticInt32Field() : - (sint32)field->getVirtualInt32Field((JavaObject*)obj); - case CHAR_ID : - return isStatic(field->access) ? - (uint32)field->getStaticInt16Field() : - (uint32)field->getVirtualInt16Field((JavaObject*)obj); - case BYTE_ID : - return isStatic(field->access) ? - (sint32)field->getStaticInt8Field() : - (sint32)field->getVirtualInt8Field((JavaObject*)obj); - case SHORT_ID : - return isStatic(field->access) ? - (sint32)field->getStaticInt16Field() : - (sint32)field->getVirtualInt16Field((JavaObject*)obj); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (type->isPrimitive()) { + 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); } + + JavaThread::get()->isolate->illegalArgumentException(""); return 0; } @@ -79,36 +98,34 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case INT_ID : - return isStatic(field->access) ? - (sint64)field->getStaticInt32Field() : - (sint64)field->getVirtualInt32Field((JavaObject*)obj); - case CHAR_ID : - return isStatic(field->access) ? - (uint64)field->getStaticInt16Field() : - (uint64)field->getVirtualInt16Field((JavaObject*)obj); - case BYTE_ID : - return isStatic(field->access) ? - (sint64)field->getStaticInt8Field() : - (sint64)field->getVirtualInt8Field((JavaObject*)obj); - case SHORT_ID : - return isStatic(field->access) ? - (sint64)field->getStaticInt16Field() : - (sint64)field->getVirtualInt16Field((JavaObject*)obj); - case LONG_ID : - return isStatic(field->access) ? - (sint64)field->getStaticLongField() : - (sint64)field->getVirtualLongField((JavaObject*)obj); - default: - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + 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); } + + JavaThread::get()->isolate->illegalArgumentException(""); return 0; } @@ -117,20 +134,25 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + + JavaObject* Obj = (JavaObject*)obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } - switch (ass->numId) { - case BOOL_ID : - return isStatic(field->access) ? - (uint8)field->getStaticInt8Field() : - (uint8)field->getVirtualInt8Field((JavaObject*)obj); - default: - JavaThread::get()->isolate->illegalArgumentException(""); + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isBool()) + return (uint8)field->getInt8Field(Obj); } + + JavaThread::get()->isolate->illegalArgumentException(""); return 0; @@ -141,40 +163,34 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case BYTE_ID : - return isStatic(field->access) ? - (jfloat)field->getStaticInt8Field() : - (jfloat)field->getVirtualInt8Field((JavaObject*)obj); - case INT_ID : - return isStatic(field->access) ? - (jfloat)field->getStaticInt32Field() : - (jfloat)field->getVirtualInt32Field((JavaObject*)obj); - case SHORT_ID : - return isStatic(field->access) ? - (jfloat)field->getStaticInt16Field() : - (jfloat)field->getVirtualInt16Field((JavaObject*)obj); - case LONG_ID : - return isStatic(field->access) ? - (jfloat)field->getStaticLongField() : - (jfloat)field->getVirtualLongField((JavaObject*)obj); - case CHAR_ID : - return isStatic(field->access) ? - (jfloat)(uint32)field->getStaticInt16Field() : - (jfloat)(uint32)field->getVirtualInt16Field((JavaObject*)obj); - case FLOAT_ID : - return isStatic(field->access) ? - (jfloat)field->getStaticFloatField() : - (jfloat)field->getVirtualFloatField((JavaObject*)obj); - default: - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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()) + return (jfloat)(uint32)field->getInt16Field((JavaObject*)obj); + if (prim->isFloat()) + return (jfloat)field->getFloatField((JavaObject*)obj); } + JavaThread::get()->isolate->illegalArgumentException(""); return 0.0; } @@ -183,20 +199,24 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + + JavaObject* Obj = (JavaObject*)obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } - switch (ass->numId) { - case BYTE_ID : - return isStatic(field->access) ? - (sint8)field->getStaticInt8Field() : - (sint8)field->getVirtualInt8Field((JavaObject*)obj); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isByte()) + return (sint8)field->getInt8Field(Obj); } + JavaThread::get()->isolate->illegalArgumentException(""); return 0; } @@ -206,20 +226,24 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + + JavaObject* Obj = (JavaObject*)obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } - switch (ass->numId) { - case CHAR_ID : - return isStatic(field->access) ? - (uint16)field->getStaticInt16Field() : - (uint16)field->getVirtualInt16Field((JavaObject*)obj); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isChar()) + return (uint16)field->getInt16Field((JavaObject*)obj); } + JavaThread::get()->isolate->illegalArgumentException(""); return 0; @@ -230,24 +254,26 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + + JavaObject* Obj = (JavaObject*)obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } - switch (ass->numId) { - case SHORT_ID : - return isStatic(field->access) ? - (sint16)field->getStaticInt16Field() : - (sint16)field->getVirtualInt16Field((JavaObject*)obj); - case BYTE_ID : - return isStatic(field->access) ? - (sint16)field->getStaticInt8Field() : - (sint16)field->getVirtualInt8Field((JavaObject*)obj); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isShort()) + return (sint16)field->getInt16Field(Obj); + if (prim->isByte()) + return (sint16)field->getInt8Field(Obj); } + JavaThread::get()->isolate->illegalArgumentException(""); return 0; } @@ -257,44 +283,36 @@ JNIEnv *env, #endif jobject Field, jobject obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case BYTE_ID : - return isStatic(field->access) ? - (jdouble)(sint64)field->getStaticInt8Field() : - (jdouble)(sint64)field->getVirtualInt8Field((JavaObject*)obj); - case INT_ID : - return isStatic(field->access) ? - (jdouble)(sint64)field->getStaticInt32Field() : - (jdouble)(sint64)field->getVirtualInt32Field((JavaObject*)obj); - case SHORT_ID : - return isStatic(field->access) ? - (jdouble)(sint64)field->getStaticInt16Field() : - (jdouble)(sint64)field->getVirtualInt16Field((JavaObject*)obj); - case LONG_ID : - return isStatic(field->access) ? - (jdouble)(sint64)field->getStaticLongField() : - (jdouble)(sint64)field->getVirtualLongField((JavaObject*)obj); - case CHAR_ID : - return isStatic(field->access) ? - (jdouble)(uint64)field->getStaticInt16Field() : - (jdouble)(uint64)field->getVirtualInt16Field((JavaObject*)obj); - case FLOAT_ID : - return isStatic(field->access) ? - (jdouble)field->getStaticFloatField() : - (jdouble)field->getVirtualFloatField((JavaObject*)obj); - case DOUBLE_ID : - return isStatic(field->access) ? - (jdouble)field->getStaticDoubleField() : - (jdouble)field->getVirtualDoubleField((JavaObject*)obj); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); return 0.0; } @@ -303,89 +321,63 @@ JNIEnv *env, #endif jobject Field, jobject _obj) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - Typedef* type = field->getSignature(); - const AssessorDesc* ass = type->funcs; - JavaObject* obj = (JavaObject*)_obj; Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + + JavaObject* Obj = (JavaObject*)_obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } JavaObject* res = 0; - switch (ass->numId) { - case BOOL_ID : { - uint8 val = (isStatic(field->access) ? - field->getStaticInt8Field() : - field->getVirtualInt8Field(obj)); - res = Classpath::boolClass->doNew(vm); - Classpath::boolValue->setVirtualInt8Field(res, val); - break; + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isBool()) { + uint8 val = field->getInt8Field(Obj); + res = vm->upcalls->boolClass->doNew(vm); + vm->upcalls->boolValue->setInt8Field(res, val); } - case BYTE_ID : { - sint8 val = (isStatic(field->access) ? - field->getStaticInt8Field() : - field->getVirtualInt8Field(obj)); - res = Classpath::byteClass->doNew(vm); - Classpath::byteValue->setVirtualInt8Field(res, val); - break; + else if (prim->isByte()) { + sint8 val = field->getInt8Field(Obj); + res = vm->upcalls->byteClass->doNew(vm); + vm->upcalls->byteValue->setInt8Field(res, val); } - case CHAR_ID : { - uint16 val = (isStatic(field->access) ? - field->getStaticInt16Field() : - field->getVirtualInt16Field(obj)); - res = Classpath::charClass->doNew(vm); - Classpath::charValue->setVirtualInt16Field(res, val); - break; + else if (prim->isChar()) { + uint16 val = field->getInt16Field(Obj); + res = vm->upcalls->charClass->doNew(vm); + vm->upcalls->charValue->setInt16Field(res, val); } - case SHORT_ID : { - sint16 val = (isStatic(field->access) ? - field->getStaticInt16Field() : - field->getVirtualInt16Field(obj)); - res = Classpath::shortClass->doNew(vm); - Classpath::shortValue->setVirtualInt16Field(res, val); - break; + else if (prim->isShort()) { + sint16 val = field->getInt16Field(Obj); + res = vm->upcalls->shortClass->doNew(vm); + vm->upcalls->shortValue->setInt16Field(res, val); } - case INT_ID : { - sint32 val = (isStatic(field->access) ? - field->getStaticInt32Field() : - field->getVirtualInt32Field(obj)); - res = Classpath::intClass->doNew(vm); - Classpath::intValue->setVirtualInt32Field(res, val); - break; + else if (prim->isInt()) { + sint32 val = field->getInt32Field(Obj); + res = vm->upcalls->intClass->doNew(vm); + vm->upcalls->intValue->setInt32Field(res, val); } - case LONG_ID : { - sint64 val = (isStatic(field->access) ? - field->getStaticLongField() : - field->getVirtualLongField(obj)); - res = Classpath::longClass->doNew(vm); - Classpath::longValue->setVirtualLongField(res, val); - break; + else if (prim->isLong()) { + sint64 val = field->getLongField(Obj); + res = vm->upcalls->longClass->doNew(vm); + vm->upcalls->longValue->setLongField(res, val); } - case FLOAT_ID : { - float val = (isStatic(field->access) ? - field->getStaticFloatField() : - field->getVirtualFloatField(obj)); - res = Classpath::floatClass->doNew(vm); - Classpath::floatValue->setVirtualFloatField(res, val); - break; + else if (prim->isFloat()) { + float val = field->getFloatField(Obj); + res = vm->upcalls->floatClass->doNew(vm); + vm->upcalls->floatValue->setFloatField(res, val); } - case DOUBLE_ID : { - double val = (isStatic(field->access) ? - field->getStaticDoubleField() : - field->getVirtualDoubleField(obj)); - res = Classpath::doubleClass->doNew(vm); - Classpath::doubleValue->setVirtualDoubleField(res, val); - break; + else if (prim->isDouble()) { + double val = field->getDoubleField(Obj); + res = vm->upcalls->doubleClass->doNew(vm); + vm->upcalls->doubleValue->setDoubleField(res, val); } - case OBJECT_ID : - case ARRAY_ID : - res = (isStatic(field->access) ? - field->getStaticObjectField() : - field->getVirtualObjectField(obj)); - break; - default: - JavaThread::get()->isolate->unknownError("should not be here"); + } else { + res = field->getObjectField(Obj); } return (jobject)res; } @@ -395,56 +387,42 @@ JNIEnv *env, #endif jobject Field, jobject obj, jobject val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); void** buf = (void**)alloca(sizeof(uint64)); void* _buf = (void*)buf; NativeUtil::decapsulePrimitive(JavaThread::get()->isolate, buf, (JavaObject*)val, field->getSignature()); - const AssessorDesc* ass = field->getSignature()->funcs; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case BOOL_ID : - return isStatic(field->access) ? - field->setStaticInt8Field(((uint8*)_buf)[0]) : - field->setVirtualInt8Field((JavaObject*)obj, ((uint8*)_buf)[0]); - case BYTE_ID : - return isStatic(field->access) ? - field->setStaticInt8Field(((sint8*)_buf)[0]) : - field->setVirtualInt8Field((JavaObject*)obj, ((sint8*)_buf)[0]); - case CHAR_ID : - return isStatic(field->access) ? - field->setStaticInt16Field(((uint16*)_buf)[0]) : - field->setVirtualInt16Field((JavaObject*)obj, ((uint16*)_buf)[0]); - case SHORT_ID : - return isStatic(field->access) ? - field->setStaticInt16Field(((sint16*)_buf)[0]) : - field->setVirtualInt16Field((JavaObject*)obj, ((sint16*)_buf)[0]); - case INT_ID : - return isStatic(field->access) ? - field->setStaticInt32Field(((sint32*)_buf)[0]) : - field->setVirtualInt32Field((JavaObject*)obj, ((sint32*)_buf)[0]); - case LONG_ID : - return isStatic(field->access) ? - field->setStaticLongField(((sint64*)_buf)[0]) : - field->setVirtualLongField((JavaObject*)obj, ((sint64*)_buf)[0]); - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField(((float*)_buf)[0]) : - field->setVirtualFloatField((JavaObject*)obj, ((float*)_buf)[0]); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField(((double*)_buf)[0]) : - field->setVirtualDoubleField((JavaObject*)obj, ((double*)_buf)[0]); - case ARRAY_ID : - case OBJECT_ID : - return isStatic(field->access) ? - field->setStaticObjectField(((JavaObject**)_buf)[0]) : - field->setVirtualObjectField((JavaObject*)obj, ((JavaObject**)_buf)[0]); - default : - JavaThread::get()->isolate->unknownError("should not be here"); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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]); + } else { + return field->setObjectField(Obj, ((JavaObject**)_buf)[0]); } } @@ -453,20 +431,23 @@ JNIEnv *env, #endif jobject Field, jobject obj, jboolean val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaObject* Obj = (JavaObject*)obj; - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } - switch (ass->numId) { - case BOOL_ID : - return isStatic(field->access) ? - field->setStaticInt8Field((uint8)val) : - field->setVirtualInt8Field((JavaObject*)obj, (uint8)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isBool()) + return field->setInt8Field(Obj, (uint8)val); } + JavaThread::get()->isolate->illegalArgumentException(""); } @@ -474,42 +455,34 @@ #ifdef NATIVE_JNI JNIEnv *env, #endif -jobject Field, jobject _obj, jbyte val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; - JavaObject* obj = (JavaObject*)_obj; - - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); - - switch (ass->numId) { - case BYTE_ID : - return isStatic(field->access) ? - field->setStaticInt8Field((sint8)val) : - field->setVirtualInt8Field((JavaObject*)obj, (sint8)val); - case SHORT_ID : - return isStatic(field->access) ? - field->setStaticInt16Field((sint16)val) : - field->setVirtualInt16Field((JavaObject*)obj, (sint16)val); - case INT_ID : - return isStatic(field->access) ? - field->setStaticInt32Field((sint32)val) : - field->setVirtualInt32Field((JavaObject*)obj, (sint32)val); - case LONG_ID : - return isStatic(field->access) ? - field->setStaticLongField((sint64)val) : - field->setVirtualLongField((JavaObject*)obj, (sint64)val); - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField((float)val) : - field->setVirtualFloatField((JavaObject*)obj, (float)val); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); +jobject Field, jobject obj, jbyte val) { + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaObject* Obj = (JavaObject*)obj; + + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar( @@ -517,36 +490,32 @@ JNIEnv *env, #endif jobject Field, jobject obj, jchar val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case CHAR_ID : - return isStatic(field->access) ? - field->setStaticInt16Field((uint16)val) : - field->setVirtualDoubleField((JavaObject*)obj, (uint16)val); - case INT_ID : - return isStatic(field->access) ? - field->setStaticInt32Field((uint32)val) : - field->setVirtualInt32Field((JavaObject*)obj, (uint32)val); - case LONG_ID : - return isStatic(field->access) ? - field->setStaticLongField((uint64)val) : - field->setVirtualLongField((JavaObject*)obj, (uint64)val); - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField((float)(uint32)val) : - field->setVirtualFloatField((JavaObject*)obj, (float)(uint32)val); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)(uint64)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)(uint64)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort( @@ -554,36 +523,32 @@ JNIEnv *env, #endif jobject Field, jobject obj, jshort val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case SHORT_ID : - return isStatic(field->access) ? - field->setStaticInt16Field((sint16)val) : - field->setVirtualInt16Field((JavaObject*)obj, (sint16)val); - case INT_ID : - return isStatic(field->access) ? - field->setStaticInt32Field((sint32)val) : - field->setVirtualInt32Field((JavaObject*)obj, (sint32)val); - case LONG_ID : - return isStatic(field->access) ? - field->setStaticLongField((sint64)val) : - field->setVirtualLongField((JavaObject*)obj, (sint64)val); - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField((float)val) : - field->setVirtualFloatField((JavaObject*)obj, (float)val); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt( @@ -591,32 +556,29 @@ JNIEnv *env, #endif jobject Field, jobject obj, jint val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; - - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case INT_ID : - return isStatic(field->access) ? - field->setStaticInt32Field((sint32)val) : - field->setVirtualInt32Field((JavaObject*)obj, (sint32)val); - case LONG_ID : - return isStatic(field->access) ? - field->setStaticLongField((sint64)val) : - field->setVirtualLongField((JavaObject*)obj, (sint64)val); - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField((float)val) : - field->setVirtualFloatField((JavaObject*)obj, (float)val); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong( @@ -624,28 +586,27 @@ JNIEnv *env, #endif jobject Field, jobject obj, jlong val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; - - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case LONG_ID : - return isStatic(field->access) ? - field->setStaticLongField((sint64)val) : - field->setVirtualLongField((JavaObject*)obj, (sint64)val); - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField((float)val) : - field->setVirtualFloatField((JavaObject*)obj, (float)val); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat( @@ -653,24 +614,25 @@ JNIEnv *env, #endif jobject Field, jobject obj, jfloat val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; - - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaObject* Obj = (JavaObject*)obj; - switch (ass->numId) { - case FLOAT_ID : - return isStatic(field->access) ? - field->setStaticFloatField((float)val) : - field->setVirtualFloatField((JavaObject*)obj, (float)val); - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + 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); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble( @@ -678,20 +640,23 @@ JNIEnv *env, #endif jobject Field, jobject obj, jdouble val) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); - const AssessorDesc* ass = field->getSignature()->funcs; - - if (isStatic(field->access)) - JavaThread::get()->isolate->initialiseClass(field->classDef); - - switch (ass->numId) { - case DOUBLE_ID : - return isStatic(field->access) ? - field->setStaticDoubleField((double)val) : - field->setVirtualDoubleField((JavaObject*)obj, (double)val); - default : - JavaThread::get()->isolate->illegalArgumentException(""); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaObject* Obj = (JavaObject*)obj; + + if (isStatic(field->access)) { + UserClass* cl = internalGetClass(vm, field, Field); + cl->initialiseClass(vm); + Obj = cl->getStaticInstance(); + } + + const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isDouble()) + return field->setDoubleField(Obj, (double)val); } + JavaThread::get()->isolate->illegalArgumentException(""); } JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset( @@ -700,7 +665,8 @@ #endif JavaObject* Unsafe, JavaObject* Field) { - JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field); + Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); return (jlong)field->ptrOffset; } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc Thu Oct 2 18:28:36 2008 @@ -31,13 +31,13 @@ jobject _src) { JavaObject* src = (JavaObject*)_src; - CommonClass* cl = src->classOf; + UserCommonClass* cl = src->classOf; uint64 size = 0; - if (cl->isArray) { + if (cl->isArray()) { size = sizeof(JavaArray) + ((JavaArray*)src)->size * - ((ClassArray*)cl)->baseClass()->virtualSize; + ((UserClassArray*)cl)->baseClass()->getVirtualSize(); } else { - size = cl->virtualSize; + size = cl->getVirtualSize(); } JavaObject* res = (JavaObject*) JavaThread::get()->isolate->allocator.allocateObject(size, src->getVirtualTable()); @@ -52,8 +52,10 @@ jclass clazz, #endif jobject _obj) { + JavaObject* obj = (JavaObject*)_obj; - return (jobject)(obj->classOf->getClassDelegatee()); + Jnjvm* vm = JavaThread::get()->isolate; + return (jobject)(obj->classOf->getClassDelegatee(vm)); } JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll( Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc Thu Oct 2 18:28:36 2008 @@ -52,7 +52,7 @@ memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, lgPost * sizeof(uint16)); // TODO: find a better place to store the UTF8 - const UTF8* res = JnjvmClassLoader::bootstrapLoader->readerConstructUTF8(elements, size); + const UTF8* res = vm->bootstrapLoader->readerConstructUTF8(elements, size); return (jobject)(vm->UTF8ToStr(res)); @@ -172,4 +172,12 @@ #endif } +JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){ +#ifdef NATIVE_JNI +JNIEnv *env, +jclass clazz, +#endif + return 1; +} } + Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc Thu Oct 2 18:28:36 2008 @@ -28,21 +28,66 @@ extern "C" { -ArrayObject* recGetClassContext(int** stack, uint32 size, uint32 first, uint32 rec) { +#ifdef MULTIPLE_VM +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; +} +#endif + +#ifdef MULTIPLE_VM +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::acons(rec, vm->upcalls->classArrayClass, &(vm->allocator)); + } +} +#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(stack, size, first + 1, rec + 1); - res->elements[rec] = meth->classDef->getClassDelegatee(); + ArrayObject* res = recGetClassContext(vm, stack, size, first + 1, rec + 1); + res->elements[rec] = meth->classDef->getClassDelegatee(vm); return res; } else { - return recGetClassContext(stack, size, first + 1, rec); + return recGetClassContext(vm, stack, size, first + 1, rec); } } else { - Jnjvm* vm = JavaThread::get()->isolate; - return ArrayObject::acons(rec, Classpath::classArrayClass, &(vm->allocator)); + return ArrayObject::acons(rec, vm->upcalls->classArrayClass, &(vm->allocator)); } } +#endif JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassContext( #ifdef NATIVE_JNI @@ -50,21 +95,35 @@ jclass clazz, #endif ) { + Jnjvm* vm = JavaThread::get()->isolate; int* ips[100]; int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 100); +#ifdef MULTIPLE_VM + UserConstantPool* pools[100]; + getPools(pools, 100); +#endif + int i = 0; int first = 0; - CommonClass* cl = Classpath::vmStackWalker; + UserCommonClass* cl = vm->upcalls->vmStackWalker; while (i < real_size) { JavaMethod* meth = JavaJIT::IPToJavaMethod(ips[i++]); +#ifdef MULTIPLE_VM + if (meth && meth->classDef == cl->classDef) { +#else if (meth && meth->classDef == cl) { +#endif first = i; break; } } - return (jobject)recGetClassContext(ips, real_size, first, 0); +#ifdef MULTIPLE_VM + return (jobject)recGetClassContext(vm, ips, real_size, first, 0, pools, 0); +#else + return (jobject)recGetClassContext(vm, ips, real_size, first, 0); +#endif } JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader( @@ -73,14 +132,15 @@ jclass clazz, #endif jclass _Cl) { + Jnjvm* vm = JavaThread::get()->isolate; JavaObject* Cl = (JavaObject*)_Cl; - CommonClass* cl = (CommonClass*)Classpath::vmdataClass->getVirtualObjectField(Cl); + UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl); return (jobject)cl->classLoader->getJavaClassLoader(); } extern "C" JavaObject* getCallingClass() { - Class* cl = JavaJIT::getCallingClass(); - if (cl) return cl->getClassDelegatee(); + UserClass* cl = JavaJIT::getCallingClass(); + if (cl) return cl->getClassDelegatee(JavaThread::get()->isolate); return 0; } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc Thu Oct 2 18:28:36 2008 @@ -40,17 +40,14 @@ verifyNull(src); verifyNull(dst); - if (!(src->classOf->isArray && dst->classOf->isArray)) { + if (!(src->classOf->isArray() && dst->classOf->isArray())) { vm->arrayStoreException(); } - ClassArray* ts = (ClassArray*)src->classOf; - ClassArray* td = (ClassArray*)dst->classOf; - CommonClass* dstType = td->baseClass(); - AssessorDesc* dstFuncs = td->funcs(); - AssessorDesc* srcFuncs = ts->funcs(); - CommonClass* srcPrim = srcFuncs->classType; - CommonClass* dstPrim = dstFuncs->classType; + UserClassArray* ts = (UserClassArray*)src->classOf; + UserClassArray* td = (UserClassArray*)dst->classOf; + UserCommonClass* dstType = td->baseClass(); + UserCommonClass* srcType = ts->baseClass(); if (len > src->size) { vm->indexOutOfBounds(src, len); @@ -66,13 +63,14 @@ vm->indexOutOfBounds(src, sstart); } else if (len < 0) { vm->indexOutOfBounds(src, len); - } else if (srcPrim != dstPrim) { + } else if ((dstType->isPrimitive() || srcType->isPrimitive()) && + srcType != dstType) { vm->arrayStoreException(); } jint i = sstart; bool doThrow = false; - if (srcFuncs->doTrace) { + if (!(dstType->isPrimitive())) { while (i < sstart + len && !doThrow) { JavaObject* cur = ((ArrayObject*)src)->elements[i]; if (cur) { @@ -85,8 +83,10 @@ } } - uint32 size = srcFuncs->nbb; - if (size == 0) size = sizeof(void*); + uint32 size = dstType->isPrimitive() ? + dstType->virtualSize : sizeof(JavaObject*); + + assert(size && "Size zero in a arraycopy"); void* ptrDst = (void*)((int64_t)(dst->elements) + size * dstart); void* ptrSrc = (void*)((int64_t)(src->elements) + size * sstart); memmove(ptrDst, ptrSrc, size * len); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc Thu Oct 2 18:28:36 2008 @@ -28,8 +28,10 @@ static void setProperty(Jnjvm* vm, JavaObject* prop, const char* key, const char* val) { - Classpath::setProperty->invokeIntSpecial(vm, prop, vm->asciizToStr(key), - vm->asciizToStr(val)); + vm->upcalls->setProperty->invokeIntSpecial(vm, (UserClass*)prop->classOf, + prop, + vm->asciizToStr(key), + vm->asciizToStr(val)); } static void setUnameProp(Jnjvm* vm, JavaObject* prop) { @@ -71,7 +73,7 @@ if (!tmp) tmp = ""; setProperty(vm, prop, "java.home", tmp); - JnjvmBootstrapLoader* JCL = JnjvmClassLoader::bootstrapLoader; + JnjvmBootstrapLoader* JCL = vm->bootstrapLoader; setProperty(vm, prop, "java.class.version", "49.0"); setProperty(vm, prop, "java.class.path", vm->classpath); setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc Thu Oct 2 18:28:36 2008 @@ -56,11 +56,11 @@ #else Collector::inject_my_thread(&argc); #endif - CommonClass* vmthClass = vmThread->classOf; - JavaObject* thread = Classpath::assocThread->getVirtualObjectField(vmThread); + UserClass* vmthClass = (UserClass*)vmThread->classOf; Jnjvm* isolate = intern->isolate; + JavaObject* thread = isolate->upcalls->assocThread->getObjectField(vmThread); ThreadSystem* ts = isolate->threadSystem; - bool isDaemon = Classpath::daemon->getVirtualInt8Field(thread); + bool isDaemon = isolate->upcalls->daemon->getInt8Field(thread); intern->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; @@ -77,9 +77,8 @@ vm->numThreads++; vm->lock->unlock(); #endif - JavaMethod* method = vmthClass->lookupMethod(Jnjvm::runName, Jnjvm::clinitType, ACC_VIRTUAL, true); - method->invokeIntSpecial(isolate, vmThread); - + + isolate->upcalls->runVMThread->invokeIntSpecial(isolate, vmthClass, vmThread); if (!isDaemon) { ts->nonDaemonLock->lock(); @@ -107,14 +106,14 @@ JNIEnv *env, #endif jobject _vmThread, sint64 stackSize) { + Jnjvm* vm = JavaThread::get()->isolate; JavaObject* vmThread = (JavaObject*)_vmThread; - JavaObject* javaThread = Classpath::assocThread->getVirtualObjectField(vmThread); + JavaObject* javaThread = vm->upcalls->assocThread->getObjectField(vmThread); assert(javaThread); - Jnjvm* vm = JavaThread::get()->isolate; JavaThread* th = allocator_new(vm->allocator, JavaThread)(); th->initialise(javaThread, vm); - Classpath::vmdataVMThread->setVirtualObjectField(vmThread, (JavaObject*)th); + vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)th); int tid = 0; arg_thread_t* arg = (arg_thread_t*)malloc(sizeof(arg_thread_t)); arg->intern = th; @@ -131,12 +130,13 @@ JNIEnv *env, #endif jobject _vmthread) { + Jnjvm* vm = JavaThread::get()->isolate; JavaObject* vmthread = (JavaObject*)_vmthread; - while (Classpath::vmdataVMThread->getVirtualObjectField(vmthread) == 0) + while (vm->upcalls->vmdataVMThread->getObjectField(vmthread) == 0) mvm::Thread::yield(); - JavaThread* th = (JavaThread*)Classpath::vmdataVMThread->getVirtualObjectField(vmthread); + JavaThread* th = (JavaThread*)vm->upcalls->vmdataVMThread->getObjectField(vmthread); th->lock->lock(); th->interruptFlag = 1; @@ -166,8 +166,9 @@ JNIEnv *env, #endif jobject _vmthread) { + Jnjvm* vm = JavaThread::get()->isolate; JavaObject* vmthread = (JavaObject*)_vmthread; - JavaThread* th = (JavaThread*)Classpath::vmdataVMThread->getVirtualObjectField(vmthread); + JavaThread* th = (JavaThread*)vm->upcalls->vmdataVMThread->getObjectField(vmthread); return (jboolean)th->interruptFlag; } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc Thu Oct 2 18:28:36 2008 @@ -37,16 +37,16 @@ jclass clazz, #endif jobject throwable) { - //int** fp = (int**)__builtin_frame_address(0); Jnjvm* vm = JavaThread::get()->isolate; int** stack = (int**)malloc(sizeof(int*) * 100); int real_size = mvm::jit::getBacktrace((void**)stack, 100); stack[real_size] = 0; - JavaObject* vmThrowable = Classpath::newVMThrowable->doNew(vm); - ((JavaObject**)((uint64)vmThrowable + Classpath::vmDataVMThrowable->ptrOffset))[0] = (JavaObject*)stack; + JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); + ((JavaObject**)((uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset))[0] = (JavaObject*)stack; return (jobject)vmThrowable; } + JavaObject* consStackElement(JavaMethod* meth, int* ip) { Jnjvm* vm = JavaThread::get()->isolate; JavaObject* methodName = vm->UTF8ToStr(meth->name); @@ -64,10 +64,12 @@ bool native = isNative(meth->access); - JavaObject* res = Classpath::newStackTraceElement->doNew(vm); - Classpath::initStackTraceElement->invokeIntSpecial(vm, res, sourceName, - (uint32)ip, className, - methodName, native); + UserClass* newS = vm->upcalls->newStackTraceElement; + JavaObject* res = newS->doNew(vm); + vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res, + sourceName, + (uint32)ip, className, + methodName, native); return res; } @@ -83,7 +85,7 @@ return recGetStackTrace(stack, first + 1, rec); } } else { - return ArrayObject::acons(rec, Classpath::stackTraceArray, &(vm->allocator)); + return ArrayObject::acons(rec, vm->upcalls->stackTraceArray, &(vm->allocator)); } } @@ -92,13 +94,18 @@ JNIEnv *env, #endif jobject vmthrow, jobject throwable) { - int** stack = (int**)Classpath::vmDataVMThrowable->getVirtualObjectField((JavaObject*)vmthrow); + Jnjvm* vm = JavaThread::get()->isolate; + int** stack = (int**)vm->upcalls->vmDataVMThrowable->getObjectField((JavaObject*)vmthrow); uint32 first = 0; sint32 i = 0; while (stack[i] != 0) { JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[i++]); - if (meth && !meth->classDef->subclassOf(Classpath::newThrowable)) { +#ifdef MULTIPLE_VM + if (meth) { +#else + if (meth && !meth->classDef->subclassOf(vm->upcalls->newThrowable)) { +#endif first = i - 1; break; } @@ -109,3 +116,4 @@ } } + Modified: vmkit/trunk/lib/JnJVM/Classpath/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Makefile (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Makefile Thu Oct 2 18:28:36 2008 @@ -9,6 +9,12 @@ LEVEL = ../../.. LIBRARYNAME = Classpath + +include $(LEVEL)/Makefile.config include $(LEVEL)/Makefile.common CXX.Flags += -I../VMCore $(CLASSPATH_FLAGS) + +ifeq ($(ISOLATE_BUILD), 1) + CXX.Flags += -I../Isolate +endif 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=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Thu Oct 2 18:28:36 2008 @@ -5,14 +5,22 @@ ;;; A virtual table is an array of function pointers. %VT = type i32** +;;; The type of a constant pool. Jnjvm will make this into a i8** +%ConstantPool = type i8* + +%Jnjvm = type {%VT, %JavaClass*, [9 x %JavaClass*]} + ;;; The type of internal classes. This is not complete, but we only need ;;; the first fields for now. ;;; Field 1 - The VT of a class C++ object. ;;; Field 2 - The size of instances of this class. ;;; Field 3 - The VT of instances of this class. ;;; Field 4 - The list of super classes of this class. -;;; Field 5 - The depth of the class in its super hierarchy -%JavaClass = type { %VT, i32, %VT ,%JavaClass**, i32} +;;; Field 5 - The depth of the class in its super hierarchy. +;;; Field 6 - The class state (resolved, initialized, ...) +;;; field 7 - The constant pool, only for multi vm environment. +;;; field 8 - The static instance, only for multi vm environment. +%JavaClass = type { %VT, i32, %VT ,%JavaClass**, i32, i32, %ConstantPool*, %JavaObject* } ;;; The root of all Java Objects: a VT, a class and a lock. %JavaObject = type { %VT, %JavaClass*, i32 } @@ -30,13 +38,13 @@ %ArrayUInt32 = type { %JavaObject, i32, [0 x i32] } %ArrayUInt8 = type { %JavaObject, i32, [0 x i8] } -;;; The CacheNode type. The second field is the last called method -%CacheNode = type { i8*, %JavaClass*, %CacheNode*, %Enveloppe* } +;;; The CacheNode type. The second field is the last called method. The +;;; last field is for multi vm environment. +%CacheNode = type { i8*, %JavaClass*, %CacheNode*, %Enveloppe*, %ConstantPool* } ;;; 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*, %ConstantPool*, i8*, i32 } ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;; Constant calls for Jnjvm runtime internal objects field accesses ;;;;;;;;; @@ -94,18 +102,27 @@ ;;; implementation. declare void @forceInitialisationCheck(%JavaClass*) +;;; getConstantPoolAt - Get the value in the constant pool of this class. +;;; This function is removed by Jnjvm after the GVn pass, therefore it does +;;; not have an actual implementation. +declare i8* @getConstantPoolAt(i8* (%JavaClass*, i32, ...)*, %ConstantPool*, + %JavaClass*, i32, ...) readnone + ;;; vtableLookup - Look up the offset in a virtual table of a specific ;;; function. This function takes a class and an index to lookup in the ;;; constant pool and returns and stores it in the constant pool cache. -declare i32 @vtableLookup(%JavaObject*, %JavaClass*, i32) readnone +declare i8* @vtableLookup(%JavaClass*, i32, ...) ;;; newLookup - Look up a specific class. The function takes a class and an ;;; index to lookup in the constant pool and returns and stores it in the ;;; constant pool cache. -declare %JavaClass* @newLookup(%JavaClass*, i32) readnone +declare i8* @classLookup(%JavaClass*, i32, ...) + +;;; virtualFieldLookup - Look up a specific virtual field. +declare i8* @virtualFieldLookup(%JavaClass*, i32, ...) -;;; fieldLookup - Look up a specific field. -declare i8* @fieldLookup(%JavaObject*, %JavaClass*, i32, i32) readnone +;;; staticFieldLookup - Look up a specific static field. +declare i8* @staticFieldLookup(%JavaClass*, i32, ...) ;;; JavaObjectAquire - This function is called when starting a synchronized ;;; block or method. 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=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-isolate.ll Thu Oct 2 18:28:36 2008 @@ -2,9 +2,36 @@ ;;;;;;;;;;;;;;;;;;;;;;;; Isolate specific methods ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; enveloppeLookup - Find the enveloppe for the current user class. +declare i8* @enveloppeLookup(%JavaClass*, i32, ...) -;;; getStaticInstance - Get the static instance of a class. -declare %JavaObject* @getStaticInstance(%JavaClass*, i8*) readnone +;;; stringLookup - Find the isolate-specific string at the given offset in the +;;; constant pool. +declare i8* @stringLookup(%JavaClass*, i32, ...) -;;; runtimeUTF8ToStr - Convert the UTF8 in a string. -declare %JavaObject* @stringLookup(%JavaClass*, i32) +;;; staticCtpLookup - Find the user constant pool at the given offset in the +;;; constant pool. +declare i8* @staticCtpLookup(%JavaClass*, i32, ...) + +;;; specialCtpLookup - Find the user constant pool at the given offset in the +;;; constant pool. +declare %ConstantPool* @specialCtpLookup(%ConstantPool*, i32, %ConstantPool**) + +;;; getCtpCacheNode - Get the constant pool cache of a cache node. This is a +;;; constant call because the cache node never changes. +declare %ConstantPool* @getCtpCacheNode(%CacheNode*) readnone + +;;; getCtpCacheNode - Get the constant pool cache of a class. This is a +;;; constant call because the constant pool never changes. +declare %ConstantPool* @getCtpClass(%JavaClass*) readnone + +;;; getJnjvmExceptionClass - Get the exception user class for the given +;;; isolate. +declare %JavaClass* @getJnjvmExceptionClass(%Jnjvm*) readnone + +;;; getJnjvmArrayClass - Get the array user class of the index, for the given +;;; isolate. +declare %JavaClass* @getJnjvmArrayClass(%Jnjvm*, i32) readnone + +;;; getArrayClass - Get the array user class of the user class. +declare %JavaClass* @getArrayClass(%JavaClass*) readnone Modified: vmkit/trunk/lib/JnJVM/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Makefile (original) +++ vmkit/trunk/lib/JnJVM/Makefile Thu Oct 2 18:28:36 2008 @@ -10,5 +10,13 @@ DIRS = LLVMRuntime VMCore Classpath +include $(LEVEL)/Makefile.config + +ifeq ($(ISOLATE_BUILD), 1) + DIRS += Isolate +endif + + + include $(LEVEL)/Makefile.common Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Thu Oct 2 18:28:36 2008 @@ -34,37 +34,13 @@ const unsigned int JavaArray::T_INT = 10; const unsigned int JavaArray::T_LONG = 11; -ClassArray* JavaArray::ofByte = 0; -ClassArray* JavaArray::ofChar = 0; -ClassArray* JavaArray::ofInt = 0; -ClassArray* JavaArray::ofShort = 0; -ClassArray* JavaArray::ofBool = 0; -ClassArray* JavaArray::ofLong = 0; -ClassArray* JavaArray::ofFloat = 0; -ClassArray* JavaArray::ofDouble = 0; -ClassArray* JavaArray::ofString = 0; -ClassArray* JavaArray::ofObject = 0; - // This will force linking runtime methods extern "C" void negativeArraySizeException(sint32 val); extern "C" void outOfMemoryError(sint32 val); -#ifndef MULTIPLE_VM -#define ACONS(name, elmt, primSize, VT) \ - name *name::acons(sint32 n, ClassArray* atype, JavaAllocator* allocator) { \ - if (n < 0) \ - negativeArraySizeException(n); \ - else if (n > JavaArray::MaxArraySize) \ - outOfMemoryError(n); \ - name* res = (name*) \ - (Object*) allocator->allocateObject(sizeof(name) + n * primSize, VT); \ - res->initialise(atype); \ - res->size = n; \ - return res; \ - } -#else #define ACONS(name, elmt, primSize, VT) \ - name *name::acons(sint32 n, ClassArray* atype, JavaAllocator* allocator) { \ + name *name::acons(sint32 n, UserClassArray* atype, \ + JavaAllocator* allocator) { \ if (n < 0) \ negativeArraySizeException(n); \ else if (n > JavaArray::MaxArraySize) \ @@ -75,7 +51,6 @@ res->size = n; \ return res; \ } -#endif /// Each array class has its own element size for allocating arrays. ACONS(ArrayUInt8, uint8, 1, JavaArray::VT) @@ -113,6 +88,19 @@ return map->lookupOrCreateReader(java, len); } +const UTF8* UTF8::checkedJavaToInternal(UTF8Map* map, unsigned int start, + unsigned int len) const { + uint16* java = (uint16*) alloca(len * sizeof(uint16)); + for (uint32 i = 0; i < len; i++) { + uint16 cur = elements[start + i]; + if (cur == '.') java[i] = '/'; + else if (cur == '/') return 0; + else java[i] = cur; + } + + return map->lookupOrCreateReader(java, len); +} + const UTF8* UTF8::internalToJava(UTF8Map* map, unsigned int start, unsigned int len) const { uint16* java = (uint16*) alloca(len * sizeof(uint16)); @@ -137,18 +125,21 @@ } char* UTF8::UTF8ToAsciiz() const { - /*mvm::NativeString* buf = mvm::NativeString::alloc(size + 1); +#ifndef DEBUG + mvm::NativeString* buf = mvm::NativeString::alloc(size + 1); for (sint32 i = 0; i < size; ++i) { buf->setAt(i, elements[i]); } buf->setAt(size, 0); - return buf->cString();*/ + return buf->cString(); +#else char* buf = (char*)malloc(size + 1); for (sint32 i = 0; i < size; ++i) { buf[i] = elements[i]; } buf[size] = 0; return buf; +#endif } /// Currently, this uses malloc/free. This should use a custom memory pool. @@ -160,7 +151,9 @@ free(obj); } -const UTF8* UTF8::acons(sint32 n, ClassArray* cl, JavaAllocator* allocator) { + +const UTF8* UTF8::acons(sint32 n, UserClassArray* cl, + JavaAllocator* allocator) { if (n < 0) negativeArraySizeException(n); else if (n > JavaArray::MaxArraySize) Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Thu Oct 2 18:28:36 2008 @@ -68,18 +68,6 @@ static const unsigned int T_SHORT; static const unsigned int T_INT; static const unsigned int T_LONG; - - /// The Java class of Java arrays used in JnJVM. - static ClassArray* ofByte; - static ClassArray* ofChar; - static ClassArray* ofString; - static ClassArray* ofInt; - static ClassArray* ofShort; - static ClassArray* ofBool; - static ClassArray* ofLong; - static ClassArray* ofFloat; - static ClassArray* ofDouble; - static ClassArray* ofObject; /// tracer - The trace method of Java arrays of primitive types. Since their /// class lives throughout the lifetime of the application, there is no need @@ -92,7 +80,7 @@ #define ARRAYCLASS(name, elmt) \ class name : public TJavaArray { \ public: \ - static name* acons(sint32 n, ClassArray* cl, JavaAllocator* allocator); \ + static name* acons(sint32 n, UserClassArray* cl, JavaAllocator* allocator);\ } ARRAYCLASS(ArrayUInt8, uint8); @@ -117,7 +105,8 @@ /// acons - Allocates a Java array of objects. The class given as argument is /// the class of the array, not the class of its elements. - static ArrayObject* acons(sint32 n, ClassArray* cl, JavaAllocator* allocator); + static ArrayObject* acons(sint32 n, UserClassArray* cl, + JavaAllocator* allocator); /// tracer - The tracer method of Java arrays of objects. This method will /// trace all objects in the array. @@ -134,7 +123,8 @@ /// acons - Allocates an UTF8 in permanent memory. The class argument must be /// JavaArray::ofChar. - static const UTF8* acons(sint32 n, ClassArray* cl, JavaAllocator* allocator); + static const UTF8* acons(sint32 n, UserClassArray* cl, + JavaAllocator* allocator); /// internalToJava - Creates a copy of the UTF8 at its given offset and size /// woth all its '.' replaced by '/'. The JVM bytecode reference classes in @@ -147,8 +137,18 @@ const UTF8* javaToInternal(UTF8Map* map, unsigned int start, unsigned int len) const; + /// checkedJavaToInternal - Replaces all '/' into '.'. Returns null if the + /// UTF8 contains a '/', as Java does not allow things like + /// Class.forName("java/lang/Object") + const UTF8* checkedJavaToInternal(UTF8Map* map, unsigned int start, + unsigned int len) const; + /// UTF8ToAsciiz - Allocates a C string with the contents of this UTF8. char* UTF8ToAsciiz() const; + + char* printString() const { + return UTF8ToAsciiz(); + } /// extract - Creates an UTF8 by extracting the contents at the given size /// of this. @@ -156,7 +156,7 @@ /// equals - Returns whether two UTF8s are equals. When the JnJVM executes /// in single mode, equality is just a pointer comparison. When executing - /// in multiple mode, we compare the contents f the UTF8s. + /// in multiple mode, we compare the contents of the UTF8s. #ifndef MULTIPLE_VM bool equals(const UTF8* other) const { return this == other; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp Thu Oct 2 18:28:36 2008 @@ -61,7 +61,8 @@ -Class* JavaJIT::getCallingClass() { +#ifndef MULTIPLE_VM +UserClass* JavaJIT::getCallingClass() { int* ips[10]; int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); int n = 0; @@ -82,7 +83,7 @@ return 0; } -Class* JavaJIT::getCallingClassWalker() { +UserClass* JavaJIT::getCallingClassWalker() { int* ips[10]; int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); int n = 0; @@ -102,9 +103,57 @@ } return 0; } +#else + +UserClass* JavaJIT::getCallingClass() { + Class* res = 0; + + int* ips[10]; + int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); + int n = 0; + int i = 0; + while (n < real_size) { + mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + if (code) { + JavaMethod* meth = (JavaMethod*)code->getMetaInfo(); + 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() { - Class* cl = getCallingClassWalker(); + UserClass* cl = getCallingClassWalker(); if (!cl) return 0; else return cl->classLoader->getJavaClassLoader(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Thu Oct 2 18:28:36 2008 @@ -41,10 +41,13 @@ lastCible = 0; methPtr = 0; next = 0; +#ifdef MULTIPLE_VM + definingCtp = 0; +#endif enveloppe = E; } -Enveloppe::Enveloppe(JavaConstantPool* ctp, uint32 i) { +Enveloppe::Enveloppe(UserConstantPool* ctp, uint32 i) { firstCache = new CacheNode(this); cacheLock = mvm::Lock::allocNormal(); ctpInfo = ctp; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Thu Oct 2 18:28:36 2008 @@ -27,11 +27,13 @@ #include "types.h" +#include "JnjvmConfig.h" + namespace jnjvm { -class Class; class Enveloppe; -class JavaConstantPool; +class UserClass; +class UserConstantPool; /// CacheNode - A {class, method pointer} pair. class CacheNode { @@ -41,7 +43,7 @@ void* methPtr; /// lastCible - The class of this cache. - Class* lastCible; + UserClass* lastCible; /// next - The next cache. CacheNode* next; @@ -49,6 +51,12 @@ /// enveloppe - The container to which this class belongs to. Enveloppe* enveloppe; +#ifdef MULTIPLE_VM + ///definingClass - The class that defined the method being called. + /// + UserConstantPool* definingCtp; +#endif + /// CacheNode - Creates a CacheNode with empty values. CacheNode(Enveloppe* E); }; @@ -67,7 +75,7 @@ /// ctpInfo - The constant pool info that owns the invokeinterface /// bytecode. This is used to resolve the interface call at its first /// occurence. - JavaConstantPool* ctpInfo; + UserConstantPool* ctpInfo; /// cacheLock - The linked list may be modified by concurrent thread. This /// lock ensures that the list stays consistent. @@ -79,7 +87,7 @@ /// 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(JavaConstantPool* info, uint32 index); + Enveloppe(UserConstantPool* info, uint32 index); }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Thu Oct 2 18:28:36 2008 @@ -25,6 +25,7 @@ #include "JavaObject.h" #include "JavaThread.h" #include "JavaTypes.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" #include "JnjvmModuleProvider.h" #include "LockedMap.h" @@ -39,10 +40,9 @@ const UTF8* Attribut::innerClassesAttribut = 0; const UTF8* Attribut::sourceFileAttribut = 0; -CommonClass* ClassArray::SuperArray = 0; +CommonClass* ClassArray::SuperArray; std::vector ClassArray::InterfacesArray; - Attribut::Attribut(const UTF8* name, uint32 length, uint32 offset) { @@ -171,16 +171,13 @@ unsigned int end, mvm::PrintBuffer* buf) { uint16 first = name->elements[start]; - if (first == AssessorDesc::I_TAB) { + if (first == I_TAB) { unsigned int stepsEnd = start; - while (name->elements[stepsEnd] == AssessorDesc::I_TAB) stepsEnd++; - if (name->elements[stepsEnd] == AssessorDesc::I_REF) { + while (name->elements[stepsEnd] == I_TAB) stepsEnd++; + if (name->elements[stepsEnd] == I_REF) { printClassNameIntern(name, (stepsEnd + 1),(end - 1), buf); } else { - AssessorDesc * funcs = 0; - uint32 next = 0; - AssessorDesc::analyseIntern(name, stepsEnd, 0, funcs, next); - buf->write(funcs->asciizName); + name->print(buf); } buf->write(" "); for (uint32 i = start; i < stepsEnd; i++) @@ -206,27 +203,82 @@ buf->write(">"); } -CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n, bool isArray) { +UserClassPrimitive* CommonClass::toPrimitive(Jnjvm* vm) const { + if (this == vm->upcalls->voidClass) { + return vm->upcalls->OfVoid; + } else if (this == vm->upcalls->intClass) { + return vm->upcalls->OfInt; + } else if (this == vm->upcalls->shortClass) { + return vm->upcalls->OfShort; + } else if (this == vm->upcalls->charClass) { + return vm->upcalls->OfChar; + } else if (this == vm->upcalls->doubleClass) { + return vm->upcalls->OfDouble; + } else if (this == vm->upcalls->byteClass) { + return vm->upcalls->OfByte; + } else if (this == vm->upcalls->boolClass) { + return vm->upcalls->OfBool; + } else if (this == vm->upcalls->longClass) { + return vm->upcalls->OfLong; + } else if (this == vm->upcalls->floatClass) { + return vm->upcalls->OfFloat; + } else { + return 0; + } +} + + +UserClassPrimitive* +ClassPrimitive::byteIdToPrimitive(char id, Classpath* upcalls) { + switch (id) { + case I_FLOAT : + return upcalls->OfFloat; + case I_INT : + return upcalls->OfInt; + case I_SHORT : + return upcalls->OfShort; + case I_CHAR : + return upcalls->OfChar; + case I_DOUBLE : + return upcalls->OfDouble; + case I_BYTE : + return upcalls->OfByte; + case I_BOOL : + return upcalls->OfBool; + case I_LONG : + return upcalls->OfLong; + case I_VOID : + return upcalls->OfVoid; + default : + return 0; + } +} + +CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n, + bool isArray) { name = n; this->lockVar = mvm::Lock::allocRecursive(); this->condVar = mvm::Cond::allocCond(); this->status = loaded; this->classLoader = loader; - this->isArray = isArray; - this->isPrimitive = false; + this->array = isArray; + this->primitive = false; + this->JInfo = 0; #ifndef MULTIPLE_VM this->delegatee = 0; #endif } -ClassPrimitive::ClassPrimitive(JnjvmClassLoader* loader, const UTF8* n) : +ClassPrimitive::ClassPrimitive(JnjvmClassLoader* loader, const UTF8* n, + uint32 nb) : CommonClass(loader, n, false) { - + display = (CommonClass**)malloc(sizeof(CommonClass*)); display[0] = this; - isPrimitive = true; + primitive = true; status = ready; access = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC; + virtualSize = nb; } Class::Class(JnjvmClassLoader* loader, const UTF8* n, ArrayUInt8* B) : @@ -239,16 +291,22 @@ #endif } -ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n) : CommonClass(loader, n, true) { - _funcs = 0; - _baseClass = 0; +ClassArray::ClassArray(JnjvmClassLoader* loader, const UTF8* n, + UserCommonClass* base) : + CommonClass(loader, n, true) { + _baseClass = base; super = ClassArray::SuperArray; interfaces = ClassArray::InterfacesArray; depth = 1; display = (CommonClass**)malloc(2 * sizeof(CommonClass*)); display[0] = ClassArray::SuperArray; display[1] = this; - access = ACC_FINAL | ACC_ABSTRACT; + access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC; + if (base->isPrimitive()) { + virtualVT = JavaArray::VT; + } else { + virtualVT = ArrayObject::VT; + } } void Class::print(mvm::PrintBuffer* buf) const { @@ -263,26 +321,21 @@ buf->write(">"); } -void ClassArray::resolveComponent() { - AssessorDesc::introspectArray(classLoader, name, 0, _funcs, - _baseClass); -} - -JnjvmClassLoader* ClassArray::arrayLoader(const UTF8* name, - JnjvmClassLoader* loader, - unsigned int start, - unsigned int len) { - - if (name->elements[start] == AssessorDesc::I_TAB) { - return arrayLoader(name, loader, start + 1, len - 1); - } else if (name->elements[start] == AssessorDesc::I_REF) { - const UTF8* componentName = name->javaToInternal(loader->hashUTF8, start + 1, - len - 2); - CommonClass* cl = loader->loadName(componentName, false, true); - return cl->classLoader; - } else { - return JnjvmClassLoader::bootstrapLoader; - } +JavaArray* UserClassArray::doNew(sint32 n, Jnjvm* vm) { + if (n < 0) + vm->negativeArraySizeException(n); + else if (n > JavaArray::MaxArraySize) + vm->outOfMemoryError(n); + + UserCommonClass* cl = baseClass(); + assert(cl && virtualVT && "array class not resolved"); + + uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); + JavaArray* res = (JavaArray*) + vm->allocator.allocateObject(sizeof(name) + n * primSize, virtualVT); + res->initialise(this); + res->size = n; + return res; } void* JavaMethod::compiledPtr() { @@ -323,25 +376,33 @@ } JavaMethod* CommonClass::lookupMethodDontThrow(const UTF8* name, - const UTF8* type, bool isStatic, - bool recurse) { - - FieldCmp CC(name, type); - method_map& map = isStatic ? staticMethods : virtualMethods; - method_iterator End = map.end(); - method_iterator I = map.find(CC); - if (I != End) return I->second; + const UTF8* type, + bool isStatic, + bool recurse, + Class*& methodCl) { + + CommonClass::FieldCmp CC(name, type); + CommonClass::method_map* map = isStatic ? getStaticMethods() : + getVirtualMethods(); + CommonClass::method_iterator End = map->end(); + CommonClass::method_iterator I = map->find(CC); + if (I != End) { + methodCl = (Class*)this; + return I->second; + } JavaMethod *cur = 0; if (recurse) { if (super) cur = super->lookupMethodDontThrow(name, type, isStatic, - recurse); + recurse, methodCl); if (cur) return cur; if (isStatic) { - for (std::vector::iterator i = interfaces.begin(), - e = interfaces.end(); i!= e; i++) { - cur = (*i)->lookupMethodDontThrow(name, type, isStatic, recurse); + std::vector* interfaces = getInterfaces(); + for (std::vector::iterator i = interfaces->begin(), + e = interfaces->end(); i!= e; i++) { + cur = (*i)->lookupMethodDontThrow(name, type, isStatic, recurse, + methodCl); if (cur) return cur; } } @@ -351,34 +412,43 @@ } JavaMethod* CommonClass::lookupMethod(const UTF8* name, const UTF8* type, - bool isStatic, bool recurse) { - JavaMethod* res = lookupMethodDontThrow(name, type, isStatic, recurse); + bool isStatic, bool recurse, + Class*& methodCl) { + JavaMethod* res = lookupMethodDontThrow(name, type, isStatic, recurse, + methodCl); if (!res) { JavaThread::get()->isolate->noSuchMethodError(this, name); } return res; } -JavaField* CommonClass::lookupFieldDontThrow(const UTF8* name, - const UTF8* type, bool isStatic, - bool recurse) { - - FieldCmp CC(name, type); - field_map& map = isStatic ? staticFields : virtualFields; - field_iterator End = map.end(); - field_iterator I = map.find(CC); - if (I != End) return I->second; +JavaField* +CommonClass::lookupFieldDontThrow(const UTF8* name, const UTF8* type, + bool isStatic, bool recurse, + CommonClass*& definingClass) { + + CommonClass::FieldCmp CC(name, type); + CommonClass::field_map* map = isStatic ? getStaticFields() : + getVirtualFields(); + CommonClass::field_iterator End = map->end(); + CommonClass::field_iterator I = map->find(CC); + if (I != End) { + definingClass = this; + return I->second; + } JavaField *cur = 0; if (recurse) { if (super) cur = super->lookupFieldDontThrow(name, type, isStatic, - recurse); + recurse, definingClass); if (cur) return cur; if (isStatic) { - for (std::vector::iterator i = interfaces.begin(), - e = interfaces.end(); i!= e; i++) { - cur = (*i)->lookupFieldDontThrow(name, type, isStatic, recurse); + std::vector* interfaces = getInterfaces(); + for (std::vector::iterator i = interfaces->begin(), + e = interfaces->end(); i!= e; i++) { + cur = (*i)->lookupFieldDontThrow(name, type, isStatic, recurse, + definingClass); if (cur) return cur; } } @@ -388,29 +458,33 @@ } JavaField* CommonClass::lookupField(const UTF8* name, const UTF8* type, - bool isStatic, bool recurse) { + bool isStatic, bool recurse, + CommonClass*& definingClass) { - JavaField* res = lookupFieldDontThrow(name, type, isStatic, recurse); + JavaField* res = lookupFieldDontThrow(name, type, isStatic, recurse, + definingClass); if (!res) { JavaThread::get()->isolate->noSuchFieldError(this, name); } return res; } -JavaObject* Class::doNew(Jnjvm* vm) { +JavaObject* UserClass::doNew(Jnjvm* vm) { + assert(this && "No class when allocating."); assert(this->isReady() && "Uninitialized class when allocating."); - JavaObject* res = (JavaObject*)vm->allocator.allocateObject(virtualSize, virtualVT); + JavaObject* res = (JavaObject*)vm->allocator.allocateObject(getVirtualSize(), + getVirtualVT()); res->classOf = this; return res; } -bool CommonClass::inheritName(const UTF8* Tname) { - if (name->equals(Tname)) { +bool UserCommonClass::inheritName(const UTF8* Tname) { + if (getName()->equals(Tname)) { return true; - } else if (isPrimitive) { + } else if (isPrimitive()) { return false; } else if (super) { - if (super->inheritName(Tname)) return true; + if (getSuper()->inheritName(Tname)) return true; } for (uint32 i = 0; i < interfaces.size(); ++i) { @@ -419,34 +493,35 @@ return false; } -bool CommonClass::isOfTypeName(const UTF8* Tname) { +bool UserCommonClass::isOfTypeName(const UTF8* Tname) { if (inheritName(Tname)) { return true; - } else if (isArray) { - CommonClass* curS = this; + } else if (isArray()) { + UserCommonClass* curS = this; uint32 prof = 0; uint32 len = Tname->size; bool res = true; - while (res && Tname->elements[prof] == AssessorDesc::I_TAB) { - CommonClass* cl = ((ClassArray*)curS)->baseClass(); + while (res && Tname->elements[prof] == I_TAB) { + UserCommonClass* cl = ((UserClassArray*)curS)->baseClass(); ++prof; cl->resolveClass(); - res = curS->isArray && cl && (prof < len); + res = curS->isArray() && cl && (prof < len); curS = cl; } - return (Tname->elements[prof] == AssessorDesc::I_REF) && - (res && curS->inheritName(Tname->extract(classLoader->hashUTF8, prof + 1, len - 1))); + return (Tname->elements[prof] == I_REF) && + (res && curS->inheritName(Tname->extract(classLoader->hashUTF8, prof + 1, + len - 1))); } else { return false; } } -bool CommonClass::implements(CommonClass* cl) { +bool UserCommonClass::implements(UserCommonClass* cl) { if (this == cl) return true; else { - for (std::vector::iterator i = interfaces.begin(), + for (std::vector::iterator i = interfaces.begin(), e = interfaces.end(); i!= e; i++) { if (*i == cl) return true; else if ((*i)->implements(cl)) return true; @@ -458,14 +533,14 @@ return false; } -bool CommonClass::instantiationOfArray(ClassArray* cl) { +bool UserCommonClass::instantiationOfArray(UserClassArray* cl) { if (this == cl) return true; else { - if (isArray) { - CommonClass* baseThis = ((ClassArray*)this)->baseClass(); - CommonClass* baseCl = ((ClassArray*)cl)->baseClass(); + if (isArray()) { + UserCommonClass* baseThis = ((UserClassArray*)this)->baseClass(); + UserCommonClass* baseCl = ((UserClassArray*)cl)->baseClass(); - if (isInterface(baseThis->access) && isInterface(baseCl->access)) { + if (baseThis->isInterface() && baseCl->isInterface()) { return baseThis->implements(baseCl); } else { return baseThis->isAssignableFrom(baseCl); @@ -475,7 +550,7 @@ return false; } -bool CommonClass::subclassOf(CommonClass* cl) { +bool UserCommonClass::subclassOf(UserCommonClass* cl) { if (cl->depth <= depth) { return display[cl->depth] == cl; } else { @@ -483,20 +558,20 @@ } } -bool CommonClass::isAssignableFrom(CommonClass* cl) { +bool UserCommonClass::isAssignableFrom(UserCommonClass* cl) { if (this == cl) { return true; - } else if (isInterface(cl->access)) { + } else if (cl->isInterface()) { return this->implements(cl); - } else if (cl->isArray) { - return this->instantiationOfArray((ClassArray*)cl); + } else if (cl->isArray()) { + return this->instantiationOfArray((UserClassArray*)cl); } else { return this->subclassOf(cl); } } -void JavaField::initField(JavaObject* obj) { - const AssessorDesc* funcs = getSignature()->funcs; +void JavaField::initField(JavaObject* obj, Jnjvm* vm) { + const Typedef* type = getSignature(); Attribut* attribut = lookupAttribut(Attribut::constantAttribut); if (!attribut) { @@ -505,78 +580,27 @@ Reader reader(attribut, classDef->bytes); JavaConstantPool * ctpInfo = classDef->ctpInfo; uint16 idx = reader.readU2(); - if (funcs == AssessorDesc::dLong) { - JnjvmModule::InitField(this, obj, (uint64)ctpInfo->LongAt(idx)); - } else if (funcs == AssessorDesc::dDouble) { - JnjvmModule::InitField(this, obj, ctpInfo->DoubleAt(idx)); - } else if (funcs == AssessorDesc::dFloat) { - JnjvmModule::InitField(this, obj, ctpInfo->FloatAt(idx)); - } else if (funcs == AssessorDesc::dRef) { + if (type->isPrimitive()) { + UserCommonClass* cl = type->assocClass(vm->bootstrapLoader); + if (cl == vm->upcalls->OfLong) { + JnjvmModule::InitField(this, obj, (uint64)ctpInfo->LongAt(idx)); + } else if (cl == vm->upcalls->OfDouble) { + JnjvmModule::InitField(this, obj, ctpInfo->DoubleAt(idx)); + } else if (cl == vm->upcalls->OfFloat) { + JnjvmModule::InitField(this, obj, ctpInfo->FloatAt(idx)); + } else { + JnjvmModule::InitField(this, obj, (uint64)ctpInfo->IntegerAt(idx)); + } + } else if (type->isReference()){ const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[idx]); JnjvmModule::InitField(this, obj, (JavaObject*)ctpInfo->resolveString(utf8, idx)); - } else if (funcs == AssessorDesc::dInt || funcs == AssessorDesc::dChar || - funcs == AssessorDesc::dShort || funcs == AssessorDesc::dByte || - funcs == AssessorDesc::dBool) { - JnjvmModule::InitField(this, obj, (uint64)ctpInfo->IntegerAt(idx)); } else { JavaThread::get()->isolate-> - unknownError("unknown constant %c", funcs->byteId); - } - } - -} - -JavaObject* CommonClass::getClassDelegatee(JavaObject* pd) { - return JavaThread::get()->isolate->getClassDelegatee(this, pd); -} - -#ifdef MULTIPLE_VM -JavaObject* Class::staticInstance() { - std::pair* val = - JavaThread::get()->isolate->statics->lookup(this); - assert(val); - return val->second; -} - -void Class::createStaticInstance() { - JavaAllocator* allocator = &(JavaThread::get()->isolate->allocator); - JavaObject* val = - (JavaObject*)allocator->allocateObject(staticSize, staticVT); - - val->initialise(this); - for (field_iterator i = this->staticFields.begin(), - e = this->staticFields.end(); i!= e; ++i) { - - JavaField* cur = i->second; - cur->initField(val); - } - - Jnjvm* vm = JavaThread::get()->isolate; - std::pair* p = vm->statics->lookup(this); - assert(p); - assert(!p->second); - p->second = val; -} - -JavaState* CommonClass::getStatus() { - if (!this->isArray && - !this->isPrimitive) { - Class* cl = (Class*)this; - Jnjvm* vm = JavaThread::get()->isolate; - std::pair* val = vm->statics->lookup(cl); - if (!val) { - val = new std::pair(status, 0); - JavaThread::get()->isolate->statics->hash(cl, val); + unknownError("unknown constant %s\n", type->printString()); } - if (val->first < status) val->first = status; - return (JavaState*)&(val->first); - } else { - return &status; - } + } } -#endif - JavaMethod* CommonClass::constructMethod(const UTF8* name, const UTF8* type, uint32 access) { @@ -636,25 +660,25 @@ } -void Class::loadParents() { - int nbI = interfacesUTF8.size(); +void UserClass::loadParents() { + std::vector* interfacesUTF8 = getInterfacesUTF8(); + unsigned nbI = interfacesUTF8->size(); + const UTF8* superUTF8 = getSuperUTF8(); if (superUTF8 == 0) { depth = 0; - display = (CommonClass**)malloc(sizeof(CommonClass*)); + display = (UserCommonClass**)malloc(sizeof(UserCommonClass*)); display[0] = this; - virtualTableSize = VT_SIZE / sizeof(void*); } else { super = classLoader->loadName(superUTF8, true, true); depth = super->depth + 1; - virtualTableSize = super->virtualTableSize; - display = (CommonClass**)malloc((depth + 1) * sizeof(CommonClass*)); - memcpy(display, super->display, depth * sizeof(CommonClass*)); + display = (UserCommonClass**)malloc((depth + 1) * sizeof(UserCommonClass*)); + memcpy(display, super->display, depth * sizeof(UserCommonClass*)); display[depth] = this; } - for (int i = 0; i < nbI; i++) - interfaces.push_back((Class*)classLoader->loadName(interfacesUTF8[i], - true, true)); + for (unsigned i = 0; i < nbI; i++) + interfaces.push_back((UserClass*)classLoader->loadName((*interfacesUTF8)[i], + true, true)); } void Class::readAttributs(Reader& reader, std::vector& attr) { @@ -712,12 +736,15 @@ ctpInfo = new JavaConstantPool(this, reader); access = reader.readU2(); + if (!isPublic(access)) access |= ACC_PRIVATE; + const UTF8* thisClassName = ctpInfo->resolveClassName(reader.readU2()); if (!(thisClassName->equals(name))) { - JavaThread::get()->isolate->classFormatError("try to load %s and found class named %s", - printString(), thisClassName->printString()); + JavaThread::get()->isolate->classFormatError( + "try to load %s and found class named %s", + printString(), thisClassName->printString()); } readParents(reader); @@ -726,16 +753,14 @@ readAttributs(reader, attributs); } +#ifndef MULTIPLE_VM void CommonClass::resolveClass() { if (status < resolved) { acquire(); if (status >= resolved) { release(); - } else if (status < loaded) { - release(); - JavaThread::get()->isolate->unknownError("try to resolve a not-read class"); - } else if (status == loaded || ownerClass()) { - if (isArray) { + } else if (status == loaded) { + if (isArray()) { ClassArray* arrayCl = (ClassArray*)this; CommonClass* baseClass = arrayCl->baseClass(); baseClass->resolveClass(); @@ -762,12 +787,18 @@ } } } +#else +void CommonClass::resolveClass() { + assert(status >= resolved && + "Asking to resolve a not resolved-class in a isolate environment"); +} +#endif -void Class::resolveInnerOuterClasses() { +void UserClass::resolveInnerOuterClasses() { if (!innerOuterResolved) { Attribut* attribut = lookupAttribut(Attribut::innerClassesAttribut); if (attribut != 0) { - Reader reader(attribut, bytes); + Reader reader(attribut, getBytes()); uint16 nbi = reader.readU2(); for (uint16 i = 0; i < nbi; ++i) { @@ -776,13 +807,13 @@ //uint16 innerName = reader.readU2(); uint16 accessFlags = reader.readU2(); - Class* clInner = (Class*)ctpInfo->loadClass(inner); - Class* clOuter = (Class*)ctpInfo->loadClass(outer); + UserClass* clInner = (UserClass*)ctpInfo->loadClass(inner); + UserClass* clOuter = (UserClass*)ctpInfo->loadClass(outer); if (clInner == this) { outerClass = clOuter; } else if (clOuter == this) { - clInner->innerAccess = accessFlags; + clInner->setInnerAccess(accessFlags); innerClasses.push_back(clInner); } } @@ -797,7 +828,7 @@ e = virtualMethods.end(); i != e; ++i) { JavaMethod* meth = i->second; bool pub = isPublic(meth->access); - if (meth->name == Jnjvm::initName && (!publicOnly || pub)) { + if (meth->name->equals(Jnjvm::initName) && (!publicOnly || pub)) { res.push_back(meth); } } @@ -809,7 +840,7 @@ e = virtualMethods.end(); i != e; ++i) { JavaMethod* meth = i->second; bool pub = isPublic(meth->access); - if (meth->name != Jnjvm::initName && (!publicOnly || pub)) { + if (!(meth->name->equals(Jnjvm::initName)) && (!publicOnly || pub)) { res.push_back(meth); } } @@ -818,7 +849,7 @@ e = staticMethods.end(); i != e; ++i) { JavaMethod* meth = i->second; bool pub = isPublic(meth->access); - if (meth->name != Jnjvm::clinitName && (!publicOnly || pub)) { + if (!(meth->name->equals(Jnjvm::clinitName)) && (!publicOnly || pub)) { res.push_back(meth); } } @@ -842,3 +873,7 @@ } } } + +void Class::resolveStaticClass() { + classLoader->TheModule->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=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Thu Oct 2 18:28:36 2008 @@ -31,6 +31,8 @@ class AssessorDesc; class Enveloppe; class Class; +class ClassArray; +class JavaArray; class JavaConstantPool; class JavaField; class JavaJIT; @@ -47,12 +49,13 @@ /// typedef enum JavaState { loaded = 0, /// The .class file has been found. - classRead, /// The .class file has been read. - prepared, /// The parents of this class has been resolved. - resolved, /// The class has been resolved. - clinitParent, /// The class is cliniting its parents. - inClinit, /// The class is cliniting. - ready /// The class is ready to be used. + classRead = 1, /// The .class file has been read. + prepared = 2, /// The parents of this class has been resolved. + resolved = 3, /// The class has been resolved. + clinitParent = 4, /// The class is cliniting its parents. + inClinit = 5, /// The class is cliniting. + ready = 6, /// The class is ready to be used. + dontuseenums = 0xffffffff /// dummy value to force the enum to be int32 }JavaState; @@ -118,6 +121,9 @@ /// class loader finalizer method will be defined. /// class CommonClass : public mvm::Object { +#ifdef MULTIPLE_VM +friend class UserCommonClass; +#endif private: @@ -136,7 +142,7 @@ FieldCmp(const UTF8* n, const UTF8* t) : name(n), type(t) {} - inline bool operator<(const FieldCmp &cmp) const; + bool operator<(const FieldCmp &cmp) const; }; public: @@ -171,6 +177,9 @@ /// uint32 depth; + /// status - The loading/resolve/initialization state of the class. + /// + JavaState status; //===----------------------------------------------------------------------===// // @@ -178,7 +187,15 @@ // //===----------------------------------------------------------------------===// - + + uint32 getVirtualSize() { + return virtualSize; + } + + VirtualTable* getVirtualVT() { + return virtualVT; + } + /// virtualTableSize - The size of the virtual table of this class. /// uint32 virtualTableSize; @@ -187,40 +204,95 @@ /// uint32 access; + uint32 getAccess() { + return access; + } + /// isArray - Is the class an array class? /// - bool isArray; + bool array; + bool isArray() { + return array; + } + + bool primitive; + /// isPrimitive - Is the class a primitive class? /// - bool isPrimitive; + bool isPrimitive() { + return primitive; + } - /// name - The name of the class. + /// isInterface - Is the class an interface? /// - const UTF8* name; + bool isInterface() { + return jnjvm::isInterface(access); + } - /// status - The loading/resolve/initialization state of the class. + /// asClass - Returns the class as a user-defined class + /// if it is not a primitive or an array. + UserClass* asClass() { + if (!primitive && !array) return (UserClass*)this; + return 0; + } + + /// asPrimitiveClass - Returns the class if it's a primitive class. /// - JavaState status; + UserClassPrimitive* asPrimitiveClass() { + if (primitive) return (UserClassPrimitive*)this; + return 0; + } + + /// asArrayClass - Returns the class if it's an array class. + /// + UserClassArray* asArrayClass() { + if (array) return (UserClassArray*)this; + return 0; + } + + /// interfaces - The interfaces this class implements. + /// + std::vector interfaces; + + std::vector * getInterfaces() { + return &interfaces; + } + /// name - The name of the class. + /// + const UTF8* name; + + const UTF8* getName() { + return name; + } + /// super - The parent of this class. /// CommonClass * super; + + CommonClass* getSuper() { + return super; + } /// superUTF8 - The name of the parent of this class. /// const UTF8* superUTF8; - - /// interfaces - The interfaces this class implements. - /// - std::vector interfaces; + + const UTF8* getSuperUTF8() { + return superUTF8; + } /// interfacesUTF8 - The names of the interfaces this class implements. /// std::vector interfacesUTF8; + std::vector* getInterfacesUTF8() { + return &interfacesUTF8; + } + /// lockVar - When multiple threads want to load/resolve/initialize a class, - /// they must be synchronized so that these steps are only performned once + /// they must be synchronized so that these steps are only performed once /// for a given class. mvm::Lock* lockVar; @@ -267,6 +339,11 @@ /// method_map staticMethods; + field_map* getStaticFields() { return &staticFields; } + field_map* getVirtualFields() { return &virtualFields; } + method_map* getStaticMethods() { return &staticMethods; } + method_map* getVirtualMethods() { return &virtualMethods; } + /// constructMethod - Add a new method in this class method map. /// JavaMethod* constructMethod(const UTF8* name, const UTF8* type, @@ -317,23 +394,24 @@ /// Do not throw if the method is not found. /// JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type, - bool isStatic, bool recurse); + bool isStatic, bool recurse, Class*& cl); /// lookupMethod - Lookup a method and throw an exception if not found. /// JavaMethod* lookupMethod(const UTF8* name, const UTF8* type, bool isStatic, - bool recurse); + bool recurse, Class*& cl); /// lookupFieldDontThrow - Lookup a field in the field map of this class. Do /// not throw if the field is not found. /// JavaField* lookupFieldDontThrow(const UTF8* name, const UTF8* type, - bool isStatic, bool recurse); + bool isStatic, bool recurse, + CommonClass*& definingClass); /// lookupField - Lookup a field and throw an exception if not found. /// JavaField* lookupField(const UTF8* name, const UTF8* type, bool isStatic, - bool recurse); + bool recurse, CommonClass*& definingClass); /// print - Print the class for debugging purposes. /// @@ -377,29 +455,28 @@ /// getClassDelegatee - Return the java/lang/Class representation of this /// class. /// - JavaObject* getClassDelegatee(JavaObject* pd = 0); + JavaObject* getClassDelegatee(Jnjvm* vm, JavaObject* pd = 0); /// resolveClass - If the class has not been resolved yet, resolve it. /// void resolveClass(); -#ifndef MULTIPLE_VM + /// initialiseClass - If the class has not been initialized yet, + /// initialize it. + /// + void initialiseClass(Jnjvm* vm); + + /// getStatus - Get the resolution/initialization status of this class. /// - JavaState* getStatus() { - return &status; + JavaState getStatus() { + return status; } /// isReady - Has this class been initialized? /// bool isReady() { return status >= inClinit; } -#else - JavaState* getStatus(); - bool isReady() { - return *getStatus() >= inClinit; - } -#endif /// isResolved - Has this class been resolved? /// @@ -432,16 +509,18 @@ return static_cast(JInfo); } -#ifdef MULTIPLE_VM - bool isSharedClass() { - return classLoader == JnjvmClassLoader::sharedLoader; - } -#endif - void getDeclaredConstructors(std::vector& res, bool publicOnly); void getDeclaredMethods(std::vector& res, bool publicOnly); void getDeclaredFields(std::vector& res, bool publicOnly); + void setInterfaces(std::vector I) { + interfaces = I; + } + void setSuper(CommonClass* S) { + super = S; + } + UserClassPrimitive* toPrimitive(Jnjvm* vm) const; + }; /// ClassPrimitive - This class represents internal classes for primitive @@ -449,7 +528,10 @@ /// class ClassPrimitive : public CommonClass { public: - ClassPrimitive(JnjvmClassLoader* loader, const UTF8* name); + ClassPrimitive(JnjvmClassLoader* loader, const UTF8* name, uint32 nb); + + static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls); + }; @@ -482,7 +564,8 @@ /// attributs - JVM attributes of this class. /// std::vector attributs; - + +#ifndef MULTIPLE_VM /// innerClasses - The inner classes of this class. /// std::vector innerClasses; @@ -490,11 +573,16 @@ /// outerClass - The outer class, if this class is an inner class. /// Class* outerClass; +#endif /// innerAccess - The access of this class, if this class is an inner class. /// uint32 innerAccess; + void setInnerAccess(uint32 access) { + innerAccess = access; + } + /// innerOuterResolved - Is the inner/outer resolution done? /// bool innerOuterResolved; @@ -506,10 +594,25 @@ /// staticVT - The virtual table of the static instance of this class. /// VirtualTable* staticVT; + + uint32 getStaticSize() { + return staticSize; + } + + VirtualTable* getStaticVT() { + return staticVT; + } + +#ifndef MULTIPLE_VM /// doNew - Allocates a Java object whose class is this class. /// JavaObject* doNew(Jnjvm* vm); +#endif + + /// resolveStaticClass - Resolve the static type of the class. + /// + void resolveStaticClass(); /// print - Prints a string representation of this class in the buffer. /// @@ -532,20 +635,16 @@ /// #ifndef MULTIPLE_VM JavaObject* _staticInstance; - JavaObject* staticInstance() { + + JavaObject* getStaticInstance() { return _staticInstance; } - - /// createStaticInstance - Create the static instance of this class. This is - /// a no-op in a single environment because it is created only once when - /// creating the static type of the class. In a multiple environment, it is - /// called on each initialization of the class. - /// - void createStaticInstance() { } -#else - JavaObject* staticInstance(); - void createStaticInstance(); + + void setStaticInstance(JavaObject* val) { + _staticInstance = val; + } #endif + /// Class - Create a class in the given virtual machine and with the given /// name. @@ -580,13 +679,14 @@ JavaConstantPool* getConstantPool() { return ctpInfo; } - + ArrayUInt8* getBytes() { return bytes; } void resolveInnerOuterClasses(); +#ifndef MULTIPLE_VM Class* getOuterClass() { return outerClass; } @@ -594,6 +694,9 @@ std::vector* getInnerClasses() { return &innerClasses; } +#endif + + }; /// ClassArray - This class represents Java array classes. @@ -609,39 +712,25 @@ /// CommonClass* _baseClass; - /// _funcs - The type of the base class of the array (primitive or - /// reference). Null if not resolved. - /// - AssessorDesc* _funcs; - - /// resolveComponent - Resolve the array class. The base class and the - /// AssessorDesc are resolved. - /// - void resolveComponent(); - /// baseClass - Get the base class of this array class. Resolve the array /// class if needed. /// CommonClass* baseClass() { - if (_baseClass == 0) - resolveComponent(); return _baseClass; } - /// funcs - Get the type of the base class/ Resolve the array if needed. - AssessorDesc* funcs() { - if (_funcs == 0) - resolveComponent(); - return _funcs; - } + /// funcs - Get the type of the base class/ Resolve the array if needed. + JavaArray* doNew(sint32 n, Jnjvm* vm); + /// ClassArray - Empty constructor for VT. /// ClassArray() {} /// ClassArray - Construct a Java array class with the given name. /// - ClassArray(JnjvmClassLoader* loader, const UTF8* name); + ClassArray(JnjvmClassLoader* loader, const UTF8* name, + UserCommonClass* baseClass); /// arrayLoader - Return the class loader of the class with the name 'name'. @@ -662,12 +751,7 @@ /// virtual void TRACER; - /// SuperArray - The super class of array classes. - /// static CommonClass* SuperArray; - - /// InterfacesArray - The interfaces that array classes implement. - /// static std::vector InterfacesArray; }; @@ -755,62 +839,62 @@ //===----------------------------------------------------------------------===// /// This class of methods takes a variable argument list. - uint32 invokeIntSpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap); - float invokeFloatSpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap); - double invokeDoubleSpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap); - sint64 invokeLongSpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap); - JavaObject* invokeJavaObjectSpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap); - - uint32 invokeIntVirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap); - float invokeFloatVirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap); - double invokeDoubleVirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap); - sint64 invokeLongVirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap); - JavaObject* invokeJavaObjectVirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap); - - uint32 invokeIntStaticAP(Jnjvm* vm, va_list ap); - float invokeFloatStaticAP(Jnjvm* vm, va_list ap); - double invokeDoubleStaticAP(Jnjvm* vm, va_list ap); - sint64 invokeLongStaticAP(Jnjvm* vm, va_list ap); - JavaObject* invokeJavaObjectStaticAP(Jnjvm* vm, va_list ap); + uint32 invokeIntSpecialAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + float invokeFloatSpecialAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + double invokeDoubleSpecialAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + sint64 invokeLongSpecialAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + JavaObject* invokeJavaObjectSpecialAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + + uint32 invokeIntVirtualAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + float invokeFloatVirtualAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + double invokeDoubleVirtualAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + sint64 invokeLongVirtualAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + JavaObject* invokeJavaObjectVirtualAP(Jnjvm* vm, UserClass*, JavaObject* obj, va_list ap); + + uint32 invokeIntStaticAP(Jnjvm* vm, UserClass*, va_list ap); + float invokeFloatStaticAP(Jnjvm* vm, UserClass*, va_list ap); + double invokeDoubleStaticAP(Jnjvm* vm, UserClass*, va_list ap); + sint64 invokeLongStaticAP(Jnjvm* vm, UserClass*, va_list ap); + JavaObject* invokeJavaObjectStaticAP(Jnjvm* vm, UserClass*, va_list ap); /// This class of methods takes a buffer which contain the arguments of the /// call. - uint32 invokeIntSpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf); - float invokeFloatSpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf); - double invokeDoubleSpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf); - sint64 invokeLongSpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf); - JavaObject* invokeJavaObjectSpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf); - - uint32 invokeIntVirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf); - float invokeFloatVirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf); - double invokeDoubleVirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf); - sint64 invokeLongVirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf); - JavaObject* invokeJavaObjectVirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf); - - uint32 invokeIntStaticBuf(Jnjvm* vm, void* buf); - float invokeFloatStaticBuf(Jnjvm* vm, void* buf); - double invokeDoubleStaticBuf(Jnjvm* vm, void* buf); - sint64 invokeLongStaticBuf(Jnjvm* vm, void* buf); - JavaObject* invokeJavaObjectStaticBuf(Jnjvm* vm, void* buf); + uint32 invokeIntSpecialBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + float invokeFloatSpecialBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + double invokeDoubleSpecialBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + sint64 invokeLongSpecialBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + JavaObject* invokeJavaObjectSpecialBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + + uint32 invokeIntVirtualBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + float invokeFloatVirtualBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + double invokeDoubleVirtualBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + sint64 invokeLongVirtualBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + JavaObject* invokeJavaObjectVirtualBuf(Jnjvm* vm, UserClass*, JavaObject* obj, void* buf); + + uint32 invokeIntStaticBuf(Jnjvm* vm, UserClass*, void* buf); + float invokeFloatStaticBuf(Jnjvm* vm, UserClass*, void* buf); + double invokeDoubleStaticBuf(Jnjvm* vm, UserClass*, void* buf); + sint64 invokeLongStaticBuf(Jnjvm* vm, UserClass*, void* buf); + JavaObject* invokeJavaObjectStaticBuf(Jnjvm* vm, UserClass*, void* buf); /// This class of methods is variadic. - uint32 invokeIntSpecial(Jnjvm* vm, JavaObject* obj, ...); - float invokeFloatSpecial(Jnjvm* vm, JavaObject* obj, ...); - double invokeDoubleSpecial(Jnjvm* vm, JavaObject* obj, ...); - sint64 invokeLongSpecial(Jnjvm* vm, JavaObject* obj, ...); - JavaObject* invokeJavaObjectSpecial(Jnjvm* vm, JavaObject* obj, ...); - - uint32 invokeIntVirtual(Jnjvm* vm, JavaObject* obj, ...); - float invokeFloatVirtual(Jnjvm* vm, JavaObject* obj, ...); - double invokeDoubleVirtual(Jnjvm* vm, JavaObject* obj, ...); - sint64 invokeLongVirtual(Jnjvm* vm, JavaObject* obj, ...); - JavaObject* invokeJavaObjectVirtual(Jnjvm* vm, JavaObject* obj, ...); - - uint32 invokeIntStatic(Jnjvm* vm, ...); - float invokeFloatStatic(Jnjvm* vm, ...); - double invokeDoubleStatic(Jnjvm* vm, ...); - sint64 invokeLongStatic(Jnjvm* vm, ...); - JavaObject* invokeJavaObjectStatic(Jnjvm* vm, ...); + uint32 invokeIntSpecial(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + float invokeFloatSpecial(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + double invokeDoubleSpecial(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + sint64 invokeLongSpecial(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + JavaObject* invokeJavaObjectSpecial(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + + uint32 invokeIntVirtual(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + float invokeFloatVirtual(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + double invokeDoubleVirtual(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + sint64 invokeLongVirtual(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + JavaObject* invokeJavaObjectVirtual(Jnjvm* vm, UserClass*, JavaObject* obj, ...); + + uint32 invokeIntStatic(Jnjvm* vm, UserClass*, ...); + float invokeFloatStatic(Jnjvm* vm, UserClass*, ...); + double invokeDoubleStatic(Jnjvm* vm, UserClass*, ...); + sint64 invokeLongStatic(Jnjvm* vm, UserClass*, ...); + JavaObject* invokeJavaObjectStatic(Jnjvm* vm, UserClass*, ...); mvm::JITInfo* JInfo; template @@ -881,7 +965,7 @@ /// initField - Init the value of the field in the given object. This is /// used for static fields which have a default value. /// - void initField(JavaObject* obj); + void initField(JavaObject* obj, Jnjvm* vm); /// lookupAttribut - Look up the attribut in the field's list of attributs. /// @@ -893,46 +977,25 @@ /// getVritual*Field - Get a virtual field of an object. /// - #define GETVIRTUALFIELD(TYPE, TYPE_NAME) \ - TYPE getVirtual##TYPE_NAME##Field(JavaObject* obj) { \ - assert(*(classDef->getStatus()) >= inClinit); \ + #define GETFIELD(TYPE, TYPE_NAME) \ + TYPE get##TYPE_NAME##Field(JavaObject* obj) { \ + assert(classDef->isResolved()); \ void* ptr = (void*)((uint64)obj + ptrOffset); \ return ((TYPE*)ptr)[0]; \ } - /// getStatic*Field - Get a static field in the defining class. + /// set*Field - Set a field of an object. /// - #define GETSTATICFIELD(TYPE, TYPE_NAME) \ - TYPE getStatic##TYPE_NAME##Field() { \ - assert(*(classDef->getStatus()) >= inClinit); \ - JavaObject* obj = classDef->staticInstance(); \ - void* ptr = (void*)((uint64)obj + ptrOffset); \ - return ((TYPE*)ptr)[0]; \ - } - - /// setVirtual*Field - Set a virtual of an object. - /// - #define SETVIRTUALFIELD(TYPE, TYPE_NAME) \ - void setVirtual##TYPE_NAME##Field(JavaObject* obj, TYPE val) { \ - assert(*(classDef->getStatus()) >= inClinit); \ - void* ptr = (void*)((uint64)obj + ptrOffset); \ - ((TYPE*)ptr)[0] = val; \ - } - - /// setStatic*Field - Set a static field in the defining class. - #define SETSTATICFIELD(TYPE, TYPE_NAME) \ - void setStatic##TYPE_NAME##Field(TYPE val) { \ - assert(*(classDef->getStatus()) >= inClinit); \ - JavaObject* obj = classDef->staticInstance(); \ + #define SETFIELD(TYPE, TYPE_NAME) \ + void set##TYPE_NAME##Field(JavaObject* obj, TYPE val) { \ + assert(classDef->isResolved()); \ void* ptr = (void*)((uint64)obj + ptrOffset); \ ((TYPE*)ptr)[0] = val; \ } #define MK_ASSESSORS(TYPE, TYPE_NAME) \ - GETVIRTUALFIELD(TYPE, TYPE_NAME) \ - SETVIRTUALFIELD(TYPE, TYPE_NAME) \ - GETSTATICFIELD(TYPE, TYPE_NAME) \ - SETSTATICFIELD(TYPE, TYPE_NAME) \ + GETFIELD(TYPE, TYPE_NAME) \ + SETFIELD(TYPE, TYPE_NAME) \ MK_ASSESSORS(float, Float); MK_ASSESSORS(double, Double); @@ -959,4 +1022,9 @@ } // end namespace jnjvm + +#ifdef MULTIPLE_VM +#include "IsolateCommonClass.h" +#endif + #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Thu Oct 2 18:28:36 2008 @@ -267,10 +267,11 @@ CommonClass* JavaConstantPool::loadClass(uint32 index) { CommonClass* temp = isClassLoaded(index); +#ifndef MULTIPLE_VM if (!temp) { JnjvmClassLoader* loader = classDef->classLoader; const UTF8* name = UTF8At(ctpDef[index]); - if (name->elements[0] == AssessorDesc::I_TAB) { + if (name->elements[0] == I_TAB) { temp = loader->constructArray(name); temp->resolveClass(); } else { @@ -279,18 +280,22 @@ } ctpRes[index] = temp; } +#endif return temp; } CommonClass* JavaConstantPool::getMethodClassIfLoaded(uint32 index) { CommonClass* temp = isClassLoaded(index); +#ifndef MULTIPLE_VM if (!temp) { JnjvmClassLoader* loader = classDef->classLoader; + assert(loader && "Class has no loader?"); const UTF8* name = UTF8At(ctpDef[index]); temp = loader->lookupClass(name); if (!temp) temp = JnjvmClassLoader::bootstrapLoader->lookupClass(name); } +#endif return temp; } @@ -346,9 +351,10 @@ const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16); cl = getMethodClassIfLoaded(entry >> 16); if (cl && cl->status >= classRead) { + Class* methodCl = 0; // lookup the method - meth = - cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), false); + meth = cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), + false, methodCl); } } @@ -390,8 +396,9 @@ CommonClass* cl = getMethodClassIfLoaded(entry >> 16); if (cl && cl->status >= classRead) { // lookup the method - meth = - cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), false); + Class* methodCl = 0; + meth = cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), + false, methodCl); if (meth) { // don't throw if no meth, the exception will be thrown just in time JnjvmModule* M = classDef->classLoader->TheModule; @@ -429,7 +436,8 @@ assert(sign && "No cached signature after JITting"); utf8 = UTF8At(ctpDef[ntIndex] >> 16); cl = loadClass(entry >> 16); - cl->resolveClass(); + assert(cl && "No class after loadClass"); + assert(cl->isResolved() && "Class not resolved after loadClass"); } void JavaConstantPool::resolveField(uint32 index, CommonClass*& cl, @@ -440,7 +448,8 @@ assert(sign && "No cached Typedef after JITting"); utf8 = UTF8At(ctpDef[ntIndex] >> 16); cl = loadClass(entry >> 16); - cl->resolveClass(); + assert(cl && "No class after loadClass"); + assert(cl->isResolved() && "Class not resolved after loadClass"); } JavaField* JavaConstantPool::lookupField(uint32 index, bool stat) { @@ -450,8 +459,9 @@ const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16); CommonClass* cl = getMethodClassIfLoaded(entry >> 16); if (cl && cl->status >= resolved) { + CommonClass* fieldCl = 0; JavaField* field = cl->lookupFieldDontThrow(utf8, sign->keyName, stat, - true); + true, fieldCl); // don't throw if no field, the exception will be thrown just in time if (field) { if (!stat) { @@ -459,7 +469,7 @@ } #ifndef MULTIPLE_VM else if (cl->isReady()) { - JavaObject* S = field->classDef->staticInstance(); + JavaObject* S = field->classDef->getStaticInstance(); ctpRes[index] = (void*)((uint64)S + field->ptrOffset); } #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Thu Oct 2 18:28:36 2008 @@ -142,6 +142,12 @@ /// UTF8At - Get the UTF8 at the given entry. /// const UTF8* UTF8At(uint32 entry); + + /// UTF8At - Get the UTF8 referenced from this string entry. + /// + const UTF8* UTF8AtForString(uint32 entry) { + return UTF8At(ctpDef[entry]); + } /// FloatAt - Get the float at the given entry. /// Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Thu Oct 2 18:28:36 2008 @@ -32,6 +32,11 @@ #include "ServiceDomain.h" #endif +#ifdef MULTIPLE_VM +#include "SharedMaps.h" +#include "IsolateSharedLoader.h" +#endif + using namespace jnjvm; static void initialiseVT() { @@ -45,16 +50,18 @@ INIT(JavaThread); INIT(Jnjvm); INIT(ClassMap); - INIT(StaticInstanceMap); - INIT(DelegateeMap); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); -#ifdef MULTIPLE_VM - INIT(JnjvmSharedLoader); -#endif #ifdef SERVICE_VM INIT(ServiceDomain); #endif +#ifdef MULTIPLE_VM + INIT(JnjvmSharedLoader); + INIT(SharedClassByteMap); + INIT(UserClass); + INIT(UserClassArray); + INIT(UserConstantPool); +#endif #undef INIT #define INIT(X) { \ @@ -70,54 +77,104 @@ #undef INIT } -static void initialiseStatics() { +void Jnjvm::initialiseStatics() { + +#ifdef MULTIPLE_VM + if (!JnjvmSharedLoader::sharedLoader) { + JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); + } +#endif - JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader = + JnjvmBootstrapLoader* JCL = bootstrapLoader = JnjvmBootstrapLoader::createBootstrapLoader(); - // Array initialization + // Create the name of char arrays. const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C"); - JavaArray::ofChar = JCL->constructArray(utf8OfChar); - ((UTF8*)utf8OfChar)->classOf = JavaArray::ofChar; - - ClassArray::InterfacesArray.push_back( + + // Create the base class of char arrays. + JCL->upcalls->OfChar = UPCALL_PRIMITIVE_CLASS(JCL, "char", 2); + + // Create the char array. + JCL->upcalls->ArrayOfChar = JCL->constructArray(utf8OfChar, + JCL->upcalls->OfChar); + + // Alright, now we can repair the damage: set the class to the UTF8s created + // and set the array class of UTF8s. + ((UTF8*)utf8OfChar)->classOf = JCL->upcalls->ArrayOfChar; + ((UTF8*)JCL->upcalls->OfChar->name)->classOf = JCL->upcalls->ArrayOfChar; + JCL->hashUTF8->array = JCL->upcalls->ArrayOfChar; + + // Create the byte array, so that bytes for classes can be created. + JCL->upcalls->OfByte = UPCALL_PRIMITIVE_CLASS(JCL, "byte", 1); + JCL->upcalls->ArrayOfByte = + JCL->constructArray(JCL->asciizConstructUTF8("[B"), JCL->upcalls->OfByte); + + // Now we can create the super and interfaces of arrays. + JCL->InterfacesArray.push_back( JCL->loadName(JCL->asciizConstructUTF8("java/lang/Cloneable"), false, false)); - ClassArray::InterfacesArray.push_back( + JCL->InterfacesArray.push_back( JCL->loadName(JCL->asciizConstructUTF8("java/io/Serializable"), false, false)); - ClassArray::SuperArray = + JCL->SuperArray = JCL->loadName(JCL->asciizConstructUTF8("java/lang/Object"), false, false); - JavaArray::ofChar->interfaces = ClassArray::InterfacesArray; - JavaArray::ofChar->super = ClassArray::SuperArray; - - JavaArray::ofByte = JCL->constructArray(JCL->asciizConstructUTF8("[B")); - JavaArray::ofString = - JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;")); - - JavaArray::ofObject = - JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;")); - - JavaArray::ofInt = JCL->constructArray(JCL->asciizConstructUTF8("[I")); +#ifdef MULTIPLE_VM + if (!ClassArray::SuperArray) { + ClassArray::SuperArray = JCL->SuperArray->classDef; + ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[0]->classDef); + ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[1]->classDef); + } +#else + ClassArray::SuperArray = JCL->SuperArray; + ClassArray::InterfacesArray = JCL->InterfacesArray; +#endif - JavaArray::ofBool = JCL->constructArray(JCL->asciizConstructUTF8("[Z")); + // And repair the damage: set the interfaces and super of array classes already + // created. + JCL->upcalls->ArrayOfChar->setInterfaces(JCL->InterfacesArray); + JCL->upcalls->ArrayOfChar->setSuper(JCL->SuperArray); + JCL->upcalls->ArrayOfByte->setInterfaces(JCL->InterfacesArray); + JCL->upcalls->ArrayOfByte->setSuper(JCL->SuperArray); + + // Yay, create the other primitive types. + JCL->upcalls->OfBool = UPCALL_PRIMITIVE_CLASS(JCL, "boolean", 1); + JCL->upcalls->OfShort = UPCALL_PRIMITIVE_CLASS(JCL, "short", 2); + JCL->upcalls->OfInt = UPCALL_PRIMITIVE_CLASS(JCL, "int", 4); + JCL->upcalls->OfLong = UPCALL_PRIMITIVE_CLASS(JCL, "long", 8); + JCL->upcalls->OfFloat = UPCALL_PRIMITIVE_CLASS(JCL, "float", 4); + JCL->upcalls->OfDouble = UPCALL_PRIMITIVE_CLASS(JCL, "double", 8); + JCL->upcalls->OfVoid = UPCALL_PRIMITIVE_CLASS(JCL, "void", 0); + + // And finally create the primitive arrays. + JCL->upcalls->ArrayOfInt = + JCL->constructArray(JCL->asciizConstructUTF8("[I"), JCL->upcalls->OfInt); + + JCL->upcalls->ArrayOfBool = + JCL->constructArray(JCL->asciizConstructUTF8("[Z"), JCL->upcalls->OfBool); + + JCL->upcalls->ArrayOfLong = + JCL->constructArray(JCL->asciizConstructUTF8("[J"), JCL->upcalls->OfLong); + + JCL->upcalls->ArrayOfFloat = + JCL->constructArray(JCL->asciizConstructUTF8("[F"), JCL->upcalls->OfFloat); - JavaArray::ofLong = JCL->constructArray(JCL->asciizConstructUTF8("[J")); + JCL->upcalls->ArrayOfDouble = + JCL->constructArray(JCL->asciizConstructUTF8("[D"), JCL->upcalls->OfDouble); - JavaArray::ofFloat = JCL->constructArray(JCL->asciizConstructUTF8("[F")); + JCL->upcalls->ArrayOfShort = + JCL->constructArray(JCL->asciizConstructUTF8("[S"), JCL->upcalls->OfShort); - JavaArray::ofDouble = JCL->constructArray(JCL->asciizConstructUTF8("[D")); + JCL->upcalls->ArrayOfString = + JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;")); - JavaArray::ofShort = JCL->constructArray(JCL->asciizConstructUTF8("[S")); + JCL->upcalls->ArrayOfObject = + JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;")); - // End array initialization - AssessorDesc::initialise(JCL); - Attribut::codeAttribut = JCL->asciizConstructUTF8("Code"); Attribut::exceptionsAttribut = JCL->asciizConstructUTF8("Exceptions"); Attribut::constantAttribut = JCL->asciizConstructUTF8("ConstantValue"); @@ -169,19 +226,18 @@ DEF_UTF8(finalize); #undef DEF_UTF8 - } -extern "C" void ClasspathBoot(); - void mvm::VirtualMachine::initialiseJVM() { +#ifndef MULTIPLE_VM if (!JnjvmClassLoader::bootstrapLoader) { initialiseVT(); - initialiseStatics(); - - ClasspathBoot(); - Classpath::initialiseClasspath(JnjvmClassLoader::bootstrapLoader); + Jnjvm::initialiseStatics(); + JnjvmClassLoader::bootstrapLoader = Jnjvm::bootstrapLoader; } +#else + initialiseVT(); +#endif } void Jnjvm::runApplication(int argc, char** argv) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Oct 2 18:28:36 2008 @@ -56,59 +56,48 @@ CommonClass* cl = 0; JavaMethod* meth = 0; ctpInfo->infoOfMethod(index, ACC_VIRTUAL, cl, meth); - + if ((cl && isFinal(cl->access)) || (meth && (isFinal(meth->access) || isPrivate(meth->access)))) return invokeSpecial(index); -#ifndef WITHOUT_VTABLE - Constant* zero = mvm::jit::constantZero; +#if !defined(WITHOUT_VTABLE) Signdef* signature = ctpInfo->infoOfInterfaceOrVirtualMethod(index); + Typedef* retTypedef = signature->ret; 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); - + + JITVerifyNull(args[0]); Value* VT = CallInst::Create(JnjvmModule::GetVTFunction, args[0], "", currentBlock); std::vector indexes2; //[3]; +#ifdef MULTIPLE_VM + std::vector indexesCtp; //[3]; +#endif if (meth) { LLVMMethodInfo* LMI = module->getMethodInfo(meth); - indexes2.push_back(LMI->getOffset()); + ConstantInt* Offset = LMI->getOffset(); + indexes2.push_back(Offset); +#ifdef MULTIPLE_VM + indexesCtp.push_back(ConstantInt::get(Type::Int32Ty, + Offset->getZExtValue() * -1)); +#endif } else { - Value* val = getConstantPoolAt(index); - val = new PtrToIntInst(val, Type::Int32Ty, "", currentBlock); - - Value * cmp = new ICmpInst(ICmpInst::ICMP_NE, val, zero, "", currentBlock); - BasicBlock* ifTrue = createBasicBlock("true vtable"); - BasicBlock* ifFalse = createBasicBlock("false vtable"); - BasicBlock* endBlock = createBasicBlock("end vtable"); - PHINode * node = llvm::PHINode::Create(Type::Int32Ty, "", endBlock); - llvm::BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); - - currentBlock = ifTrue; - node->addIncoming(val, currentBlock); - llvm::BranchInst::Create(endBlock, currentBlock); - - currentBlock = ifFalse; - std::vector Args; - Args.push_back(args[0]); - LLVMClassInfo* LCI = - (LLVMClassInfo*)module->getClassInfo(compilingClass); - Args.push_back(LCI->getVar(this)); - Constant* CI = ConstantInt::get(Type::Int32Ty, index); - Args.push_back(CI); - val = invoke(JnjvmModule::VirtualLookupFunction, Args, "", currentBlock); - node->addIncoming(val, currentBlock); - llvm::BranchInst::Create(endBlock, currentBlock); - - currentBlock = endBlock; - indexes2.push_back(node); + Value* val = getConstantPoolAt(index, JnjvmModule::VirtualLookupFunction, + Type::Int32Ty, args[0], true); + indexes2.push_back(val); +#ifdef MULTIPLE_VM + Value* mul = BinaryOperator::createMul(val, mvm::jit::constantMinusOne, + "", currentBlock); + indexesCtp.push_back(mul); +#endif } Value* FuncPtr = GetElementPtrInst::Create(VT, indexes2.begin(), @@ -117,14 +106,22 @@ Value* Func = new LoadInst(FuncPtr, "", currentBlock); Func = new BitCastInst(Func, LSI->getVirtualPtrType(), "", currentBlock); - +#ifdef MULTIPLE_VM + Value* CTP = GetElementPtrInst::Create(VT, indexesCtp.begin(), + indexesCtp.end(), "", + currentBlock); + + CTP = new LoadInst(CTP, "", currentBlock); + CTP = new BitCastInst(CTP, JnjvmModule::ConstantPoolType, "", currentBlock); + args.push_back(CTP); +#endif Value* val = invoke(Func, args, "", currentBlock); const llvm::Type* retType = virtualType->getReturnType(); if (retType != Type::VoidTy) { - push(val, signature->ret->funcs); + push(val, retTypedef->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); } } @@ -158,16 +155,21 @@ currentBlock = createBasicBlock("start"); BasicBlock* executeBlock = createBasicBlock("execute"); endBlock = createBasicBlock("end block"); + returnType = funcType->getReturnType(); -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) Value* lastArg = 0; for (Function::arg_iterator i = func->arg_begin(), e = func->arg_end(); i != e; ++i) { lastArg = i; } #if !defined(SERVICE_VM) + ctpCache = lastArg; + lastArg--; isolateLocal = lastArg; #else + ctpCache = lastArg; + lastArg--; if (compilingClass->isolate == Jnjvm::bootstrapVM) { isolateLocal = lastArg; } else { @@ -192,8 +194,6 @@ #endif #endif - if (funcType->getReturnType() != Type::VoidTy) - endNode = llvm::PHINode::Create(funcType->getReturnType(), "", endBlock); Value* buf = llvm::CallInst::Create(JnjvmModule::GetSJLJBufferFunction, "", currentBlock); @@ -202,14 +202,13 @@ test = new ICmpInst(ICmpInst::ICMP_EQ, test, mvm::jit::constantZero, "", currentBlock); llvm::BranchInst::Create(executeBlock, endBlock, test, currentBlock); - - if (compilingMethod->getSignature()->ret->funcs != AssessorDesc::dVoid) { - uint8 id = compilingMethod->getSignature()->ret->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - Constant* C = LAI.llvmNullConstant; - endNode->addIncoming(C, currentBlock); - } + if (returnType != Type::VoidTy) { + endNode = llvm::PHINode::Create(returnType, "", endBlock); + endNode->addIncoming(Constant::getNullValue(returnType), + currentBlock); + } + currentBlock = executeBlock; if (isSynchro(compilingMethod->access)) beginSynchronize(); @@ -225,9 +224,16 @@ uint32 index = 0; if (stat) { +#ifdef MULTIPLE_VM + Value* val = getClassCtp(); + Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, + val, "", currentBlock); + nativeArgs.push_back(res); +#else LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); nativeArgs.push_back(LCI->getDelegatee(this)); +#endif index = 2; } else { index = 1; @@ -249,7 +255,7 @@ Value* result = llvm::CallInst::Create(valPtr, nativeArgs.begin(), nativeArgs.end(), "", currentBlock); - if (funcType->getReturnType() != Type::VoidTy) + if (returnType != Type::VoidTy) endNode->addIncoming(result, currentBlock); llvm::BranchInst::Create(endBlock, currentBlock); @@ -260,8 +266,8 @@ llvm::CallInst::Create(JnjvmModule::JniProceedPendingExceptionFunction, "", currentBlock); - if (funcType->getReturnType() != Type::VoidTy) - llvm::ReturnInst::Create(result, currentBlock); + if (returnType != Type::VoidTy) + llvm::ReturnInst::Create(endNode, currentBlock); else llvm::ReturnInst::Create(currentBlock); @@ -411,14 +417,42 @@ currentBlock = EndUnlock; } +#ifdef MULTIPLE_VM +Value* JavaJIT::getStaticInstanceCtp() { + Value* cl = getClassCtp(); + std::vector indexes; //[3]; + indexes.push_back(mvm::jit::constantZero); + indexes.push_back(mvm::jit::constantSeven); + Value* arg1 = GetElementPtrInst::Create(cl, indexes.begin(), + indexes.end(), "", currentBlock); + arg1 = new LoadInst(arg1, "", false, currentBlock); + return arg1; + +} + +Value* JavaJIT::getClassCtp() { + std::vector indexes; //[3]; + indexes.push_back(mvm::jit::constantOne); + Value* arg1 = GetElementPtrInst::Create(ctpCache, indexes.begin(), + indexes.end(), "", currentBlock); + arg1 = new LoadInst(arg1, "", false, currentBlock); + arg1 = new BitCastInst(arg1, JnjvmModule::JavaClassType, "", currentBlock); + return arg1; +} +#endif + void JavaJIT::beginSynchronize() { Value* obj = 0; if (isVirtual(compilingMethod->access)) { obj = llvmFunction->arg_begin(); } else { +#ifndef MULTIPLE_VM LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); obj = LCI->getStaticVar(this); +#else + obj = getStaticInstanceCtp(); +#endif } #ifndef SERVICE_VM monitorEnter(obj); @@ -438,9 +472,13 @@ if (isVirtual(compilingMethod->access)) { obj = llvmFunction->arg_begin(); } else { +#ifndef MULTIPLE_VM LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); obj = LCI->getStaticVar(this); +#else + obj = getStaticInstanceCtp(); +#endif } #ifndef SERVICE_VM monitorExit(obj); @@ -485,8 +523,7 @@ Function* func = LMI->getMethod(); llvmFunction = parentFunction; - const FunctionType *funcType = func->getFunctionType(); - returnType = funcType->getReturnType(); + returnType = func->getReturnType(); endBlock = createBasicBlock("end"); llvmFunction = parentFunction; @@ -510,14 +547,14 @@ uint32 index = 0; uint32 count = 0; -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) - uint32 max = args.size() - 1; +#if defined(MULTIPLE_VM) + uint32 max = args.size() - 2; #else uint32 max = args.size(); #endif std::vector::iterator type = compilingMethod->getSignature()->args.begin(); - std::vector::iterator i = args.begin(); + std::vector::iterator i = args.begin(); if (isVirtual(compilingMethod->access)) { new StoreInst(*i, objectLocals[0], false, currentBlock); @@ -525,38 +562,42 @@ ++index; ++count; } + for (;count < max; ++i, ++index, ++count, ++type) { - const AssessorDesc* cur = (*type)->funcs; + const Typedef* cur = *type; + const Type* curType = (*i)->getType(); - if (cur == AssessorDesc::dLong){ + if (curType == Type::Int64Ty){ new StoreInst(*i, longLocals[index], false, currentBlock); ++index; - } else if (cur == AssessorDesc::dBool || cur == AssessorDesc::dChar) { + } else if (cur->isUnsigned()) { new StoreInst(new ZExtInst(*i, Type::Int32Ty, "", currentBlock), intLocals[index], false, currentBlock); - } else if (cur == AssessorDesc::dByte || cur == AssessorDesc::dShort) { + } else if (curType == Type::Int8Ty || curType == Type::Int16Ty) { new StoreInst(new SExtInst(*i, Type::Int32Ty, "", currentBlock), intLocals[index], false, currentBlock); - } else if (cur == AssessorDesc::dInt) { + } else if (curType == Type::Int32Ty) { new StoreInst(*i, intLocals[index], false, currentBlock); - } else if (cur == AssessorDesc::dDouble) { + } else if (curType == Type::DoubleTy) { new StoreInst(*i, doubleLocals[index], false, currentBlock); ++index; - } else if (cur == AssessorDesc::dFloat) { + } else if (curType == Type::FloatTy) { new StoreInst(*i, floatLocals[index], false, currentBlock); } else { new StoreInst(*i, objectLocals[index], false, currentBlock); } } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) #if !defined(SERVICE_VM) - isolateLocal = args[args.size() - 1]; + isolateLocal = args[args.size() - 2]; + ctpCache = args[args.size() - 1]; #else + ctpCache = args[args.size() - 1]; if (compilingClass->isolate == Jnjvm::bootstrapVM) { - isolateLocal = args[args.size() - 1]; + isolateLocal = args[args.size() - 2]; } else { JavaObject* loader = compilingClass->classLoader; ServiceDomain* vm = ServiceDomain::getDomainFromLoader(loader); @@ -569,7 +610,7 @@ BranchInst::Create(ifTrue, endBlock, cmp, currentBlock); currentBlock = ifTrue; std::vector Args; - Args.push_back(args[args.size()- 1]); + Args.push_back(args[args.size()- 2]); Args.push_back(isolateLocal); CallInst::Create(JnjvmModule::ServiceCallStartFunction, Args.begin(), Args.end(), "", currentBlock); @@ -674,8 +715,8 @@ uint32 index = 0; uint32 count = 0; -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) - uint32 max = func->arg_size() - 1; +#if defined(MULTIPLE_VM) + uint32 max = func->arg_size() - 2; #else uint32 max = func->arg_size(); #endif @@ -692,31 +733,35 @@ for (;count < max; ++i, ++index, ++count, ++type) { - const AssessorDesc* cur = (*type)->funcs; - if (cur == AssessorDesc::dLong){ + const Typedef* cur = *type; + const llvm::Type* curType = i->getType(); + + if (curType == Type::Int64Ty){ new StoreInst(i, longLocals[index], false, currentBlock); ++index; - } else if (cur == AssessorDesc::dBool || cur == AssessorDesc::dChar) { + } else if (cur->isUnsigned()) { new StoreInst(new ZExtInst(i, Type::Int32Ty, "", currentBlock), intLocals[index], false, currentBlock); - } else if (cur == AssessorDesc::dByte || cur == AssessorDesc::dShort) { + } else if (curType == Type::Int8Ty || curType == Type::Int16Ty) { new StoreInst(new SExtInst(i, Type::Int32Ty, "", currentBlock), intLocals[index], false, currentBlock); - } else if (cur == AssessorDesc::dInt) { + } else if (curType == Type::Int32Ty) { new StoreInst(i, intLocals[index], false, currentBlock); - } else if (cur == AssessorDesc::dDouble) { + } else if (curType == Type::DoubleTy) { new StoreInst(i, doubleLocals[index], false, currentBlock); ++index; - } else if (cur == AssessorDesc::dFloat) { + } else if (curType == Type::FloatTy) { new StoreInst(i, floatLocals[index], false, currentBlock); } else { new StoreInst(i, objectLocals[index], false, currentBlock); } } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) #if !defined(SERVICE_VM) isolateLocal = i; + i++; + ctpCache = i; #else if (compilingClass->isolate == Jnjvm::bootstrapVM) { isolateLocal = i; @@ -739,7 +784,13 @@ BranchInst::Create(endBlock, currentBlock); currentBlock = endBlock; } + i++; + ctpCache = i; #endif + Value* addrCtpCache = new AllocaInst(JnjvmModule::ConstantPoolType, "", + currentBlock); + /// make it volatile to be sure it's on the stack + new StoreInst(ctpCache, addrCtpCache, true, currentBlock); #endif unsigned nbe = readExceptionTable(reader); @@ -758,7 +809,8 @@ beginSynchronize(); compileOpcodes(&compilingClass->bytes->elements[start], codeLen); - + + assert(stack.size() == 0 && "Stack not empty after compiling bytecode"); // Fix a javac(?) bug where a method only throws an exception and des // not return. pred_iterator PI = pred_begin(endBlock); @@ -846,7 +898,6 @@ std::vector exceptions; unsigned sync = isSynchro(compilingMethod->access) ? 1 : 0; nbe += sync; - JavaConstantPool* ctpInfo = compilingClass->ctpInfo; if (nbe) { supplLocal = new AllocaInst(JnjvmModule::JavaObjectType, "exceptionVar", currentBlock); @@ -866,8 +917,12 @@ if (isVirtual(compilingMethod->access)) { argsSync.push_back(llvmFunction->arg_begin()); } else { +#ifndef MULTIPLE_VM LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); Value* arg = LCI->getStaticVar(this); +#else + Value* arg = getStaticInstanceCtp(); +#endif argsSync.push_back(arg); } llvm::CallInst::Create(JnjvmModule::ReleaseObjectFunction, argsSync.begin(), argsSync.end(), @@ -912,11 +967,12 @@ ex->catche = reader.readU2(); +#ifndef MULTIPLE_VM if (ex->catche) { JavaObject* exc = 0; - Class* cl = 0; + UserClass* cl = 0; try { - cl = (Class*)(ctpInfo->loadClass(ex->catche)); + cl = (UserClass*)(compilingClass->ctpInfo->loadClass(ex->catche)); } catch(...) { compilingClass->release(); exc = JavaThread::getJavaException(); @@ -933,6 +989,7 @@ } else { ex->catchClass = Classpath::newThrowable; } +#endif ex->test = createBasicBlock("testException"); @@ -1023,9 +1080,17 @@ Value* cl = 0; currentBlock = cur->realTest; +#ifdef MULTIPLE_VM + // 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); + else cl = CallInst::Create(JnjvmModule::GetJnjvmExceptionClassFunction, + isolateLocal, "", currentBlock); +#else assert(cur->catchClass); LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(cur->catchClass); cl = LCI->getVar(this); +#endif Value* cmp = llvm::CallInst::Create(JnjvmModule::CompareExceptionFunction, cl, "", currentBlock); llvm::BranchInst::Create(cur->handler, bbNext, cmp, currentBlock); @@ -1076,7 +1141,7 @@ c = new FCmpInst(FCmpInst::FCMP_UNO, val1, val2, "", currentBlock); r = llvm::SelectInst::Create(c, l ? one : minus, r, "", currentBlock); - push(r, AssessorDesc::dInt); + push(r, false); } @@ -1087,70 +1152,44 @@ if (type == JavaConstantPool::ConstantString) { #ifdef MULTIPLE_VM // Lookup the constant pool cache - Constant* nil = mvm::jit::constantPtrNull; - Value* val = getConstantPoolAt(index); - Value* cmp = new ICmpInst(ICmpInst::ICMP_NE, nil, val, "", currentBlock); - BasicBlock* ifTrue = createBasicBlock("true string"); - BasicBlock* ifFalse = createBasicBlock("false string"); - BasicBlock* endBlock = createBasicBlock("end string"); - - PHINode * node = PHINode::Create(JnjvmModule::JavaObjectType, "", endBlock); - BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); - - // ---------- In case we already resolved something --------------------- // - currentBlock = ifTrue; - val = new BitCastInst(val, JnjvmModule::JavaObjectType, "", currentBlock); - node->addIncoming(val, currentBlock); - BranchInst::Create(endBlock, currentBlock); - - // ---------------- In case we have to resolve -------------------------- // - currentBlock = ifFalse; - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); - Value* v = LCI->getVar(this); - std::vector Args; - Args.push_back(v); - Args.push_back(ConstantInt::get(Type::Int32Ty, index)); - CallInst* C = llvm::CallInst::Create(JnjvmModule::StringLookupFunction, - Args.begin(), Args.end(), - "", currentBlock); - node->addIncoming(C, currentBlock); - BranchInst::Create(endBlock, currentBlock); - - // ---------------------------- The end ----------------------------------// - currentBlock = endBlock; - push(node, AssessorDesc::dRef); - + Value* val = getConstantPoolAt(index, JnjvmModule::StringLookupFunction, + JnjvmModule::JavaObjectType, 0, false); + push(val, false); #else const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); LLVMStringInfo* LSI = module->getStringInfo(str); Value* val = LSI->getDelegatee(this); - push(val, AssessorDesc::dRef); + push(val, false); #endif } else if (type == JavaConstantPool::ConstantLong) { push(ConstantInt::get(Type::Int64Ty, ctpInfo->LongAt(index)), - AssessorDesc::dLong); + false); } else if (type == JavaConstantPool::ConstantDouble) { push(ConstantFP::get(Type::DoubleTy, ctpInfo->DoubleAt(index)), - AssessorDesc::dDouble); + false); } else if (type == JavaConstantPool::ConstantInteger) { push(ConstantInt::get(Type::Int32Ty, ctpInfo->IntegerAt(index)), - AssessorDesc::dInt); + false); } else if (type == JavaConstantPool::ConstantFloat) { push(ConstantFP::get(Type::FloatTy, ctpInfo->FloatAt(index)), - AssessorDesc::dFloat); + false); } else if (type == JavaConstantPool::ConstantClass) { +#ifndef MULTIPLE_VM if (ctpInfo->ctpRes[index]) { CommonClass* cl = (CommonClass*)(ctpInfo->ctpRes[index]); LLVMCommonClassInfo* LCI = module->getClassInfo(cl); - push(LCI->getDelegatee(this), AssessorDesc::dRef); + push(LCI->getDelegatee(this), false); } else { +#endif Value* val = getResolvedClass(index, false); - Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, val, "", - currentBlock); - push(res, AssessorDesc::dRef); + Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, + val, "", currentBlock); + push(res, false); +#ifndef MULTIPLE_VM } +#endif } else { JavaThread::get()->isolate->unknownError("unknown type %d", type); } @@ -1237,7 +1276,7 @@ void JavaJIT::setCurrentBlock(BasicBlock* newBlock) { - std::vector< std::pair > newStack; + std::vector< std::pair > newStack; uint32 index = 0; for (BasicBlock::iterator i = newBlock->begin(), e = newBlock->end(); i != e; ++i, ++index) { @@ -1248,7 +1287,7 @@ const llvm::Type* type = i->getType(); if (type == Type::Int32Ty || type == Type::Int16Ty || type == Type::Int8Ty) { - newStack.push_back(std::make_pair(i, AssessorDesc::dInt)); + newStack.push_back(std::make_pair(i, false)); } else { newStack.push_back(std::make_pair(i, stack[index].second)); } @@ -1261,16 +1300,17 @@ static void testPHINodes(BasicBlock* dest, BasicBlock* insert, JavaJIT* jit) { if(dest->empty()) { - for (std::vector< std::pair >::iterator i = + for (std::vector< std::pair >::iterator i = jit->stack.begin(), e = jit->stack.end(); i!= e; ++i) { Value* cur = i->first; - const AssessorDesc* func = i->second; + bool unsign = i->second; PHINode* node = 0; - if (func == AssessorDesc::dChar || func == AssessorDesc::dBool) { + const Type* type = cur->getType(); + if (unsign) { node = llvm::PHINode::Create(Type::Int32Ty, "", dest); cur = new ZExtInst(cur, Type::Int32Ty, "", jit->currentBlock); - } else if (func == AssessorDesc::dByte || func == AssessorDesc::dShort) { + } else if (type == Type::Int8Ty || type == Type::Int16Ty) { node = llvm::PHINode::Create(Type::Int32Ty, "", dest); cur = new SExtInst(cur, Type::Int32Ty, "", jit->currentBlock); } else { @@ -1279,7 +1319,7 @@ node->addIncoming(cur, insert); } } else { - std::vector< std::pair >::iterator stackit = + std::vector< std::pair >::iterator stackit = jit->stack.begin(); for (BasicBlock::iterator i = dest->begin(), e = dest->end(); i != e; ++i) { @@ -1288,11 +1328,12 @@ } else { Instruction* ins = i; Value* cur = stackit->first; - const AssessorDesc* func = stackit->second; + const Type* type = cur->getType(); + bool unsign = stackit->second; - if (func == AssessorDesc::dChar || func == AssessorDesc::dBool) { + if (unsign) { cur = new ZExtInst(cur, Type::Int32Ty, "", jit->currentBlock); - } else if (func == AssessorDesc::dByte || func == AssessorDesc::dShort) { + } else if (type == Type::Int8Ty || type == Type::Int16Ty) { cur = new SExtInst(cur, Type::Int32Ty, "", jit->currentBlock); } @@ -1317,15 +1358,16 @@ void JavaJIT::makeArgs(FunctionType::param_iterator it, uint32 index, std::vector& Args, uint32 nb) { -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) - nb++; +#if defined(MULTIPLE_VM) + nb += 1; #endif Args.reserve(nb + 2); Value** args = (Value**)alloca(nb*sizeof(Value*)); -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) args[nb - 1] = isolateLocal; sint32 start = nb - 2; it--; + it--; #else sint32 start = nb - 1; #endif @@ -1334,13 +1376,12 @@ if (it->get() == Type::Int64Ty || it->get() == Type::DoubleTy) { pop(); } - const AssessorDesc* func = topFunc(); + bool unsign = topFunc(); Value* tmp = pop(); const Type* type = it->get(); if (tmp->getType() != type) { // int8 or int16 - convertValue(tmp, type, currentBlock, - func == AssessorDesc::dChar || func == AssessorDesc::dBool); + convertValue(tmp, type, currentBlock, unsign); } args[i] = tmp; @@ -1354,7 +1395,7 @@ Instruction* JavaJIT::lowerMathOps(const UTF8* name, std::vector& args) { - if (name == Jnjvm::abs) { + if (name->equals(Jnjvm::abs)) { const Type* Ty = args[0]->getType(); if (Ty == Type::Int32Ty) { Constant* const_int32_9 = mvm::jit::constantZero; @@ -1388,71 +1429,71 @@ return llvm::CallInst::Create(mvm::jit::func_llvm_fabs_f64, args[0], "tmp1", currentBlock); } - } else if (name == Jnjvm::sqrt) { + } else if (name->equals(Jnjvm::sqrt)) { return llvm::CallInst::Create(mvm::jit::func_llvm_sqrt_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::sin) { + } else if (name->equals(Jnjvm::sin)) { return llvm::CallInst::Create(mvm::jit::func_llvm_sin_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::cos) { + } else if (name->equals(Jnjvm::cos)) { return llvm::CallInst::Create(mvm::jit::func_llvm_cos_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::tan) { + } else if (name->equals(Jnjvm::tan)) { return llvm::CallInst::Create(mvm::jit::func_llvm_tan_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::asin) { + } else if (name->equals(Jnjvm::asin)) { return llvm::CallInst::Create(mvm::jit::func_llvm_asin_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::acos) { + } else if (name->equals(Jnjvm::acos)) { return llvm::CallInst::Create(mvm::jit::func_llvm_acos_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::atan) { + } else if (name->equals(Jnjvm::atan)) { return llvm::CallInst::Create(mvm::jit::func_llvm_atan_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::atan2) { + } else if (name->equals(Jnjvm::atan2)) { return llvm::CallInst::Create(mvm::jit::func_llvm_atan2_f64, args.begin(), args.end(), "tmp1", currentBlock); - } else if (name == Jnjvm::exp) { + } else if (name->equals(Jnjvm::exp)) { return llvm::CallInst::Create(mvm::jit::func_llvm_exp_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::log) { + } else if (name->equals(Jnjvm::log)) { return llvm::CallInst::Create(mvm::jit::func_llvm_log_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::pow) { + } else if (name->equals(Jnjvm::pow)) { return llvm::CallInst::Create(mvm::jit::func_llvm_pow_f64, args.begin(), args.end(), "tmp1", currentBlock); - } else if (name == Jnjvm::ceil) { + } else if (name->equals(Jnjvm::ceil)) { return llvm::CallInst::Create(mvm::jit::func_llvm_ceil_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::floor) { + } else if (name->equals(Jnjvm::floor)) { return llvm::CallInst::Create(mvm::jit::func_llvm_floor_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::rint) { + } else if (name->equals(Jnjvm::rint)) { return llvm::CallInst::Create(mvm::jit::func_llvm_rint_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::cbrt) { + } else if (name->equals(Jnjvm::cbrt)) { return llvm::CallInst::Create(mvm::jit::func_llvm_cbrt_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::cosh) { + } else if (name->equals(Jnjvm::cosh)) { return llvm::CallInst::Create(mvm::jit::func_llvm_cosh_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::expm1) { + } else if (name->equals(Jnjvm::expm1)) { return llvm::CallInst::Create(mvm::jit::func_llvm_expm1_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::hypot) { + } else if (name->equals(Jnjvm::hypot)) { return llvm::CallInst::Create(mvm::jit::func_llvm_hypot_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::log10) { + } else if (name->equals(Jnjvm::log10)) { return llvm::CallInst::Create(mvm::jit::func_llvm_log10_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::log1p) { + } else if (name->equals(Jnjvm::log1p)) { return llvm::CallInst::Create(mvm::jit::func_llvm_log1p_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::sinh) { + } else if (name->equals(Jnjvm::sinh)) { return llvm::CallInst::Create(mvm::jit::func_llvm_sinh_f64, args[0], "tmp1", currentBlock); - } else if (name == Jnjvm::tanh) { + } else if (name->equals(Jnjvm::tanh)) { return llvm::CallInst::Create(mvm::jit::func_llvm_tanh_f64, args[0], "tmp1", currentBlock); } @@ -1493,12 +1534,37 @@ makeArgs(it, index, args, signature->args.size() + 1); JITVerifyNull(args[0]); - if (cl == Jnjvm::mathName) { + if (cl->equals(Jnjvm::mathName)) { val = lowerMathOps(name, args); } if (!val) { +#if defined(MULTIPLE_VM) + const Type* Ty = JnjvmModule::ConstantPoolType; + Constant* Nil = Constant::getNullValue(Ty); + GlobalVariable* GV = new GlobalVariable(Ty, false, + GlobalValue::ExternalLinkage, Nil, + "", module); + Value* res = new LoadInst(GV, "", false, currentBlock); + Value* test = new ICmpInst(ICmpInst::ICMP_EQ, res, Nil, "", currentBlock); + + BasicBlock* trueCl = createBasicBlock("UserCtp OK"); + BasicBlock* falseCl = createBasicBlock("UserCtp Not OK"); + PHINode* node = llvm::PHINode::Create(Ty, "", trueCl); + node->addIncoming(res, currentBlock); + BranchInst::Create(falseCl, trueCl, test, currentBlock); + std::vector Args; + Args.push_back(ctpCache); + Args.push_back(ConstantInt::get(Type::Int32Ty, index)); + Args.push_back(GV); + res = CallInst::Create(JnjvmModule::SpecialCtpLookupFunction, Args.begin(), + Args.end(), "", falseCl); + node->addIncoming(res, falseCl); + BranchInst::Create(trueCl, falseCl); + currentBlock = trueCl; + args.push_back(node); +#endif Function* func = (Function*)ctpInfo->infoOfStaticOrSpecialMethod(index, ACC_VIRTUAL, signature, meth); @@ -1514,9 +1580,9 @@ const llvm::Type* retType = virtualType->getReturnType(); if (retType != Type::VoidTy) { - push(val, signature->ret->funcs); + push(val, signature->ret->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); } } @@ -1538,7 +1604,7 @@ makeArgs(it, index, args, signature->args.size()); ctpInfo->markAsStaticCall(index); - if (cl == Jnjvm::mathName) { + if (cl->equals(Jnjvm::mathName)) { val = lowerMathOps(name, args); } @@ -1547,22 +1613,12 @@ ctpInfo->infoOfStaticOrSpecialMethod(index, ACC_STATIC, signature, meth); -#ifdef MULTIPLE_VM - - uint32 clIndex = ctpInfo->getClassIndexFromMethod(index); - Class* mycl = (Class*)(ctpInfo->getMethodClassIfLoaded(clIndex)); - Value* arg = 0; - if (mycl && mycl->isResolved()) { - LLVMCommonClassInfo* LCI = module->getClassInfo(mycl); - arg = LCI->getVar(this); - arg = invoke(JnjvmModule::InitialisationCheckFunction, arg, "", - currentBlock); - } else { - arg = getResolvedClass(clIndex, true); - } - CallInst::Create(JnjvmModule::ForceInitialisationCheckFunction, arg, "", - currentBlock); - +#if defined(MULTIPLE_VM) + Value* newCtpCache = getConstantPoolAt(index, + JnjvmModule::StaticCtpLookupFunction, + JnjvmModule::ConstantPoolType, 0, + false); + args.push_back(newCtpCache); #endif if (meth && meth->canBeInlined && meth != compilingMethod && @@ -1576,59 +1632,135 @@ const llvm::Type* retType = staticType->getReturnType(); if (retType != Type::VoidTy) { - push(val, signature->ret->funcs); + push(val, signature->ret->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); } } } -Value* JavaJIT::getConstantPoolAt(uint32 index) { +Value* JavaJIT::getConstantPoolAt(uint32 index, Function* resolver, + const Type* returnType, + Value* additionalArg, bool doThrow) { + +// This makes unswitch loop very unhappy time-wise, but makes GVN happy +// number-wise. IMO, it's better to have this than Unswitch. +#if 1 + std::vector Args; +#ifdef MULTIPLE_VM + Value* CTP = ctpCache; + Args.push_back(mvm::jit::constantOne); + Value* Cl = GetElementPtrInst::Create(CTP, Args.begin(), Args.end(), "", + currentBlock); + Cl = new LoadInst(Cl, "", currentBlock); + Cl = new BitCastInst(Cl, JnjvmModule::JavaClassType, "", currentBlock); + Args.clear(); +#else JavaConstantPool* ctp = compilingClass->ctpInfo; LLVMConstantPoolInfo* LCPI = module->getConstantPoolInfo(ctp); Value* CTP = LCPI->getDelegatee(this); - + LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); + Value* Cl = LCI->getVar(this); +#endif + + Args.push_back(resolver); + Args.push_back(CTP); + Args.push_back(Cl); + Args.push_back(ConstantInt::get(Type::Int32Ty, index)); + if (additionalArg) Args.push_back(additionalArg); + + Value* res = 0; + if (doThrow) { + res = invoke(JnjvmModule::GetConstantPoolAtFunction, Args, "", + currentBlock); + } else { + res = CallInst::Create(JnjvmModule::GetConstantPoolAtFunction, Args.begin(), + Args.end(), "", currentBlock); + } + + const Type* realType = + JnjvmModule::GetConstantPoolAtFunction->getReturnType(); + if (returnType == Type::Int32Ty) { + return new PtrToIntInst(res, Type::Int32Ty, "", currentBlock); + } else if (returnType != realType) { + return new BitCastInst(res, returnType, "", currentBlock); + } + + return res; +#else + +#ifdef MULTIPLE_VM + Value* CTP = ctpCache; +#else + JavaConstantPool* ctp = compilingClass->ctpInfo; + LLVMConstantPoolInfo* LCPI = module->getConstantPoolInfo(ctp); + Value* CTP = LCPI->getDelegatee(this); +#endif std::vector indexes; //[3]; +#ifndef MULTIPLE_VM indexes.push_back(ConstantInt::get(Type::Int32Ty, index)); +#else + // Add one to the index because of the VT + indexes.push_back(ConstantInt::get(Type::Int32Ty, index + 1)); +#endif Value* arg1 = GetElementPtrInst::Create(CTP, indexes.begin(), indexes.end(), "", currentBlock); - // We set as volatile because "readnone" calls may alter - // the constant pool cache. - arg1 = new LoadInst(arg1, "", true, currentBlock); + arg1 = new LoadInst(arg1, "", false, currentBlock); + Value* test = new ICmpInst(ICmpInst::ICMP_EQ, arg1, mvm::jit::constantPtrNull, + "", currentBlock); + + BasicBlock* trueCl = createBasicBlock("Ctp OK"); + BasicBlock* falseCl = createBasicBlock("Ctp Not OK"); + PHINode* node = llvm::PHINode::Create(mvm::jit::ptrType, "", trueCl); + node->addIncoming(arg1, currentBlock); + llvm::BranchInst::Create(falseCl, trueCl, test, currentBlock); + + currentBlock = falseCl; + std::vector Args; +#ifdef MULTIPLE_VM + std::vector Args; + Args.push_back(mvm::jit::constantOne); + Value* v = GetElementPtrInst::Create(ctpCache, Args.begin(), Args.end(), "", + currentBlock); + v = new LoadInst(v, "", currentBlock); + v = new BitCastInst(v, JnjvmModule::JavaClassType, "", currentBlock); +#else + LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); + Value* v = LCI->getVar(this); +#endif + Args.push_back(v); + ConstantInt* CI = ConstantInt::get(Type::Int32Ty, index); + Args.push_back(CI); + + if (additionalArg) + Args.push_back(additionalArg); + + Value* res = 0; + if (doThrow) { + res = invoke(resolver, Args, "", currentBlock); + } else { + res = CallInst::Create(resolver, Args.begin(), Args.end(), "", + currentBlock); + } + node->addIncoming(res, currentBlock); - return arg1; + llvm::BranchInst::Create(trueCl, currentBlock); + currentBlock = trueCl; + + if (returnType == Type::Int32Ty) { + return new PtrToIntInst(node, Type::Int32Ty, "", currentBlock); + } else { + return new BitCastInst(node, returnType, "", currentBlock); + } +#endif } -Value* JavaJIT::getResolvedClass(uint16 index, bool clinit) { +Value* JavaJIT::getResolvedClass(uint16 index, bool clinit, bool doThrow) { - Value* arg1 = getConstantPoolAt(index); - arg1 = new BitCastInst(arg1, JnjvmModule::JavaClassType, "", currentBlock); - Value* test = new ICmpInst(ICmpInst::ICMP_EQ, arg1, - JnjvmModule::JavaClassNullConstant, "", - currentBlock); + Value* node = getConstantPoolAt(index, JnjvmModule::ClassLookupFunction, + JnjvmModule::JavaClassType, 0, doThrow); - BasicBlock* trueCl = createBasicBlock("Cl OK"); - BasicBlock* falseCl = createBasicBlock("Cl Not OK"); - PHINode* node = llvm::PHINode::Create(JnjvmModule::JavaClassType, "", - trueCl); - node->addIncoming(arg1, currentBlock); - llvm::BranchInst::Create(falseCl, trueCl, test, currentBlock); - - currentBlock = falseCl; - - std::vector Args; - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); - Value* v = LCI->getVar(this); - Args.push_back(v); - ConstantInt* CI = ConstantInt::get(Type::Int32Ty, index); - Args.push_back(CI); - Value* res = invoke(JnjvmModule::ClassLookupFunction, Args, "", - currentBlock); - node->addIncoming(res, currentBlock); - - llvm::BranchInst::Create(trueCl, currentBlock); - currentBlock = trueCl; if (clinit) return invoke(JnjvmModule::InitialisationCheckFunction, node, "", currentBlock); @@ -1652,16 +1784,21 @@ } else { LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(cl); Size = LCI->getVirtualSize(this); +#ifndef MULTIPLE_VM VT = LCI->getVirtualTable(this); Cl = LCI->getVar(this); -#ifndef MULTIPLE_VM if (!cl->isReady()) { -#endif - Cl = invoke(JnjvmModule::InitialisationCheckFunction, Cl, "", currentBlock); + Cl = invoke(JnjvmModule::InitialisationCheckFunction, Cl, "", + currentBlock); + CallInst::Create(JnjvmModule::ForceInitialisationCheckFunction, Cl, "", + currentBlock); + } +#else + Cl = getResolvedClass(index, true); CallInst::Create(JnjvmModule::ForceInitialisationCheckFunction, Cl, "", currentBlock); -#ifndef MULTIPLE_VM - } + VT = CallInst::Create(JnjvmModule::GetVTFromClassFunction, Cl, "", + currentBlock); #endif } std::vector args; @@ -1684,7 +1821,7 @@ new StoreInst(Cl, GEP, currentBlock); - push(val, AssessorDesc::dRef); + push(val, false); } Value* JavaJIT::arraySize(Value* val) { @@ -1721,12 +1858,13 @@ #ifndef MULTIPLE_VM if (field->classDef->isReady()) { -#endif object = LCI->getStaticVar(this); type = LCI->getStaticType(); return fieldGetter(this, type, object, LFI->getOffset()); -#ifndef MULTIPLE_VM } +#else + // In a multi environment, we always need to get the ptr in the constant + // pool. Therefore, we do nothing here. #endif } else { type = LCI->getVirtualType(); @@ -1736,55 +1874,27 @@ const Type* Pty = mvm::jit::arrayPtrType; Constant* zero = mvm::jit::constantZero; - Constant* nil = mvm::jit::constantPtrNull; - - Value* val = getConstantPoolAt(index); - // a virtual field can never be zero. - Value * cmp = new ICmpInst(ICmpInst::ICMP_NE, val, nil, "", currentBlock); - BasicBlock* ifTrue = createBasicBlock("true ldResolved"); - BasicBlock* ifFalse = createBasicBlock("false ldResolved"); - BasicBlock* endBlock = createBasicBlock("end ldResolved"); - PHINode * node = llvm::PHINode::Create(mvm::jit::ptrType, "", endBlock); - llvm::BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); - - // ---------- In case we already resolved something --------------------- // - currentBlock = ifTrue; - Value* resPtr = 0; - if (object) { - Value* ptr = new BitCastInst(object, Pty, "", currentBlock); - val = new PtrToIntInst(val, Type::Int32Ty, "", currentBlock); - std::vector gepArgs; // size = 1 - gepArgs.push_back(zero); - gepArgs.push_back(val); - resPtr = llvm::GetElementPtrInst::Create(ptr, gepArgs.begin(), gepArgs.end(), - "", currentBlock); - } else { - resPtr = val; - } + Function* func = stat ? JnjvmModule::StaticFieldLookupFunction : + JnjvmModule::VirtualFieldLookupFunction; - node->addIncoming(resPtr, currentBlock); - llvm::BranchInst::Create(endBlock, currentBlock); + const Type* returnType = 0; + if (stat) + returnType = mvm::jit::ptrType; + else + returnType = Type::Int32Ty; - // ---------- In case we have to resolve -------------------------------- // - currentBlock = ifFalse; - std::vector args; - if (object) { - args.push_back(object); - } else { - args.push_back(JnjvmModule::JavaObjectNullConstant); + Value* ptr = getConstantPoolAt(index, func, returnType, 0, true); + if (!stat) { + Value* tmp = new BitCastInst(object, Pty, "", currentBlock); + std::vector args; + args.push_back(zero); + args.push_back(ptr); + ptr = GetElementPtrInst::Create(tmp, args.begin(), args.end(), "", + currentBlock); } - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); - args.push_back(LCI->getVar(this)); - Constant* CI = ConstantInt::get(Type::Int32Ty, index); - args.push_back(CI); - args.push_back(stat ? mvm::jit::constantOne : mvm::jit::constantZero); - Value* tmp = invoke(JnjvmModule::FieldLookupFunction, args, "", currentBlock); - node->addIncoming(tmp, currentBlock); - llvm::BranchInst::Create(endBlock, currentBlock); - currentBlock = endBlock;; - return new BitCastInst(node, fieldTypePtr, "", currentBlock); + return new BitCastInst(ptr, fieldTypePtr, "", currentBlock); } void JavaJIT::convertValue(Value*& val, const Type* t1, BasicBlock* currentBlock, @@ -1815,20 +1925,21 @@ void JavaJIT::setStaticField(uint16 index) { - const AssessorDesc* ass = topFunc(); + bool unsign = topFunc(); Value* val = pop(); + Typedef* sign = compilingClass->ctpInfo->infoOfField(index); - uint8 id = sign->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = module->getTypedefInfo(sign); const Type* type = LAI.llvmType; + if (type == Type::Int64Ty || type == Type::DoubleTy) { val = pop(); } + Value* ptr = ldResolved(index, true, 0, type, LAI.llvmTypePtr); if (type != val->getType()) { // int1, int8, int16 - convertValue(val, type, currentBlock, - ass == AssessorDesc::dChar || ass == AssessorDesc::dBool); + convertValue(val, type, currentBlock, unsign); } new StoreInst(val, ptr, false, currentBlock); @@ -1836,23 +1947,22 @@ void JavaJIT::getStaticField(uint16 index) { Typedef* sign = compilingClass->ctpInfo->infoOfField(index); - uint8 id = sign->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - Value* ptr = ldResolved(index, true, 0, LAI.llvmType, - LAI.llvmTypePtr); - push(new LoadInst(ptr, "", currentBlock), sign->funcs); + LLVMAssessorInfo& LAI = module->getTypedefInfo(sign); const Type* type = LAI.llvmType; + + Value* ptr = ldResolved(index, true, 0, type, LAI.llvmTypePtr); + + push(new LoadInst(ptr, "", currentBlock), sign->isUnsigned()); if (type == Type::Int64Ty || type == Type::DoubleTy) { - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); } } void JavaJIT::setVirtualField(uint16 index) { - const AssessorDesc* ass = topFunc(); + bool unsign = topFunc(); Value* val = pop(); Typedef* sign = compilingClass->ctpInfo->infoOfField(index); - uint8 id = sign->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = module->getTypedefInfo(sign); const Type* type = LAI.llvmType; if (type == Type::Int64Ty || type == Type::DoubleTy) { @@ -1861,12 +1971,10 @@ Value* object = pop(); JITVerifyNull(object); - Value* ptr = ldResolved(index, false, object, type, - LAI.llvmTypePtr); + Value* ptr = ldResolved(index, false, object, type, LAI.llvmTypePtr); if (type != val->getType()) { // int1, int8, int16 - convertValue(val, type, currentBlock, - ass == AssessorDesc::dChar || ass == AssessorDesc::dBool); + convertValue(val, type, currentBlock, unsign); } new StoreInst(val, ptr, false, currentBlock); @@ -1874,16 +1982,16 @@ void JavaJIT::getVirtualField(uint16 index) { Typedef* sign = compilingClass->ctpInfo->infoOfField(index); + LLVMAssessorInfo& LAI = module->getTypedefInfo(sign); + const Type* type = LAI.llvmType; Value* obj = pop(); JITVerifyNull(obj); - uint8 id = sign->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - Value* ptr = ldResolved(index, false, obj, LAI.llvmType, - LAI.llvmTypePtr); - push(new LoadInst(ptr, "", currentBlock), sign->funcs); - const Type* type = LAI.llvmType; + + Value* ptr = ldResolved(index, false, obj, type, LAI.llvmTypePtr); + + push(new LoadInst(ptr, "", currentBlock), sign->isUnsigned()); if (type == Type::Int64Ty || type == Type::DoubleTy) { - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); } } @@ -1976,21 +2084,26 @@ if (retType != Type::VoidTy) { node = PHINode::Create(retType, "", endBlock); } + + JITVerifyNull(args[0]); + + Value* zero = mvm::jit::constantZero; + Value* one = mvm::jit::constantOne; +#ifndef MULTIPLE_VM // ok now the cache Enveloppe* enveloppe = new Enveloppe(compilingClass->ctpInfo, index); compilingMethod->caches.push_back(enveloppe); - - Value* zero = mvm::jit::constantZero; - Value* one = mvm::jit::constantOne; - + Value* llvmEnv = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (enveloppe)), JnjvmModule::EnveloppeType); - - - JITVerifyNull(args[0]); +#else + Value* llvmEnv = getConstantPoolAt(index, + JnjvmModule::EnveloppeLookupFunction, + JnjvmModule::EnveloppeType, 0, false); +#endif std::vector args1; args1.push_back(zero); @@ -2020,6 +2133,12 @@ "", ifFalse); Value* meth = new BitCastInst(_meth, virtualPtrType, "", currentBlock); +#ifdef MULTIPLE_VM + Value* cache2 = new LoadInst(cachePtr, "", currentBlock); + Value* newCtpCache = CallInst::Create(JnjvmModule::GetCtpCacheNodeFunction, + cache2, "", currentBlock); + args.push_back(newCtpCache); +#endif Value* ret = invoke(meth, args, "", currentBlock); if (node) { node->addIncoming(ret, currentBlock); @@ -2034,6 +2153,13 @@ _meth = new LoadInst(methPtr, "", currentBlock); meth = new BitCastInst(_meth, virtualPtrType, "", currentBlock); +#ifdef MULTIPLE_VM + args.pop_back(); + cache = new LoadInst(cachePtr, "", currentBlock); + newCtpCache = CallInst::Create(JnjvmModule::GetCtpCacheNodeFunction, + cache, "", currentBlock); + args.push_back(newCtpCache); +#endif ret = invoke(meth, args, "", currentBlock); BranchInst::Create(endBlock, currentBlock); @@ -2043,9 +2169,9 @@ currentBlock = endBlock; if (node) { - push(node, signature->ret->funcs); + push(node, signature->ret->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); } } } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Thu Oct 2 18:28:36 2008 @@ -24,7 +24,6 @@ #include "mvm/Object.h" #include "mvm/PrintBuffer.h" -#include "JavaTypes.h" #include "JnjvmModule.h" namespace jnjvm { @@ -41,7 +40,7 @@ uint32 endpc; uint32 handlerpc; uint16 catche; - Class* catchClass; + UserClass* catchClass; llvm::BasicBlock* test; llvm::BasicBlock* realTest; llvm::BasicBlock* handler; @@ -58,7 +57,9 @@ class JavaJIT { private: - llvm::Value* getConstantPoolAt(uint32 index); + llvm::Value* getConstantPoolAt(uint32 index, llvm::Function* resolver, + const llvm::Type* returnType, + llvm::Value* addArg, bool doThrow = true); public: @@ -100,16 +101,12 @@ // stack manipulation - std::vector< std::pair > stack; - void push(llvm::Value* val, const AssessorDesc* ass) { - assert(LLVMAssessorInfo::AssessorInfo[ass->numId].llvmType == - val->getType()); - stack.push_back(std::make_pair(val, ass)); + std::vector< std::pair > stack; + void push(llvm::Value* val, bool unsign) { + stack.push_back(std::make_pair(val, unsign)); } - void push(std::pair pair) { - assert(LLVMAssessorInfo::AssessorInfo[pair.second->numId].llvmType == - pair.first->getType()); + void push(std::pair pair) { stack.push_back(pair); } @@ -123,7 +120,7 @@ return stack.back().first; } - const AssessorDesc* topFunc() { + bool topFunc() { return stack.back().second; } @@ -133,11 +130,11 @@ llvm::Value* popAsInt() { llvm::Value * ret = top(); - const AssessorDesc* ass = topFunc(); + bool unsign = topFunc(); stack.pop_back(); if (ret->getType() != llvm::Type::Int32Ty) { - if (ass == AssessorDesc::dChar || ass == AssessorDesc::dBool) { + if (unsign) { ret = new llvm::ZExtInst(ret, llvm::Type::Int32Ty, "", currentBlock); } else { ret = new llvm::SExtInst(ret, llvm::Type::Int32Ty, "", currentBlock); @@ -148,8 +145,8 @@ } - std::pair popPair() { - std::pair ret = stack.back(); + std::pair popPair() { + std::pair ret = stack.back(); stack.pop_back(); return ret; } @@ -208,7 +205,7 @@ 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); + llvm::Value* getResolvedClass(uint16 index, bool clinit, bool doThrow = true); // methods invoke void makeArgs(llvm::FunctionType::param_iterator it, @@ -256,11 +253,16 @@ llvm::Value* isolateLocal; #endif +#if defined(MULTIPLE_VM) + llvm::Value* ctpCache; + llvm::Value* getStaticInstanceCtp(); + llvm::Value* getClassCtp(); +#endif static const char* OpcodeNames[256]; - static Class* getCallingClass(); - static Class* getCallingClassWalker(); + static UserClass* getCallingClass(); + static UserClass* getCallingClassWalker(); static JavaObject* getCallingClassLoader(); static void printBacktrace(); static JavaMethod* IPToJavaMethod(void* ip); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Thu Oct 2 18:28:36 2008 @@ -43,6 +43,28 @@ using namespace jnjvm; using namespace llvm; +uint8 arrayType(unsigned int t) { + if (t == JavaArray::T_CHAR) { + return I_CHAR; + } else if (t == JavaArray::T_BOOLEAN) { + return I_BOOL; + } else if (t == JavaArray::T_INT) { + return I_INT; + } else if (t == JavaArray::T_SHORT) { + return I_SHORT; + } else if (t == JavaArray::T_BYTE) { + return I_BYTE; + } else if (t == JavaArray::T_FLOAT) { + return I_FLOAT; + } else if (t == JavaArray::T_LONG) { + return I_LONG; + } else if (t == JavaArray::T_DOUBLE) { + return I_DOUBLE; + } else { + JavaThread::get()->isolate->unknownError("unknown array type %d\n", t); + return 0; + } +} static inline sint8 readS1(uint8* bytecode, uint32& i) { return ((sint8*)bytecode)[++i]; @@ -136,85 +158,85 @@ #endif if (opinfo->reqSuppl) { - push(new LoadInst(supplLocal, "", currentBlock), AssessorDesc::dRef); + push(new LoadInst(supplLocal, "", currentBlock), false); } switch (bytecodes[i]) { case ACONST_NULL : - push(JnjvmModule::JavaObjectNullConstant, AssessorDesc::dRef); + push(JnjvmModule::JavaObjectNullConstant, false); break; case ICONST_M1 : - push(mvm::jit::constantMinusOne, AssessorDesc::dInt); + push(mvm::jit::constantMinusOne, false); break; case ICONST_0 : - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); break; case ICONST_1 : - push(mvm::jit::constantOne, AssessorDesc::dInt); + push(mvm::jit::constantOne, false); break; case ICONST_2 : - push(mvm::jit::constantTwo, AssessorDesc::dInt); + push(mvm::jit::constantTwo, false); break; case ICONST_3 : - push(mvm::jit::constantThree, AssessorDesc::dInt); + push(mvm::jit::constantThree, false); break; case ICONST_4 : - push(mvm::jit::constantFour, AssessorDesc::dInt); + push(mvm::jit::constantFour, false); break; case ICONST_5 : - push(mvm::jit::constantFive, AssessorDesc::dInt); + push(mvm::jit::constantFive, false); break; case LCONST_0 : - push(mvm::jit::constantLongZero, AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantLongZero, false); + push(mvm::jit::constantZero, false); break; case LCONST_1 : - push(mvm::jit::constantLongOne, AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantLongOne, false); + push(mvm::jit::constantZero, false); break; case FCONST_0 : - push(mvm::jit::constantFloatZero, AssessorDesc::dFloat); + push(mvm::jit::constantFloatZero, false); break; case FCONST_1 : - push(mvm::jit::constantFloatOne, AssessorDesc::dFloat); + push(mvm::jit::constantFloatOne, false); break; case FCONST_2 : - push(mvm::jit::constantFloatTwo, AssessorDesc::dFloat); + push(mvm::jit::constantFloatTwo, false); break; case DCONST_0 : - push(mvm::jit::constantDoubleZero, AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantDoubleZero, false); + push(mvm::jit::constantZero, false); break; case DCONST_1 : - push(mvm::jit::constantDoubleOne, AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantDoubleOne, false); + push(mvm::jit::constantZero, false); break; case BIPUSH : push(ConstantExpr::getSExt(ConstantInt::get(Type::Int8Ty, bytecodes[++i]), - Type::Int32Ty), AssessorDesc::dInt); + Type::Int32Ty), false); break; case SIPUSH : push(ConstantExpr::getSExt(ConstantInt::get(Type::Int16Ty, readS2(bytecodes, i)), - Type::Int32Ty), AssessorDesc::dInt); + Type::Int32Ty), false); break; case LDC : @@ -227,138 +249,138 @@ case LDC2_W : _ldc(readS2(bytecodes, i)); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(mvm::jit::constantZero, false); break; case ILOAD : push(new LoadInst(intLocals[WREAD_U1(bytecodes, false, i)], "", - currentBlock), AssessorDesc::dInt); + currentBlock), false); break; case LLOAD : push(new LoadInst(longLocals[WREAD_U1(bytecodes, false, i)], "", - currentBlock), AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + currentBlock), false); + push(mvm::jit::constantZero, false); break; case FLOAD : push(new LoadInst(floatLocals[WREAD_U1(bytecodes, false, i)], "", - currentBlock), AssessorDesc::dFloat); + currentBlock), false); break; case DLOAD : push(new LoadInst(doubleLocals[WREAD_U1(bytecodes, false, i)], "", - currentBlock), AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + currentBlock), false); + push(mvm::jit::constantZero, false); break; case ALOAD : push(new LoadInst(objectLocals[WREAD_U1(bytecodes, false, i)], "", - currentBlock), AssessorDesc::dRef); + currentBlock), false); break; case ILOAD_0 : - push(new LoadInst(intLocals[0], "", currentBlock), AssessorDesc::dInt); + push(new LoadInst(intLocals[0], "", currentBlock), false); break; case ILOAD_1 : - push(new LoadInst(intLocals[1], "", currentBlock), AssessorDesc::dInt); + push(new LoadInst(intLocals[1], "", currentBlock), false); break; case ILOAD_2 : - push(new LoadInst(intLocals[2], "", currentBlock), AssessorDesc::dInt); + push(new LoadInst(intLocals[2], "", currentBlock), false); break; case ILOAD_3 : - push(new LoadInst(intLocals[3], "", currentBlock), AssessorDesc::dInt); + push(new LoadInst(intLocals[3], "", currentBlock), false); break; case LLOAD_0 : push(new LoadInst(longLocals[0], "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case LLOAD_1 : push(new LoadInst(longLocals[1], "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case LLOAD_2 : push(new LoadInst(longLocals[2], "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case LLOAD_3 : push(new LoadInst(longLocals[3], "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case FLOAD_0 : push(new LoadInst(floatLocals[0], "", currentBlock), - AssessorDesc::dFloat); + false); break; case FLOAD_1 : push(new LoadInst(floatLocals[1], "", currentBlock), - AssessorDesc::dFloat); + false); break; case FLOAD_2 : push(new LoadInst(floatLocals[2], "", currentBlock), - AssessorDesc::dFloat); + false); break; case FLOAD_3 : push(new LoadInst(floatLocals[3], "", currentBlock), - AssessorDesc::dFloat); + false); break; case DLOAD_0 : push(new LoadInst(doubleLocals[0], "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case DLOAD_1 : push(new LoadInst(doubleLocals[1], "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case DLOAD_2 : push(new LoadInst(doubleLocals[2], "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case DLOAD_3 : push(new LoadInst(doubleLocals[3], "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case ALOAD_0 : push(new LoadInst(objectLocals[0], "", currentBlock), - AssessorDesc::dRef); + false); break; case ALOAD_1 : push(new LoadInst(objectLocals[1], "", currentBlock), - AssessorDesc::dRef); + false); break; case ALOAD_2 : push(new LoadInst(objectLocals[2], "", currentBlock), - AssessorDesc::dRef); + false); break; case ALOAD_3 : push(new LoadInst(objectLocals[3], "", currentBlock), - AssessorDesc::dRef); + false); break; case IALOAD : { @@ -366,7 +388,7 @@ Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, JnjvmModule::JavaArraySInt32Type); - push(new LoadInst(ptr, "", currentBlock), AssessorDesc::dInt); + push(new LoadInst(ptr, "", currentBlock), false); break; } @@ -375,8 +397,8 @@ Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, JnjvmModule::JavaArrayLongType); - push(new LoadInst(ptr, "", currentBlock), AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(new LoadInst(ptr, "", currentBlock), false); + push(mvm::jit::constantZero, false); break; } @@ -385,7 +407,7 @@ Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, JnjvmModule::JavaArrayFloatType); - push(new LoadInst(ptr, "", currentBlock), AssessorDesc::dFloat); + push(new LoadInst(ptr, "", currentBlock), false); break; } @@ -394,8 +416,8 @@ Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, JnjvmModule::JavaArrayDoubleType); - push(new LoadInst(ptr, "", currentBlock), AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(new LoadInst(ptr, "", currentBlock), false); + push(mvm::jit::constantZero, false); break; } @@ -404,7 +426,7 @@ Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, JnjvmModule::JavaArrayObjectType); - push(new LoadInst(ptr, "", currentBlock), AssessorDesc::dRef); + push(new LoadInst(ptr, "", currentBlock), false); break; } @@ -415,7 +437,7 @@ JnjvmModule::JavaArraySInt8Type); Value* val = new LoadInst(ptr, "", currentBlock); push(new SExtInst(val, Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -426,7 +448,7 @@ JnjvmModule::JavaArrayUInt16Type); Value* val = new LoadInst(ptr, "", currentBlock); push(new ZExtInst(val, Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -437,7 +459,7 @@ JnjvmModule::JavaArraySInt16Type); Value* val = new LoadInst(ptr, "", currentBlock); push(new SExtInst(val, Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -640,11 +662,11 @@ } case CASTORE : { - const AssessorDesc* ass = topFunc(); Value* val = pop(); - if (ass == AssessorDesc::dInt) { + const Type* type = val->getType(); + if (type == Type::Int32Ty) { val = new TruncInst(val, Type::Int16Ty, "", currentBlock); - } else if (ass == AssessorDesc::dByte || ass == AssessorDesc::dBool) { + } else if (type == Type::Int8Ty) { val = new ZExtInst(val, Type::Int16Ty, "", currentBlock); } Value* index = pop(); @@ -656,11 +678,11 @@ } case SASTORE : { - const AssessorDesc* ass = topFunc(); Value* val = pop(); - if (ass == AssessorDesc::dInt) { + const Type* type = val->getType(); + if (type == Type::Int32Ty) { val = new TruncInst(val, Type::Int16Ty, "", currentBlock); - } else if (ass == AssessorDesc::dByte || ass == AssessorDesc::dBool) { + } else if (type == Type::Int8Ty) { val = new SExtInst(val, Type::Int16Ty, "", currentBlock); } Value* index = pop(); @@ -684,8 +706,8 @@ break; case DUP_X1 : { - std::pair one = popPair(); - std::pair two = popPair(); + std::pair one = popPair(); + std::pair two = popPair(); push(one); push(two); push(one); @@ -693,9 +715,9 @@ } case DUP_X2 : { - std::pair one = popPair(); - std::pair two = popPair(); - std::pair three = popPair(); + std::pair one = popPair(); + std::pair two = popPair(); + std::pair three = popPair(); push(one); push(three); push(two); @@ -709,9 +731,9 @@ break; case DUP2_X1 : { - std::pair one = popPair(); - std::pair two = popPair(); - std::pair three = popPair(); + std::pair one = popPair(); + std::pair two = popPair(); + std::pair three = popPair(); push(two); push(one); @@ -724,10 +746,10 @@ } case DUP2_X2 : { - std::pair one = popPair(); - std::pair two = popPair(); - std::pair three = popPair(); - std::pair four = popPair(); + std::pair one = popPair(); + std::pair two = popPair(); + std::pair three = popPair(); + std::pair four = popPair(); push(two); push(one); @@ -741,8 +763,8 @@ } case SWAP : { - std::pair one = popPair(); - std::pair two = popPair(); + std::pair one = popPair(); + std::pair two = popPair(); push(one); push(two); break; @@ -752,7 +774,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createAdd(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -762,8 +784,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createAdd(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -771,7 +793,7 @@ Value* val2 = pop(); Value* val1 = pop(); push(BinaryOperator::createAdd(val1, val2, "", currentBlock), - AssessorDesc::dFloat); + false); break; } @@ -781,8 +803,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createAdd(val1, val2, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -790,7 +812,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createSub(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } case LSUB : { @@ -799,8 +821,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createSub(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -808,7 +830,7 @@ Value* val2 = pop(); Value* val1 = pop(); push(BinaryOperator::createSub(val1, val2, "", currentBlock), - AssessorDesc::dFloat); + false); break; } @@ -818,8 +840,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createSub(val1, val2, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -827,7 +849,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createMul(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -837,8 +859,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createMul(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -846,7 +868,7 @@ Value* val2 = pop(); Value* val1 = pop(); push(BinaryOperator::createMul(val1, val2, "", currentBlock), - AssessorDesc::dFloat); + false); break; } @@ -856,8 +878,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createMul(val1, val2, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -865,7 +887,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createSDiv(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -875,8 +897,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createSDiv(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -884,7 +906,7 @@ Value* val2 = pop(); Value* val1 = pop(); push(BinaryOperator::createFDiv(val1, val2, "", currentBlock), - AssessorDesc::dFloat); + false); break; } @@ -894,8 +916,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createFDiv(val1, val2, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -903,7 +925,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createSRem(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -913,8 +935,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createSRem(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -922,7 +944,7 @@ Value* val2 = pop(); Value* val1 = pop(); push(BinaryOperator::createFRem(val1, val2, "", currentBlock), - AssessorDesc::dFloat); + false); break; } @@ -932,8 +954,8 @@ pop(); llvm::Value* val1 = pop(); push(BinaryOperator::createFRem(val1, val2, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -941,30 +963,30 @@ push(BinaryOperator::createSub( mvm::jit::constantZero, popAsInt(), "", currentBlock), - AssessorDesc::dInt); + false); break; case LNEG : { pop(); push(BinaryOperator::createSub( mvm::jit::constantLongZero, - pop(), "", currentBlock), AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + pop(), "", currentBlock), false); + push(mvm::jit::constantZero, false); break; } case FNEG : push(BinaryOperator::createSub( mvm::jit::constantFloatMinusZero, - pop(), "", currentBlock), AssessorDesc::dFloat); + pop(), "", currentBlock), false); break; case DNEG : { pop(); push(BinaryOperator::createSub( mvm::jit::constantDoubleMinusZero, - pop(), "", currentBlock), AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + pop(), "", currentBlock), false); + push(mvm::jit::constantZero, false); break; } @@ -972,7 +994,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createShl(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -981,8 +1003,8 @@ pop(); // remove the 0 on the stack Value* val1 = pop(); push(BinaryOperator::createShl(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -990,7 +1012,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createAShr(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -999,8 +1021,8 @@ pop(); // remove the 0 on the stack Value* val1 = pop(); push(BinaryOperator::createAShr(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -1010,7 +1032,7 @@ Value* mask = ConstantInt::get(Type::Int32Ty, 0x1F); val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); push(BinaryOperator::createLShr(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1021,8 +1043,8 @@ pop(); // remove the 0 on the stack Value* val1 = pop(); push(BinaryOperator::createLShr(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -1030,7 +1052,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createAnd(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1040,8 +1062,8 @@ pop(); // remove the 0 on the stack Value* val1 = pop(); push(BinaryOperator::createAnd(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -1049,7 +1071,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createOr(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1059,8 +1081,8 @@ pop(); // remove the 0 on the stack Value* val1 = pop(); push(BinaryOperator::createOr(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -1068,7 +1090,7 @@ Value* val2 = popAsInt(); Value* val1 = popAsInt(); push(BinaryOperator::createXor(val1, val2, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1078,8 +1100,8 @@ pop(); // remove the 0 on the stack Value* val1 = pop(); push(BinaryOperator::createXor(val1, val2, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; } @@ -1096,38 +1118,38 @@ case I2L : push(new SExtInst(pop(), llvm::Type::Int64Ty, "", currentBlock), - AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case I2F : push(new SIToFPInst(pop(), llvm::Type::FloatTy, "", currentBlock), - AssessorDesc::dFloat); + false); break; case I2D : push(new SIToFPInst(pop(), llvm::Type::DoubleTy, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case L2I : pop(); push(new TruncInst(pop(), llvm::Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; case L2F : pop(); push(new SIToFPInst(pop(), llvm::Type::FloatTy, "", currentBlock), - AssessorDesc::dFloat); + false); break; case L2D : pop(); push(new SIToFPInst(pop(), llvm::Type::DoubleTy, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case F2I : { @@ -1174,7 +1196,7 @@ currentBlock = res; - push(node, AssessorDesc::dInt); + push(node, false); break; } @@ -1220,15 +1242,15 @@ currentBlock = res; - push(node, AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(node, false); + push(mvm::jit::constantZero, false); break; } case F2D : push(new FPExtInst(pop(), llvm::Type::DoubleTy, "", currentBlock), - AssessorDesc::dDouble); - push(mvm::jit::constantZero, AssessorDesc::dInt); + false); + push(mvm::jit::constantZero, false); break; case D2I : { @@ -1275,7 +1297,7 @@ currentBlock = res; - push(node, AssessorDesc::dInt); + push(node, false); break; } @@ -1324,15 +1346,15 @@ currentBlock = res; - push(node, AssessorDesc::dLong); - push(mvm::jit::constantZero, AssessorDesc::dInt); + push(node, false); + push(mvm::jit::constantZero, false); break; } case D2F : pop(); // remove the 0 on the stack push(new FPTruncInst(pop(), llvm::Type::FloatTy, "", currentBlock), - AssessorDesc::dFloat); + false); break; case I2B : { @@ -1341,7 +1363,7 @@ val = new TruncInst(val, llvm::Type::Int8Ty, "", currentBlock); } push(new SExtInst(val, llvm::Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1351,7 +1373,7 @@ val = new TruncInst(val, llvm::Type::Int16Ty, "", currentBlock); } push(new ZExtInst(val, llvm::Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1361,7 +1383,7 @@ val = new TruncInst(val, llvm::Type::Int16Ty, "", currentBlock); } push(new SExtInst(val, llvm::Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -1392,7 +1414,7 @@ BranchInst::Create(res, currentBlock); currentBlock = res; - push(node, AssessorDesc::dInt); + push(node, false); break; } @@ -1433,13 +1455,10 @@ case IFEQ : { uint32 tmp = i; BasicBlock* ifTrue = opcodeInfos[tmp + readS2(bytecodes, i)].newBlock; - const AssessorDesc* ass = topFunc(); - - uint8 id = ass->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - llvm::Value* val = LAI.llvmNullConstant; Value* op = pop(); + const Type* type = op->getType(); + Constant* val = Constant::getNullValue(type); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_EQ, op, val, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFEQ"); @@ -1451,13 +1470,10 @@ case IFNE : { uint32 tmp = i; BasicBlock* ifTrue = opcodeInfos[tmp + readS2(bytecodes, i)].newBlock; - const AssessorDesc* ass = topFunc(); - - uint8 id = ass->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - llvm::Value* val = LAI.llvmNullConstant; Value* op = pop(); + const Type* type = op->getType(); + Constant* val = Constant::getNullValue(type); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_NE, op, val, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFNE"); @@ -1469,11 +1485,9 @@ case IFLT : { uint32 tmp = i; BasicBlock* ifTrue = opcodeInfos[tmp + readS2(bytecodes, i)].newBlock; - const AssessorDesc* ass = topFunc(); - uint8 id = ass->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - llvm::Value* val = LAI.llvmNullConstant; Value* op = pop(); + const Type* type = op->getType(); + Constant* val = Constant::getNullValue(type); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_SLT, op, val, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFLT"); @@ -1485,11 +1499,9 @@ case IFGE : { uint32 tmp = i; BasicBlock* ifTrue = opcodeInfos[tmp + readS2(bytecodes, i)].newBlock; - const AssessorDesc* ass = topFunc(); - uint8 id = ass->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - llvm::Value* val = LAI.llvmNullConstant; Value* op = pop(); + const Type* type = op->getType(); + Constant* val = Constant::getNullValue(type); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_SGE, op, val, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFGE"); @@ -1501,11 +1513,9 @@ case IFGT : { uint32 tmp = i; BasicBlock* ifTrue = opcodeInfos[tmp + readS2(bytecodes, i)].newBlock; - const AssessorDesc* ass = topFunc(); - uint8 id = ass->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - llvm::Value* val = LAI.llvmNullConstant; Value* op = pop(); + const Type* type = op->getType(); + Constant* val = Constant::getNullValue(type); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_SGT, op, val, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFGT"); @@ -1517,11 +1527,9 @@ case IFLE : { uint32 tmp = i; BasicBlock* ifTrue = opcodeInfos[tmp + readS2(bytecodes, i)].newBlock; - const AssessorDesc* ass = topFunc(); - uint8 id = ass->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; - llvm::Value* val = LAI.llvmNullConstant; Value* op = pop(); + const Type* type = op->getType(); + Constant* val = Constant::getNullValue(type); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_SLE, op, val, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFLE"); @@ -1707,12 +1715,13 @@ BasicBlock* def = opcodeInfos[tmp + readU4(bytecodes, i)].newBlock; uint32 nbs = readU4(bytecodes, i); - const AssessorDesc* ass = topFunc(); + bool unsign = topFunc(); Value* key = pop(); - if (ass == AssessorDesc::dShort || ass == AssessorDesc::dByte) { - key = new SExtInst(key, Type::Int32Ty, "", currentBlock); - } else if (ass == AssessorDesc::dChar || ass == AssessorDesc::dBool) { + const Type* type = key->getType(); + if (unsign) { key = new ZExtInst(key, Type::Int32Ty, "", currentBlock); + } else if (type == Type::Int8Ty || type == Type::Int16Ty) { + key = new SExtInst(key, Type::Int32Ty, "", currentBlock); } for (uint32 cur = 0; cur < nbs; ++cur) { Value* val = ConstantInt::get(Type::Int32Ty, readU4(bytecodes, i)); @@ -1727,11 +1736,10 @@ break; } case IRETURN : { - const AssessorDesc* ass = topFunc(); + bool unsign = topFunc(); Value* val = pop(); assert(val->getType()->isInteger()); - convertValue(val, returnType, currentBlock, - ass == AssessorDesc::dChar || ass == AssessorDesc::dBool); + convertValue(val, returnType, currentBlock, unsign); endNode->addIncoming(val, currentBlock); BranchInst::Create(endBlock, currentBlock); break; @@ -1820,34 +1828,52 @@ case NEWARRAY : case ANEWARRAY : { - ClassArray* dcl = 0; +#ifndef MULTIPLE_VM + UserClassArray* dcl = 0; +#endif ConstantInt* sizeElement = 0; GlobalVariable* TheVT = 0; - JnjvmClassLoader* JCL = compilingClass->classLoader; + Value* valCl = 0; if (bytecodes[i] == NEWARRAY) { uint8 id = bytecodes[++i]; - AssessorDesc* ass = AssessorDesc::arrayType(id); - dcl = ass->arrayClass; + uint8 charId = arrayType(id); +#ifndef MULTIPLE_VM + dcl = JavaThread::get()->isolate->arrayClasses[id - 4]; +#else + std::vector args; + args.push_back(isolateLocal); + args.push_back(ConstantInt::get(Type::Int32Ty, id - 4)); + valCl = CallInst::Create(JnjvmModule::GetJnjvmArrayClassFunction, + args.begin(), args.end(), "", currentBlock); +#endif + TheVT = JnjvmModule::JavaObjectVirtualTableGV; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[ass->numId]; + LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[charId]; sizeElement = LAI.sizeInBytesConstant; } else { uint16 index = readU2(bytecodes, i); +#ifndef MULTIPLE_VM const UTF8* className = compilingClass->ctpInfo->resolveClassName(index); - const UTF8* arrayName = - AssessorDesc::constructArrayName(JCL, 0, 1, className); + JnjvmClassLoader* JCL = compilingClass->classLoader; + const UTF8* arrayName = JCL->constructArrayName(1, className); dcl = JCL->constructArray(arrayName); +#else + + valCl = getResolvedClass(index, false); + valCl = CallInst::Create(JnjvmModule::GetArrayClassFunction, valCl, + "", currentBlock); +#endif TheVT = JnjvmModule::ArrayObjectVirtualTableGV; sizeElement = mvm::jit::constantPtrSize; } - +#ifndef MULTIPLE_VM LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); - llvm::Value* valCl = LCI->getVar(this); - + valCl = LCI->getVar(this); +#endif llvm::Value* arg1 = popAsInt(); Value* cmp = new ICmpInst(ICmpInst::ICMP_SLT, arg1, @@ -1926,7 +1952,7 @@ currentBlock); new StoreInst(valCl, GEP, currentBlock); - push(res, AssessorDesc::dRef); + push(res, false); break; } @@ -1934,7 +1960,7 @@ case ARRAYLENGTH : { Value* val = pop(); JITVerifyNull(val); - push(arraySize(val), AssessorDesc::dInt); + push(arraySize(val), false); break; } @@ -1957,8 +1983,10 @@ case CHECKCAST : { uint16 index = readU2(bytecodes, i); +#ifndef MULTIPLE_VM CommonClass* dcl = compilingClass->ctpInfo->getMethodClassIfLoaded(index); +#endif Value* obj = top(); @@ -1972,12 +2000,14 @@ BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); currentBlock = ifFalse; Value* clVar = 0; +#ifndef MULTIPLE_VM if (dcl) { LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); clVar = LCI->getVar(this); - } else { + } else +#endif clVar = getResolvedClass(index, false); - } + std::vector args; args.push_back(obj); args.push_back(clVar); @@ -2008,6 +2038,7 @@ case INSTANCEOF : { uint16 index = readU2(bytecodes, i); +#ifndef MULTIPLE_VM CommonClass* dcl = compilingClass->ctpInfo->getMethodClassIfLoaded(index); @@ -2018,6 +2049,9 @@ } else { clVar = getResolvedClass(index, false); } +#else + Value* clVar = getResolvedClass(index, false); +#endif std::vector args; args.push_back(pop()); args.push_back(clVar); @@ -2025,7 +2059,7 @@ args.begin(), args.end(), "", currentBlock); push(new ZExtInst(val, Type::Int32Ty, "", currentBlock), - AssessorDesc::dInt); + false); break; } @@ -2062,19 +2096,23 @@ } case MULTIANEWARRAY : { - JnjvmClassLoader* JCL = compilingClass->classLoader; uint16 index = readU2(bytecodes, i); uint8 dim = readU1(bytecodes, i); + +#ifdef MULTIPLE_VM + Value* valCl = getResolvedClass(index, true); +#else + JnjvmClassLoader* JCL = compilingClass->classLoader; const UTF8* className = compilingClass->ctpInfo->resolveClassName(index); - ClassArray* dcl = JCL->constructArray(className); + UserClassArray* dcl = JCL->constructArray(className); compilingClass->ctpInfo->loadClass(index); - LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); Value* valCl = LCI->getVar(this); +#endif Value** args = (Value**)alloca(sizeof(Value*) * (dim + 2)); args[0] = valCl; args[1] = ConstantInt::get(Type::Int32Ty, dim); @@ -2086,11 +2124,8 @@ for (sint32 v = 0; v < dim + 2; ++v) { Args.push_back(args[v]); } -#ifdef MULTIPLE_VM - Args.push_back(isolateLocal); -#endif push(invoke(JnjvmModule::MultiCallNewFunction, Args, "", currentBlock), - AssessorDesc::dRef); + false); break; } @@ -2100,10 +2135,8 @@ case IFNULL : { uint32 tmp = i; - const AssessorDesc* ass = topFunc(); - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[ass->numId]; - llvm::Value* nil = LAI.llvmNullConstant; llvm::Value* val = pop(); + Constant* nil = Constant::getNullValue(val->getType()); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_EQ, val, nil, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("true IFNULL"); @@ -2115,10 +2148,8 @@ case IFNONNULL : { uint32 tmp = i; - const AssessorDesc* ass = topFunc(); - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[ass->numId]; - llvm::Value* nil = LAI.llvmNullConstant; llvm::Value* val = pop(); + Constant* nil = Constant::getNullValue(val->getType()); llvm::Value* test = new ICmpInst(ICmpInst::ICMP_NE, val, nil, "", currentBlock); BasicBlock* ifFalse = createBasicBlock("false IFNONNULL"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Thu Oct 2 18:28:36 2008 @@ -29,21 +29,22 @@ char const* className, char const* func, char const* sign, int access, ...) { - CommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className), - true, true); + UserCommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className), + true, true); - vm->initialiseClass(cl); + cl->initialiseClass(vm); bool stat = access == ACC_STATIC ? true : false; + UserClass* methodCl = 0; JavaMethod* method = cl->lookupMethod(loader->asciizConstructUTF8(func), loader->asciizConstructUTF8(sign), stat, - true); + true, methodCl); va_list ap; va_start(ap, access); if (stat) { - method->invokeIntStaticAP(vm, ap); + method->invokeIntStaticAP(vm, (UserClass*)cl, ap); } else { JavaObject* obj = va_arg(ap, JavaObject*); - method->invokeIntSpecialAP(vm, obj, ap); + method->invokeIntSpecialAP(vm, (UserClass*)cl, obj, ap); } va_end(ap); } @@ -54,47 +55,51 @@ #define readArgs(buf, signature, ap) \ for (std::vector::iterator i = signature->args.begin(), \ e = signature->args.end(); i!= e; i++) { \ - const AssessorDesc* funcs = (*i)->funcs; \ - if (funcs == AssessorDesc::dLong) { \ - ((sint64*)buf)[0] = va_arg(ap, sint64); \ - buf += 2; \ - } else if (funcs == AssessorDesc::dInt) { \ - ((sint32*)buf)[0] = va_arg(ap, sint32); \ + const Typedef* type = *i;\ + if (type->isPrimitive()){\ + const PrimitiveTypedef* prim = (PrimitiveTypedef*)type;\ + if (prim->isLong()){\ + ((sint64*)buf)[0] = va_arg(ap, sint64);\ + buf += 2;\ + } else if (prim->isInt()){ \ + ((sint32*)buf)[0] = va_arg(ap, sint32);\ + buf++; \ + } else if (prim->isChar()){ \ + ((uint32*)buf)[0] = va_arg(ap, uint32);\ + buf++; \ + } else if (prim->isShort()){ \ + ((uint32*)buf)[0] = va_arg(ap, uint32);\ + buf++; \ + } else if (prim->isByte()){ \ + ((uint32*)buf)[0] = va_arg(ap, uint32);\ + buf++; \ + } else if (prim->isBool()){ \ + ((uint32*)buf)[0] = va_arg(ap, uint32);\ + buf++;\ + } else if (prim->isFloat()){\ + ((float*)buf)[0] = (float)va_arg(ap, double);\ + buf++;\ + } else if (prim->isDouble()){\ + ((double*)buf)[0] = va_arg(ap, double);\ + buf += 2;\ + } else{\ + fprintf(stderr, "Can't happen");\ + abort();\ + }\ + } else{\ + ((JavaObject**)buf)[0] = va_arg(ap, JavaObject*);\ buf++; \ - } else if (funcs == AssessorDesc::dChar) { \ - ((uint32*)buf)[0] = va_arg(ap, uint32); \ - buf++; \ - } else if (funcs == AssessorDesc::dShort) { \ - ((uint32*)buf)[0] = va_arg(ap, uint32); \ - buf++; \ - } else if (funcs == AssessorDesc::dByte) { \ - ((uint32*)buf)[0] = va_arg(ap, uint32); \ - buf++; \ - } else if (funcs == AssessorDesc::dBool) { \ - ((uint32*)buf)[0] = va_arg(ap, uint32); \ - buf++; \ - } else if (funcs == AssessorDesc::dFloat) { \ - ((float*)buf)[0] = (float)va_arg(ap, double); \ - buf++; \ - } else if (funcs == AssessorDesc::dDouble) { \ - ((double*)buf)[0] = va_arg(ap, double); \ - buf += 2; \ - } else if (funcs == AssessorDesc::dRef || funcs == AssessorDesc::dTab) { \ - ((JavaObject**)buf)[0] = va_arg(ap, JavaObject*); \ - buf++; \ - } else { \ - assert(0 && "Should not be here"); \ - } \ - } \ + }\ + }\ #if 1//defined(__PPC__) && !defined(__MACH__) #define INVOKE(TYPE, TYPE_NAME, FUNC_TYPE_VIRTUAL_AP, FUNC_TYPE_STATIC_AP, FUNC_TYPE_VIRTUAL_BUF, FUNC_TYPE_STATIC_BUF) \ \ -TYPE JavaMethod::invoke##TYPE_NAME##VirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap) { \ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##VirtualAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) { \ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ verifyNull(obj); \ Signdef* sign = getSignature(); \ @@ -102,13 +107,13 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = (((void***)obj)[0])[offset];\ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, func, obj, _buf);\ + return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, _buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj);\ @@ -117,13 +122,13 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, func, obj, _buf);\ + return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, _buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, va_list ap) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ Signdef* sign = getSignature(); \ @@ -131,66 +136,67 @@ void* _buf = (void*)buf; \ readArgs(buf, sign, ap); \ void* func = this->compiledPtr();\ - return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, func, _buf);\ + return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getConstantPool(), func, _buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj);\ - JavaMethod* meth = obj->classOf->lookupMethod(name, type, false, true);\ + UserClass* methodCl = 0; \ + JavaMethod* meth = obj->classOf->lookupMethod(name, type, false, true, methodCl);\ \ Signdef* sign = getSignature(); \ void* func = meth->compiledPtr();\ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, func, obj, buf);\ + return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, func, obj, buf);\ + return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, void* buf) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, func, buf);\ + return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getConstantPool(), func, buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, JavaObject* obj, ...) { \ +TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \ va_list ap;\ va_start(ap, obj);\ - TYPE res = invoke##TYPE_NAME##VirtualAP(vm, obj, ap);\ + TYPE res = invoke##TYPE_NAME##VirtualAP(vm, cl, obj, ap);\ va_end(ap); \ return res; \ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##Special(Jnjvm* vm, JavaObject* obj, ...) {\ +TYPE JavaMethod::invoke##TYPE_NAME##Special(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) {\ va_list ap;\ va_start(ap, obj);\ - TYPE res = invoke##TYPE_NAME##SpecialAP(vm, obj, ap);\ + TYPE res = invoke##TYPE_NAME##SpecialAP(vm, cl, obj, ap);\ va_end(ap); \ return res; \ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##Static(Jnjvm* vm, ...) {\ +TYPE JavaMethod::invoke##TYPE_NAME##Static(Jnjvm* vm, UserClass* cl, ...) {\ va_list ap;\ - va_start(ap, vm);\ - TYPE res = invoke##TYPE_NAME##StaticAP(vm, ap);\ + va_start(ap, cl);\ + TYPE res = invoke##TYPE_NAME##StaticAP(vm, cl, ap);\ va_end(ap); \ return res; \ }\ @@ -199,125 +205,125 @@ #define INVOKE(TYPE, TYPE_NAME, FUNC_TYPE_VIRTUAL_AP, FUNC_TYPE_STATIC_AP, FUNC_TYPE_VIRTUAL_BUF, FUNC_TYPE_STATIC_BUF) \ \ -TYPE JavaMethod::invoke##TYPE_NAME##VirtualAP(Jnjvm* vm, JavaObject* obj, va_list ap) { \ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##VirtualAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) { \ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj); \ void* func = (((void***)obj)[0])[offset];\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, func, obj, ap);\ + return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, cl->getConstantPool(), func, obj, ap);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, JavaObject* obj, va_list ap) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##SpecialAP(Jnjvm* vm, UserClass* cl, JavaObject* obj, va_list ap) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, func, obj, ap);\ + return ((FUNC_TYPE_VIRTUAL_AP)sign->getVirtualCallAP())(vm, cl->getConstantPool(), func, obj, ap);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, va_list ap) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, UserClass* cl, va_list ap) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(vm, func, ap);\ + return ((FUNC_TYPE_STATIC_AP)sign->getStaticCallAP())(vm, cl->getConstantPool(), func, ap);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##VirtualBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj);\ void* func = (((void***)obj)[0])[offset];\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, func, obj, buf);\ + return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, JavaObject* obj, void* buf) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##SpecialBuf(Jnjvm* vm, UserClass* cl, JavaObject* obj, void* buf) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ verifyNull(obj);\ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, func, obj, buf);\ + return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, void* buf) {\ - if (!classDef->isReady()) { \ - classDef->classLoader->loadName(classDef->name, true, true); \ - vm->initialiseClass(classDef); \ +TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, UserClass* cl, void* buf) {\ + if (!cl->isReady()) { \ + cl->classLoader->loadName(cl->getName(), true, true); \ + cl->initialiseClass(vm); \ } \ \ void* func = this->compiledPtr();\ Signdef* sign = getSignature(); \ - return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, func, buf);\ + return ((FUNC_TYPE_STATIC_BUF)sign->getStaticCallBuf())(vm, cl->getConstantPool(), func, buf);\ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm,JavaObject* obj, ...) { \ +TYPE JavaMethod::invoke##TYPE_NAME##Virtual(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) { \ va_list ap;\ va_start(ap, obj);\ - TYPE res = invoke##TYPE_NAME##VirtualAP(vm, obj, ap);\ + TYPE res = invoke##TYPE_NAME##VirtualAP(vm, cl, obj, ap);\ va_end(ap); \ return res; \ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##Special(Jnjvm* vm, JavaObject* obj, ...) {\ +TYPE JavaMethod::invoke##TYPE_NAME##Special(Jnjvm* vm, UserClass* cl, JavaObject* obj, ...) {\ va_list ap;\ va_start(ap, obj);\ - TYPE res = invoke##TYPE_NAME##SpecialAP(vm, obj, ap);\ + TYPE res = invoke##TYPE_NAME##SpecialAP(vm, cl, obj, ap);\ va_end(ap); \ return res; \ }\ \ -TYPE JavaMethod::invoke##TYPE_NAME##Static(Jnjvm* vm, ...) {\ +TYPE JavaMethod::invoke##TYPE_NAME##Static(Jnjvm* vm, UserClass* cl, ...) {\ va_list ap;\ - va_start(ap, this);\ - TYPE res = invoke##TYPE_NAME##StaticAP(vm, ap);\ + va_start(ap, cl);\ + TYPE res = invoke##TYPE_NAME##StaticAP(vm, cl, ap);\ va_end(ap); \ return res; \ }\ #endif -typedef uint32 (*uint32_virtual_ap)(Jnjvm*, void*, JavaObject*, va_list); -typedef sint64 (*sint64_virtual_ap)(Jnjvm*, void*, JavaObject*, va_list); -typedef float (*float_virtual_ap)(Jnjvm*, void*, JavaObject*, va_list); -typedef double (*double_virtual_ap)(Jnjvm*, void*, JavaObject*, va_list); -typedef JavaObject* (*object_virtual_ap)(Jnjvm*, void*, JavaObject*, va_list); - -typedef uint32 (*uint32_static_ap)(Jnjvm*, void*, va_list); -typedef sint64 (*sint64_static_ap)(Jnjvm*, void*, va_list); -typedef float (*float_static_ap)(Jnjvm*, void*, va_list); -typedef double (*double_static_ap)(Jnjvm*, void*, va_list); -typedef JavaObject* (*object_static_ap)(Jnjvm*, void*, va_list); - -typedef uint32 (*uint32_virtual_buf)(Jnjvm*, void*, JavaObject*, void*); -typedef sint64 (*sint64_virtual_buf)(Jnjvm*, void*, JavaObject*, void*); -typedef float (*float_virtual_buf)(Jnjvm*, void*, JavaObject*, void*); -typedef double (*double_virtual_buf)(Jnjvm*, void*, JavaObject*, void*); -typedef JavaObject* (*object_virtual_buf)(Jnjvm*, void*, JavaObject*, void*); - -typedef uint32 (*uint32_static_buf)(Jnjvm*, void*, void*); -typedef sint64 (*sint64_static_buf)(Jnjvm*, void*, void*); -typedef float (*float_static_buf)(Jnjvm*, void*, void*); -typedef double (*double_static_buf)(Jnjvm*, void*, void*); -typedef JavaObject* (*object_static_buf)(Jnjvm*, void*, void*); +typedef uint32 (*uint32_virtual_ap)(Jnjvm*, UserConstantPool*, void*, JavaObject*, va_list); +typedef sint64 (*sint64_virtual_ap)(Jnjvm*, UserConstantPool*, void*, JavaObject*, va_list); +typedef float (*float_virtual_ap)(Jnjvm*, UserConstantPool*, void*, JavaObject*, va_list); +typedef double (*double_virtual_ap)(Jnjvm*, UserConstantPool*, void*, JavaObject*, va_list); +typedef JavaObject* (*object_virtual_ap)(Jnjvm*, UserConstantPool*, void*, JavaObject*, va_list); + +typedef uint32 (*uint32_static_ap)(Jnjvm*, UserConstantPool*, void*, va_list); +typedef sint64 (*sint64_static_ap)(Jnjvm*, UserConstantPool*, void*, va_list); +typedef float (*float_static_ap)(Jnjvm*, UserConstantPool*, void*, va_list); +typedef double (*double_static_ap)(Jnjvm*, UserConstantPool*, void*, va_list); +typedef JavaObject* (*object_static_ap)(Jnjvm*, UserConstantPool*, void*, va_list); + +typedef uint32 (*uint32_virtual_buf)(Jnjvm*, UserConstantPool*, void*, JavaObject*, void*); +typedef sint64 (*sint64_virtual_buf)(Jnjvm*, UserConstantPool*, void*, JavaObject*, void*); +typedef float (*float_virtual_buf)(Jnjvm*, UserConstantPool*, void*, JavaObject*, void*); +typedef double (*double_virtual_buf)(Jnjvm*, UserConstantPool*, void*, JavaObject*, void*); +typedef JavaObject* (*object_virtual_buf)(Jnjvm*, UserConstantPool*, void*, JavaObject*, void*); + +typedef uint32 (*uint32_static_buf)(Jnjvm*, UserConstantPool*, void*, void*); +typedef sint64 (*sint64_static_buf)(Jnjvm*, UserConstantPool*, void*, void*); +typedef float (*float_static_buf)(Jnjvm*, UserConstantPool*, void*, void*); +typedef double (*double_static_buf)(Jnjvm*, UserConstantPool*, void*, void*); +typedef JavaObject* (*object_static_buf)(Jnjvm*, UserConstantPool*, void*, void*); INVOKE(uint32, Int, uint32_virtual_ap, uint32_static_ap, uint32_virtual_buf, uint32_static_buf) INVOKE(sint64, Long, sint64_virtual_ap, sint64_static_ap, sint64_virtual_buf, sint64_static_buf) Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Thu Oct 2 18:28:36 2008 @@ -159,7 +159,7 @@ void JavaObject::print(mvm::PrintBuffer* buf) const { buf->write("JavaObject<"); - CommonClass::printClassName(classOf->name, buf); + CommonClass::printClassName(classOf->getName(), buf); buf->write(">"); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Thu Oct 2 18:28:36 2008 @@ -129,7 +129,7 @@ /// classOf - The class of this object. /// - CommonClass* classOf; + UserCommonClass* classOf; /// lock - The monitor of this object. Most of the time null. /// @@ -156,7 +156,7 @@ /// initialise - Initialises the object. /// - void initialise(CommonClass* cl) { + void initialise(UserCommonClass* cl) { this->classOf = cl; this->lock = 0; } @@ -170,7 +170,7 @@ /// instanceOf - Is this object's class of type the given class? /// - bool instanceOf(CommonClass* cl) { + bool instanceOf(UserCommonClass* cl) { if (!this) return false; else return this->classOf->isAssignableFrom(cl); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Oct 2 18:28:36 2008 @@ -30,20 +30,11 @@ using namespace jnjvm; -#ifdef MULTIPLE_VM -extern "C" JavaString* stringLookup(Class* cl, uint32 index) { - JavaConstantPool* ctpInfo = cl->getConstantPool(); - const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); - JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); - return str; -} -#endif - extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) { Enveloppe* enveloppe = cache->enveloppe; - JavaConstantPool* ctpInfo = enveloppe->ctpInfo; - CommonClass* ocl = obj->classOf; - CommonClass* cl = 0; + UserConstantPool* ctpInfo = enveloppe->ctpInfo; + UserCommonClass* ocl = obj->classOf; + UserCommonClass* cl = 0; const UTF8* utf8 = 0; Signdef* sign = 0; uint32 index = enveloppe->index; @@ -67,9 +58,13 @@ } if (!rcache) { - JavaMethod* dmeth = ocl->lookupMethod(utf8, sign->keyName, false, true); + UserClass* methodCl = 0; + JavaMethod* dmeth = ocl->lookupMethod(utf8, sign->keyName, false, true, + methodCl); +#ifndef MULTIPLE_VM assert(dmeth->classDef->isReady() && "Class not ready in a virtual lookup."); +#endif if (cache->methPtr) { rcache = new CacheNode(enveloppe); } else { @@ -77,7 +72,10 @@ } rcache->methPtr = dmeth->compiledPtr(); - rcache->lastCible = (Class*)ocl; + rcache->lastCible = (UserClass*)ocl; +#ifdef MULTIPLE_VM + rcache->definingCtp = methodCl->getConstantPool(); +#endif } @@ -93,37 +91,157 @@ return rcache->methPtr; } -extern "C" void* fieldLookup(JavaObject* obj, Class* caller, uint32 index, - uint32 stat) { - JavaConstantPool* ctpInfo = caller->getConstantPool(); +extern "C" void* virtualFieldLookup(UserClass* caller, uint32 index) { + UserConstantPool* ctpInfo = caller->getConstantPool(); if (ctpInfo->ctpRes[index]) { return ctpInfo->ctpRes[index]; } - CommonClass* cl = 0; + UserCommonClass* cl = 0; + UserCommonClass* fieldCl = 0; const UTF8* utf8 = 0; Typedef* sign = 0; ctpInfo->resolveField(index, cl, utf8, sign); - JavaField* field = cl->lookupField(utf8, sign->keyName, stat, true); + JavaField* field = cl->lookupField(utf8, sign->keyName, false, true, fieldCl); - void* ptr = 0; - if (stat) { - Class* fieldCl = field->classDef; - JavaThread::get()->isolate->initialiseClass(fieldCl); - ptr = (void*)((uint64)(fieldCl->staticInstance()) + field->ptrOffset); -#ifndef MULTIPLE_VM - ctpInfo->ctpRes[index] = ptr; -#endif - } else { - ptr = (void*)((uint64)obj + field->ptrOffset); - ctpInfo->ctpRes[index] = (void*)field->ptrOffset; + ctpInfo->ctpRes[index] = (void*)field->ptrOffset; + + return (void*)field->ptrOffset; +} + +extern "C" void* staticFieldLookup(UserClass* caller, uint32 index) { + UserConstantPool* ctpInfo = caller->getConstantPool(); + + if (ctpInfo->ctpRes[index]) { + return ctpInfo->ctpRes[index]; } + UserCommonClass* cl = 0; + UserCommonClass* fieldCl = 0; + const UTF8* utf8 = 0; + Typedef* sign = 0; + + ctpInfo->resolveField(index, cl, utf8, sign); + + JavaField* field = cl->lookupField(utf8, sign->keyName, true, true, fieldCl); + + fieldCl->initialiseClass(JavaThread::get()->isolate); + void* ptr = + (void*)((uint64)(((UserClass*)fieldCl)->getStaticInstance()) + field->ptrOffset); + ctpInfo->ctpRes[index] = ptr; + return ptr; } +#ifdef MULTIPLE_VM +extern "C" void* stringLookup(UserClass* cl, uint32 index) { + UserConstantPool* ctpInfo = cl->getConstantPool(); + const UTF8* utf8 = ctpInfo->UTF8AtForString(index); + JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); + ctpInfo->ctpRes[index] = str; + return (void*)str; +} + +extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) { + UserConstantPool* ctpInfo = cl->getConstantPool(); + Enveloppe* enveloppe = new 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()->isolate); + + 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" UserClassArray* getArrayClass(UserCommonClass* cl) { + JnjvmClassLoader* JCL = cl->classLoader; + const UTF8* arrayName = JCL->constructArrayName(1, cl->getName()); + + UserClassArray* dcl = JCL->constructArray(arrayName); + return dcl; +} + +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 + +#ifndef WITHOUT_VTABLE +extern "C" void* vtableLookup(UserClass* caller, uint32 index, ...) { + UserCommonClass* cl = 0; + const UTF8* utf8 = 0; + Signdef* sign = 0; + + caller->getConstantPool()->resolveMethod(index, cl, utf8, sign); + UserClass* methodCl = 0; + JavaMethod* dmeth = cl->lookupMethodDontThrow(utf8, sign->keyName, false, + true, methodCl); + if (!dmeth) { + va_list ap; + va_start(ap, index); + JavaObject* obj = va_arg(ap, JavaObject*); + va_end(ap); + assert(obj->classOf->isReady() && "Class not ready in a virtual lookup."); + // Arg, the bytecode is buggy! Perform the lookup on the object class + // and do not update offset. + dmeth = obj->classOf->lookupMethod(utf8, sign->keyName, false, true, + methodCl); + } else { + caller->getConstantPool()->ctpRes[index] = (void*)dmeth->offset; + } + +#ifndef MULTIPLE_VM + assert(dmeth->classDef->isReady() && "Class not ready in a virtual lookup."); +#endif + + return (void*)dmeth->offset; +} +#endif + +extern "C" void* classLookup(UserClass* caller, uint32 index) { + UserConstantPool* ctpInfo = caller->getConstantPool(); + UserClass* cl = (UserClass*)ctpInfo->loadClass(index); + // We can not initialize here, because bytecodes such as CHECKCAST + // or classes used in catch clauses do not trigger class initialization. + // This is really sad, because we need to insert class initialization checks + // in the LLVM code. + return (void*)cl; +} + + extern "C" void printMethodStart(JavaMethod* meth) { printf("[%d] executing %s\n", mvm::Thread::self(), meth->printString()); fflush(stdout); @@ -169,82 +287,36 @@ JavaThread::get()->isolate->outOfMemoryError(val); } -extern "C" void jnjvmClassCastException(JavaObject* obj, CommonClass* cl) { - JavaThread::get()->isolate->classCastException(""); +extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) { + JavaThread::get()->isolate->classCastException(obj, cl); } extern "C" void indexOutOfBoundsException(JavaObject* obj, sint32 index) { JavaThread::get()->isolate->indexOutOfBounds(obj, index); } -#ifdef MULTIPLE_VM -extern "C" JavaObject* getStaticInstance(Class* cl, Jnjvm* vm) { - std::pair* val = vm->statics->lookup(cl); - if (!val || !(val->second)) { - vm->initialiseClass(cl); - val = vm->statics->lookup(cl); - } - return val->second; -} -#endif - -extern "C" CommonClass* initialisationCheck(CommonClass* cl) { - JavaThread::get()->isolate->initialiseClass(cl); +extern "C" UserCommonClass* initialisationCheck(UserCommonClass* cl) { + cl->initialiseClass(JavaThread::get()->isolate); return cl; } -extern "C" JavaObject* getClassDelegatee(CommonClass* cl) { +extern "C" JavaObject* getClassDelegatee(UserCommonClass* cl) { Jnjvm* vm = JavaThread::get()->isolate; - return vm->getClassDelegatee(cl); -} - -extern "C" Class* newLookup(Class* caller, uint32 index) { - JavaConstantPool* ctpInfo = caller->getConstantPool(); - Class* cl = (Class*)ctpInfo->loadClass(index); - return cl; + return cl->getClassDelegatee(vm); } -#ifndef WITHOUT_VTABLE -extern "C" uint32 vtableLookup(JavaObject* obj, Class* caller, uint32 index) { - CommonClass* cl = 0; - const UTF8* utf8 = 0; - Signdef* sign = 0; - - caller->getConstantPool()->resolveMethod(index, cl, utf8, sign); - JavaMethod* dmeth = cl->lookupMethodDontThrow(utf8, sign->keyName, false, - true); - assert(obj->classOf->isReady() && "Class not ready in a virtual lookup."); - if (!dmeth) { - // Arg, it should have been an invoke interface.... Perform the lookup - // on the object class and do not update offset. - dmeth = obj->classOf->lookupMethod(utf8, sign->keyName, false, true); - } else { - caller->getConstantPool()->ctpRes[index] = (void*)dmeth->offset; - } - - assert(dmeth->classDef->isReady() && "Class not ready in a virtual lookup."); - - return dmeth->offset; -} -#endif - - -static JavaArray* multiCallNewIntern(arrayCtor_t ctor, ClassArray* cl, - uint32 len, - sint32* dims, - Jnjvm* vm) { +static JavaArray* multiCallNewIntern(UserClassArray* cl, uint32 len, + sint32* dims, Jnjvm* vm) { if (len <= 0) JavaThread::get()->isolate->unknownError("Can not happen"); - JavaArray* _res = ctor(dims[0], cl, vm); + JavaArray* _res = cl->doNew(dims[0], vm); if (len > 1) { ArrayObject* res = (ArrayObject*)_res; - CommonClass* _base = cl->baseClass(); - if (_base->isArray) { - ClassArray* base = (ClassArray*)_base; - AssessorDesc* func = base->funcs(); - arrayCtor_t newCtor = func->arrayCtor; + UserCommonClass* _base = cl->baseClass(); + if (_base->isArray()) { + UserClassArray* base = (UserClassArray*)_base; if (dims[0] > 0) { for (sint32 i = 0; i < dims[0]; ++i) { - res->elements[i] = multiCallNewIntern(newCtor, base, (len - 1), + res->elements[i] = multiCallNewIntern(base, (len - 1), &dims[1], vm); } } else { @@ -260,19 +332,15 @@ return _res; } -extern "C" JavaArray* multiCallNew(ClassArray* cl, uint32 len, ...) { +extern "C" JavaArray* multiCallNew(UserClassArray* cl, uint32 len, ...) { va_list ap; va_start(ap, len); sint32* dims = (sint32*)alloca(sizeof(sint32) * len); for (uint32 i = 0; i < len; ++i){ dims[i] = va_arg(ap, int); } -#ifdef MULTIPLE_VM - Jnjvm* vm = va_arg(ap, Jnjvm*); -#else - Jnjvm* vm = 0; -#endif - return multiCallNewIntern((arrayCtor_t)ArrayObject::acons, cl, len, dims, vm); + Jnjvm* vm = JavaThread::get()->isolate; + return multiCallNewIntern(cl, len, dims, vm); } extern "C" void JavaObjectAquire(JavaObject* obj) { @@ -309,19 +377,19 @@ } #endif -extern "C" bool instanceOf(JavaObject* obj, CommonClass* cl) { +extern "C" bool instanceOf(JavaObject* obj, UserCommonClass* cl) { return obj->instanceOf(cl); } -extern "C" bool instantiationOfArray(CommonClass* cl1, ClassArray* cl2) { +extern "C" bool instantiationOfArray(UserCommonClass* cl1, UserClassArray* cl2) { return cl1->instantiationOfArray(cl2); } -extern "C" bool implements(CommonClass* cl1, CommonClass* cl2) { +extern "C" bool implements(UserCommonClass* cl1, UserCommonClass* cl2) { return cl1->implements(cl2); } -extern "C" bool isAssignableFrom(CommonClass* cl1, CommonClass* cl2) { +extern "C" bool isAssignableFrom(UserCommonClass* cl1, UserCommonClass* cl2) { return cl1->isAssignableFrom(cl2); } @@ -337,7 +405,7 @@ return JavaThread::getJavaException(); } -extern "C" bool JavaThreadCompareException(Class* cl) { +extern "C" bool JavaThreadCompareException(UserClass* cl) { return JavaThread::compareException(cl); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Thu Oct 2 18:28:36 2008 @@ -17,13 +17,18 @@ JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) { - Class* cl = Classpath::newString; - JavaString* res = (JavaString*)malloc(cl->virtualSize); - ((void**)res)[0] = cl->virtualVT; + UserClass* cl = vm->upcalls->newString; + JavaString* res = (JavaString*)malloc(cl->getVirtualSize()); +#ifdef MULTIPLE_VM + /// Do this for now, but we will have to change it to duplicate the UTF8. + /// UTF8 that dont have a class are shared UTF8. + if (!utf8->classOf) ((UTF8*)utf8)->classOf = vm->upcalls->ArrayOfChar; +#endif + ((void**)res)[0] = cl->getVirtualVT(); res->classOf = cl; - // no need to call the function - // Classpath::initString->run(res, utf8, 0, utf8->size, true); + // No need to call the Java function: both the Java function and + // this function do the same thing. res->value = utf8; res->count = utf8->size; res->offset = 0; @@ -44,7 +49,8 @@ const UTF8* utf8 = this->value; if (offset || (offset + count <= utf8->size)) { // TODO find a way to get a relevant hashUTF8 - return utf8->extract(JnjvmClassLoader::bootstrapLoader->hashUTF8, offset, offset + count); + UTF8Map* map = vm->bootstrapLoader->hashUTF8; + return utf8->extract(map, offset, offset + count); } else { return utf8; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Thu Oct 2 18:28:36 2008 @@ -100,7 +100,7 @@ th->internalPendingException = 0; } - static bool compareException(Class* cl) { + static bool compareException(UserClass* cl) { JavaObject* pe = JavaThread::get()->pendingException; assert(pe && "no pending exception?"); bool val = pe->classOf->subclassOf(cl); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Thu Oct 2 18:28:36 2008 @@ -18,130 +18,12 @@ #include "JavaJIT.h" #include "JavaThread.h" #include "JavaTypes.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" using namespace jnjvm; -const char AssessorDesc::I_TAB = '['; -const char AssessorDesc::I_END_REF = ';'; -const char AssessorDesc::I_PARG = '('; -const char AssessorDesc::I_PARD = ')'; -const char AssessorDesc::I_BYTE = 'B'; -const char AssessorDesc::I_CHAR = 'C'; -const char AssessorDesc::I_DOUBLE = 'D'; -const char AssessorDesc::I_FLOAT = 'F'; -const char AssessorDesc::I_INT = 'I'; -const char AssessorDesc::I_LONG = 'J'; -const char AssessorDesc::I_REF = 'L'; -const char AssessorDesc::I_SHORT = 'S'; -const char AssessorDesc::I_VOID = 'V'; -const char AssessorDesc::I_BOOL = 'Z'; -const char AssessorDesc::I_SEP = '/'; - -AssessorDesc* AssessorDesc::dParg = 0; -AssessorDesc* AssessorDesc::dPard = 0; -AssessorDesc* AssessorDesc::dVoid = 0; -AssessorDesc* AssessorDesc::dBool = 0; -AssessorDesc* AssessorDesc::dByte = 0; -AssessorDesc* AssessorDesc::dChar = 0; -AssessorDesc* AssessorDesc::dShort = 0; -AssessorDesc* AssessorDesc::dInt = 0; -AssessorDesc* AssessorDesc::dFloat = 0; -AssessorDesc* AssessorDesc::dLong = 0; -AssessorDesc* AssessorDesc::dDouble = 0; -AssessorDesc* AssessorDesc::dTab = 0; -AssessorDesc* AssessorDesc::dRef = 0; - -AssessorDesc::AssessorDesc(bool dt, char bid, uint32 nb, uint32 nw, - const char* name, - JnjvmClassLoader* loader, uint8 nid, - const char* assocName, ClassArray* cl, - arrayCtor_t ctor) { - AssessorDesc* res = this; - res->numId = nid; - res->doTrace = dt; - res->byteId = bid; - res->nbb = nb; - res->nbw = nw; - res->asciizName = name; - res->UTF8Name = loader->asciizConstructUTF8(name); - res->arrayCtor = ctor; - - res->arrayClass = cl; - if (assocName) - res->assocClassName = loader->asciizConstructUTF8(assocName); - else - res->assocClassName = 0; - - if (bid != I_PARG && bid != I_PARD && bid != I_REF && bid != I_TAB) { - res->classType = new ClassPrimitive(loader, res->UTF8Name); - res->classType->virtualSize = nb; - } else { - res->classType = 0; - } -} -void AssessorDesc::initialise(JnjvmClassLoader* vm) { - - dParg = new AssessorDesc(false, I_PARG, 0, 0, "(", vm, 0, 0, 0, - 0); - dPard = new AssessorDesc(false, I_PARD, 0, 0, ")", vm, 0, 0, 0, - 0); - dVoid = new AssessorDesc(false, I_VOID, 0, 0, "void", - vm, VOID_ID, "java/lang/Void", 0, 0); - dBool = new AssessorDesc(false, I_BOOL, 1, 1, "boolean", - vm, - BOOL_ID, "java/lang/Boolean", - JavaArray::ofBool, - (arrayCtor_t)ArrayUInt8::acons); - dByte = new AssessorDesc(false, I_BYTE, 1, 1, "byte", - vm, BYTE_ID, "java/lang/Byte", - JavaArray::ofByte, - (arrayCtor_t)ArraySInt8::acons); - dChar = new AssessorDesc(false, I_CHAR, 2, 1, "char", - vm, CHAR_ID, "java/lang/Character", - JavaArray::ofChar, - (arrayCtor_t)ArrayUInt16::acons); - dShort = new AssessorDesc(false, I_SHORT, 2, 1, "short", - vm, SHORT_ID, - "java/lang/Short", - JavaArray::ofShort, - (arrayCtor_t)ArraySInt16::acons); - dInt = new AssessorDesc(false, I_INT, 4, 1, "int", vm, - INT_ID, "java/lang/Integer", - JavaArray::ofInt, - (arrayCtor_t)ArraySInt32::acons); - dFloat = new AssessorDesc(false, I_FLOAT, 4, 1, "float", - vm, - FLOAT_ID, "java/lang/Float", - JavaArray::ofFloat, - (arrayCtor_t)ArrayFloat::acons); - dLong = new AssessorDesc(false, I_LONG, 8, 2, "long", - vm, LONG_ID, "java/lang/Long", - JavaArray::ofLong, - (arrayCtor_t)ArrayLong::acons); - dDouble = new AssessorDesc(false, I_DOUBLE, 8, 2, "double", - vm, - DOUBLE_ID, "java/lang/Double", - JavaArray::ofDouble, - (arrayCtor_t)ArrayDouble::acons); - dTab = new AssessorDesc(true, I_TAB, sizeof(void*), 1, "array", - vm, ARRAY_ID, 0, 0, - (arrayCtor_t)ArrayObject::acons); - dRef = new AssessorDesc(true, I_REF, sizeof(void*), 1, "reference", - vm, OBJECT_ID, - 0, 0, - (arrayCtor_t)ArrayObject::acons); - -} - -const char* AssessorDesc::printString() const { - mvm::PrintBuffer *buf= mvm::PrintBuffer::alloc(); - buf->write("AssessorDescriptor<"); - buf->write(asciizName); - buf->write(">"); - return buf->contents()->cString(); -} static void typeError(const UTF8* name, short int l) { if (l != 0) { @@ -154,251 +36,71 @@ } -void AssessorDesc::analyseIntern(const UTF8* name, uint32 pos, - uint32 meth, AssessorDesc*& ass, - uint32& ret) { +static bool analyseIntern(const UTF8* name, uint32 pos, uint32 meth, + uint32& ret) { short int cur = name->elements[pos]; switch (cur) { - case I_PARG : - ass = dParg; - ret = pos + 1; - break; case I_PARD : - ass = dPard; ret = pos + 1; - break; + return true; case I_BOOL : - ass = dBool; ret = pos + 1; - break; + return false; case I_BYTE : - ass = dByte; ret = pos + 1; - break; + return false; case I_CHAR : - ass = dChar; ret = pos + 1; - break; + return false; case I_SHORT : - ass = dShort; ret = pos + 1; - break; + return false; case I_INT : - ass = dInt; ret = pos + 1; - break; + return false; case I_FLOAT : - ass = dFloat; ret = pos + 1; - break; + return false; case I_DOUBLE : - ass = dDouble; ret = pos + 1; - break; + return false; case I_LONG : - ass = dLong; ret = pos + 1; - break; + return false; case I_VOID : - ass = dVoid; ret = pos + 1; - break; + return false; case I_TAB : if (meth == 1) { pos++; } else { - AssessorDesc * typeIntern = dTab; while (name->elements[++pos] == I_TAB) {} - analyseIntern(name, pos, 1, typeIntern, pos); + analyseIntern(name, pos, 1, pos); } - ass = dTab; ret = pos; - break; + return false; case I_REF : if (meth != 2) { while (name->elements[++pos] != I_END_REF) {} } - ass = dRef; ret = pos + 1; - break; + return false; default : typeError(name, cur); } + return false; } -const UTF8* AssessorDesc::constructArrayName(JnjvmClassLoader *loader, AssessorDesc* ass, - uint32 steps, - const UTF8* className) { - if (ass) { - uint16* buf = (uint16*)alloca((steps + 1) * sizeof(uint16)); - for (uint32 i = 0; i < steps; i++) { - buf[i] = I_TAB; - } - buf[steps] = ass->byteId; - return loader->readerConstructUTF8(buf, steps + 1); - } else { - uint32 len = className->size; - uint32 pos = steps; - AssessorDesc * funcs = (className->elements[0] == I_TAB ? dTab : dRef); - uint32 n = steps + len + (funcs == dRef ? 2 : 0); - uint16* buf = (uint16*)alloca(n * sizeof(uint16)); - - for (uint32 i = 0; i < steps; i++) { - buf[i] = I_TAB; - } - - if (funcs == dRef) { - ++pos; - buf[steps] = funcs->byteId; - } - - for (uint32 i = 0; i < len; i++) { - buf[pos + i] = className->elements[i]; - } - - if (funcs == dRef) { - buf[n - 1] = I_END_REF; - } - - return loader->readerConstructUTF8(buf, n); - } -} - -/* -void AssessorDesc::introspectArrayName(Jnjvm *vm, const UTF8* utf8, - uint32 start, AssessorDesc*& ass, - const UTF8*& res) { - uint32 pos = 0; - uint32 intern = 0; - AssessorDesc* funcs = 0; - - analyseIntern(utf8, start, 1, funcs, intern); - - if (funcs != dTab) { - vm->unknownError("%s isn't an array", utf8->printString()); - } - - analyseIntern(utf8, intern, 0, funcs, pos); - - if (funcs == dRef) { - ass = dRef; - res = utf8->extract(vm, intern + 1, pos - 1); - } else if (funcs == dTab) { - ass = dTab; - res = utf8->extract(vm, intern, pos); - } else { - ass = funcs; - res = 0; - } -} -*/ -void AssessorDesc::introspectArray(JnjvmClassLoader* loader, - const UTF8* utf8, uint32 start, - AssessorDesc*& ass, CommonClass*& res) { - uint32 pos = 0; - uint32 intern = 0; - AssessorDesc* funcs = 0; - - analyseIntern(utf8, start, 1, funcs, intern); - - if (funcs != dTab) { - Jnjvm* vm = JavaThread::get()->isolate; - vm->unknownError("%s isn't an array", utf8->printString()); - } - - analyseIntern(utf8, intern, 0, funcs, pos); - - if (funcs == dRef) { - ass = dRef; - const UTF8* temp = utf8->extract(loader->hashUTF8, intern + 1, pos - 1); - res = loader->loadName(temp, false, true); - } else if (funcs == dTab) { - ass = dTab; - res = loader->constructArray(utf8->extract(loader->hashUTF8, intern, pos)); - } else { - ass = funcs; - res = funcs->classType; - } -} - -AssessorDesc* AssessorDesc::arrayType(unsigned int t) { - if (t == JavaArray::T_CHAR) { - return AssessorDesc::dChar; - } else if (t == JavaArray::T_BOOLEAN) { - return AssessorDesc::dBool; - } else if (t == JavaArray::T_INT) { - return AssessorDesc::dInt; - } else if (t == JavaArray::T_SHORT) { - return AssessorDesc::dShort; - } else if (t == JavaArray::T_BYTE) { - return AssessorDesc::dByte; - } else if (t == JavaArray::T_FLOAT) { - return AssessorDesc::dFloat; - } else if (t == JavaArray::T_LONG) { - return AssessorDesc::dLong; - } else if (t == JavaArray::T_DOUBLE) { - return AssessorDesc::dDouble; - } else { - JavaThread::get()->isolate->unknownError("unknown array type %d\n", t); - return 0; - } -} - -void Typedef::tPrintBuf(mvm::PrintBuffer* buf) const { - if (pseudoAssocClassName == 0) - buf->write(funcs->asciizName); - else - CommonClass::printClassName(pseudoAssocClassName, buf); +void PrimitiveTypedef::tPrintBuf(mvm::PrintBuffer* buf) const { + prim->name->print(buf); } -AssessorDesc* AssessorDesc::byteIdToPrimitive(char id) { - switch (id) { - case I_FLOAT : - return dFloat; - case I_INT : - return dInt; - case I_SHORT : - return dShort; - case I_CHAR : - return dChar; - case I_DOUBLE : - return dDouble; - case I_BYTE : - return dByte; - case I_BOOL : - return dBool; - case I_LONG : - return dLong; - case I_VOID : - return dVoid; - default : - return 0; - } +void ArrayTypedef::tPrintBuf(mvm::PrintBuffer* buf) const { + CommonClass::printClassName(keyName, buf); } -AssessorDesc* AssessorDesc::classToPrimitive(CommonClass* cl) { - const UTF8* name = cl->name; - if (name == dFloat->assocClassName) { - return dFloat; - } else if (name == dInt->assocClassName) { - return dInt; - } else if (name == dShort->assocClassName) { - return dShort; - } else if (name == dChar->assocClassName) { - return dChar; - } else if (name == dDouble->assocClassName) { - return dDouble; - } else if (name == dByte->assocClassName) { - return dByte; - } else if (name == dBool->assocClassName) { - return dBool; - } else if (name == dLong->assocClassName) { - return dLong; - } else if (name == dVoid->assocClassName) { - return dVoid; - } else { - return 0; - } +void ObjectTypedef::tPrintBuf(mvm::PrintBuffer* buf) const { + CommonClass::printClassName(pseudoAssocClassName, buf); } const char* Typedef::printString() const { @@ -409,14 +111,12 @@ return buf->contents()->cString(); } -CommonClass* Typedef::assocClass(JnjvmClassLoader* loader) { - if (pseudoAssocClassName == 0) { - return funcs->classType; - } else if (funcs == AssessorDesc::dRef) { - return loader->loadName(pseudoAssocClassName, false, true); - } else { - return loader->constructArray(pseudoAssocClassName); - } +UserCommonClass* ArrayTypedef::assocClass(JnjvmClassLoader* loader) const { + return loader->constructArray(keyName); +} + +UserCommonClass* ObjectTypedef::assocClass(JnjvmClassLoader* loader) const { + return loader->loadName(pseudoAssocClassName, false, true); } void Typedef::humanPrintArgs(const std::vector* args, @@ -457,12 +157,11 @@ uint32 len = (uint32)name->size; uint32 pos = 1; uint32 pred = 0; - AssessorDesc* funcs = 0; while (pos < len) { pred = pos; - AssessorDesc::analyseIntern(name, pos, 0, funcs, pos); - if (funcs == AssessorDesc::dPard) break; + bool end = analyseIntern(name, pos, 0, pos); + if (end) break; else { buf.push_back(loader->constructType(name->extract(loader->hashUTF8, pred, pos))); } @@ -472,7 +171,7 @@ typeError(name, 0); } - AssessorDesc::analyseIntern(name, pos, 0, funcs, pred); + analyseIntern(name, pos, 0, pred); if (pred != len) { typeError(name, 0); @@ -490,25 +189,28 @@ } -Typedef::Typedef(const UTF8* name, JnjvmClassLoader *loader) { - Typedef* res = this; - AssessorDesc* funcs = 0; - uint32 next; - AssessorDesc::analyseIntern(name, 0, 0, funcs, next); - - assert(funcs != AssessorDesc::dParg && - "Error: resolving a signature for a field"); - res->initialLoader = loader; - res->keyName = name; - res->funcs = funcs; - if (funcs == AssessorDesc::dRef) { - res->pseudoAssocClassName = name->extract(loader->hashUTF8, 1, next - 1); - } else if (funcs == AssessorDesc::dTab) { - res->pseudoAssocClassName = name; - } else { - res->pseudoAssocClassName = 0; +Typedef* Typedef::constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm) { + short int cur = name->elements[0]; + Typedef* res = 0; + switch (cur) { + case I_TAB : + res = new ArrayTypedef(name); + break; + case I_REF : + res = new ObjectTypedef(name, map); + break; + default : + UserClassPrimitive* cl = vm->getPrimitiveClass((char)name->elements[0]); + assert(cl && "No primitive"); + bool unsign = (cl == vm->upcalls->OfChar || cl == vm->upcalls->OfBool); + res = new PrimitiveTypedef(name, cl, unsign, cur); } + return res; +} +ObjectTypedef::ObjectTypedef(const UTF8* name, UTF8Map* map) { + keyName = name; + pseudoAssocClassName = name->extract(map, 1, name->size - 1); } intptr_t Signdef::staticCallBuf() { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h Thu Oct 2 18:28:36 2008 @@ -17,14 +17,20 @@ namespace jnjvm { +class Classpath; class ClassArray; class CommonClass; class JavaArray; class JavaJIT; class JavaObject; class Jnjvm; +class JnjvmBootstrapLoader; class JnjvmClassLoader; +class UserClassArray; +class UserClassPrimitive; +class UserCommonClass; class UTF8; +class UTF8Map; #define VOID_ID 0 #define BOOL_ID 1 @@ -35,239 +41,223 @@ #define FLOAT_ID 6 #define LONG_ID 7 #define DOUBLE_ID 8 -#define ARRAY_ID 9 -#define OBJECT_ID 10 +#define OBJECT_ID 9 +#define ARRAY_ID 10 #define NUM_ASSESSORS 11 -typedef JavaArray* (*arrayCtor_t)(uint32 len, CommonClass* cl, Jnjvm* vm); +static const char I_TAB = '['; +static const char I_END_REF = ';'; +static const char I_PARG = '('; +static const char I_PARD = ')'; +static const char I_BYTE = 'B'; +static const char I_CHAR = 'C'; +static const char I_DOUBLE = 'D'; +static const char I_FLOAT = 'F'; +static const char I_INT = 'I'; +static const char I_LONG = 'J'; +static const char I_REF = 'L'; +static const char I_SHORT = 'S'; +static const char I_VOID = 'V'; +static const char I_BOOL = 'Z'; +static const char I_SEP = '/'; - -/// AssessorDesc - Description of a Java assessor: these are the letters found -/// in Java signatures, e.g. "I" or "(". +/// Typedef - Each class has a Typedef representation. A Typedef is also a class +/// which has not been loaded yet. Typedefs are hashed on the name of the class. +/// Hashing is for memory purposes, not for comparison. /// -class AssessorDesc { +class Typedef { public: - static VirtualTable *VT; - static const char I_TAB; - static const char I_END_REF; - static const char I_PARG; - static const char I_PARD; - static const char I_BYTE; - static const char I_CHAR; - static const char I_DOUBLE; - static const char I_FLOAT; - static const char I_INT; - static const char I_LONG; - static const char I_REF; - static const char I_SHORT; - static const char I_VOID; - static const char I_BOOL; - static const char I_SEP; - /// doTrace - Is this assessor for garbage collected objects? True for - /// the "L" assessor and the "[" assessor. - /// - bool doTrace; - - /// byteId - Letter reprensenting this assessor. - /// - char byteId; - - /// nbb - Number of bytes of instances of this assessor (e.g. 4 for "I"). - /// - uint32 nbb; - - /// nbw - Number of words of instances if this assessor (e.g. 8 for "D"). + /// keyName - The name of the Typedef. It is the representation of a class + /// in a Java signature, e.g. "Ljava/lang/Object;". /// - uint32 nbw; - - /// numId - A byte identifier from 0 to the number of assessors. + const UTF8* keyName; + + /// humanPrintArgs - Prints the list of typedef in a human readable form. /// - uint8 numId; + static void humanPrintArgs(const std::vector*, + mvm::PrintBuffer* buf); - /// asciizName - The name of the assessor in asciiz, e.g. "void" for "V". + /// tPrintBuf - Prints the name of the class this Typedef represents. /// - const char* asciizName; + virtual void tPrintBuf(mvm::PrintBuffer* buf) const = 0; - /// UTF8Name - The name of the assessor in UTF8, e.g. "void" for "V". + /// printString - Print the Typedef for debugging purposes. /// - const UTF8* UTF8Name; - - /// classType - The primitive Java class of this assessor. This class - /// is internal to the JVM. + const char* printString() const; + + /// assocClass - Given the loaded, try to load the class represented by this + /// Typedef. /// - CommonClass* classType; - - /// assocClassName - The associated class name, e.g. "java/lang/Integer" for - /// "I". + virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const = 0; + + /// Typedef - Create a new Typedef. /// - const UTF8* assocClassName; + static Typedef* constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm); + + virtual bool trace() const = 0; - /// arrayClass - The primitive array class of the assessor, e.g. I[] for "I". - /// - ClassArray* arrayClass; + virtual bool isPrimitive() const { + return false; + } + + virtual bool isReference() const { + return true; + } + + virtual bool isUnsigned() const { + return false; + } - /// arrayCtor - The constructor of an array of this assessor. - /// - arrayCtor_t arrayCtor; + virtual const UTF8* getName() const { + return keyName; + } -//===----------------------------------------------------------------------===// -// -// The set of assessors in Java. This set is unique and there are no other -// assessors. -// -//===----------------------------------------------------------------------===// + const UTF8* getKey() const { + return keyName; + } +}; - /// dParg - The "(" assessor. +class PrimitiveTypedef : public Typedef { +private: + UserClassPrimitive* prim; + bool unsign; + char charId; + +public: + + /// tPrintBuf - Prints the name of the class this Typedef represents. /// - static AssessorDesc* dParg; + virtual void tPrintBuf(mvm::PrintBuffer* buf) const; + - /// dPard - The ")" assessor. - /// - static AssessorDesc* dPard; + virtual bool trace() const { + return false; + } + + virtual bool isPrimitive() const { + return true; + } + + virtual bool isReference() const { + return false; + } - /// dVoid - The "V" assessor. - /// - static AssessorDesc* dVoid; + virtual bool isUnsigned() const { + return unsign; + } - /// dBool - The "Z" assessor. - /// - static AssessorDesc* dBool; + virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const { + return (UserCommonClass*)prim; + } - /// dByte - The "B" assessor. - /// - static AssessorDesc* dByte; + PrimitiveTypedef(const UTF8* name, UserClassPrimitive* cl, bool u, char i) { + keyName = name; + prim = cl; + unsign = u; + charId = i; + } + + bool isVoid() const { + return charId == I_VOID; + } - /// dChar - The "C" assessor. - /// - static AssessorDesc* dChar; + bool isLong() const { + return charId == I_LONG; + } - /// dShort - The "S" assessor. - /// - static AssessorDesc* dShort; + bool isInt() const { + return charId == I_INT; + } - /// dInt - The "I" assessor. - /// - static AssessorDesc* dInt; + bool isChar() const { + return charId == I_CHAR; + } - /// dFloat - The "F" assessor. - /// - static AssessorDesc* dFloat; + bool isShort() const { + return charId == I_SHORT; + } - /// dLong - The "J" assessor. - /// - static AssessorDesc* dLong; + bool isByte() const { + return charId == I_BYTE; + } - /// dDouble - The "D" assessor. - /// - static AssessorDesc* dDouble; + bool isBool() const { + return charId == I_BOOL; + } - /// dTab - The "[" assessor. - /// - static AssessorDesc* dTab; + bool isFloat() const { + return charId == I_FLOAT; + } - /// dRef - The "L" assessor. - /// - static AssessorDesc* dRef; + bool isDouble() const { + return charId == I_DOUBLE; + } -//===----------------------------------------------------------------------===// -// -// End of assessors. -// -//===----------------------------------------------------------------------===// - - /// AssessorDesc - Construct an assessor. + /// JInfo - Holds info useful for the JIT. /// - AssessorDesc(bool dt, char bid, uint32 nb, uint32 nw, - const char* name, - JnjvmClassLoader* loader, uint8 nid, - const char* assocName, ClassArray* cl, - arrayCtor_t ctor); - + mvm::JITInfo* JInfo; - /// initialise - Construct all assessors. + /// getInfo - Get the JIT info of this signature. The info is created lazely. /// - static void initialise(JnjvmClassLoader* loader); - + template + Ty *getInfo() { + if (!JInfo) { + JInfo = new Ty(this); + } - /// printString - Print the assessor for debugging purposes. - /// - const char* printString() const; + assert((void*)dynamic_cast(JInfo) == (void*)JInfo && + "Invalid concrete type or multiple inheritence for getInfo"); + return static_cast(JInfo); + } +}; - static void analyseIntern(const UTF8* name, uint32 pos, - uint32 meth, AssessorDesc*& ass, - uint32& ret); - - static const UTF8* constructArrayName(JnjvmClassLoader* loader, AssessorDesc* ass, - uint32 steps, const UTF8* className); - - /* - static void introspectArrayName(const UTF8* utf8, uint32 start, - AssessorDesc*& ass, const UTF8*& res); - */ - static void introspectArray(JnjvmClassLoader* loader, const UTF8* utf8, - uint32 start, AssessorDesc*& ass, - CommonClass*& res); +class ArrayTypedef : public Typedef { +public: + /// tPrintBuf - Prints the name of the class this Typedef represents. + /// + virtual void tPrintBuf(mvm::PrintBuffer* buf) const; - static AssessorDesc* arrayType(unsigned int t); - static AssessorDesc* byteIdToPrimitive(const char id); - static AssessorDesc* classToPrimitive(CommonClass* cl); - -}; + virtual bool trace() const { + return true; + } + virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const; -/// Typedef - Each class has a Typedef representation. A Typedef is also a class -/// which has not been loaded yet. Typedefs are hashed on the name of the class. -/// Hashing is for memory purposes, not for comparison. -/// -class Typedef { -public: - - /// keyName - The name of the Typedef. It is the representation of a class - /// in a Java signature, e.g. "Ljava/lang/Object;". - /// - const UTF8* keyName; + ArrayTypedef(const UTF8* name) { + keyName = name; + } +}; +class ObjectTypedef : public Typedef { +private: /// pseudoAssocClassName - The real name of the class this Typedef /// represents, e.g. "java/lang/Object" /// const UTF8* pseudoAssocClassName; - /// funcs - The assessor for this Typedef. All Typedef must have the dRef - /// or the dTab assessor, except the primive Typedefs. - /// - const AssessorDesc* funcs; - - /// initialLoader - The loader that first loaded this typedef. - /// - JnjvmClassLoader* initialLoader; - - /// printString - Print the Typedef for debugging purposes. +public: + /// tPrintBuf - Prints the name of the class this Typedef represents. /// - const char* printString() const; + virtual void tPrintBuf(mvm::PrintBuffer* buf) const; - /// assocClass - Given the loaded, try to load the class represented by this - /// Typedef. - /// - CommonClass* assocClass(JnjvmClassLoader* loader); - - /// humanPrintArgs - Prints the list of typedef in a human readable form. - /// - static void humanPrintArgs(const std::vector*, - mvm::PrintBuffer* buf); + virtual bool trace() const { + return true; + } - /// Typedef - Create a new Typedef. - /// - Typedef(const UTF8* name, JnjvmClassLoader* loader); + virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const; + + ObjectTypedef(const UTF8*name, UTF8Map* map); - /// tPrintBuf - Prints the name of the class this Typedef represents. - /// - void tPrintBuf(mvm::PrintBuffer* buf) const; + virtual const UTF8* getName() const { + return pseudoAssocClassName; + } }; + /// Signdef - This class represents a Java signature. Each Java method has a /// Java signature. Signdefs are hashed for memory purposes, not equality /// purposes. @@ -302,7 +292,7 @@ /// intptr_t _virtualCallAP; intptr_t virtualCallAP(); - + public: /// args - The arguments as Typedef of this signature. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Thu Oct 2 18:28:36 2008 @@ -36,6 +36,7 @@ using namespace jnjvm; +#ifndef MULTIPLE_VM Class* Classpath::newThread; Class* Classpath::newVMThread; JavaField* Classpath::assocThread; @@ -48,10 +49,13 @@ JavaField* Classpath::daemon; JavaField* Classpath::group; JavaField* Classpath::running; +Class* Classpath::threadGroup; JavaField* Classpath::rootGroup; JavaField* Classpath::vmThread; JavaMethod* Classpath::uncaughtException; +Class* Classpath::inheritableThreadLocal; +JavaMethod* Classpath::runVMThread; JavaMethod* Classpath::setContextClassLoader; JavaMethod* Classpath::getSystemClassLoader; Class* Classpath::newString; @@ -85,6 +89,8 @@ JavaField* Classpath::bufferAddress; JavaField* Classpath::dataPointer32; JavaField* Classpath::vmdataClassLoader; +Class* Classpath::newClassLoader; + JavaField* Classpath::boolValue; JavaField* Classpath::byteValue; @@ -177,40 +183,72 @@ JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError; JavaMethod* Classpath::ErrorWithExcpInvocationTargetException; +ClassArray* Classpath::ArrayOfByte; +ClassArray* Classpath::ArrayOfChar; +ClassArray* Classpath::ArrayOfString; +ClassArray* Classpath::ArrayOfInt; +ClassArray* Classpath::ArrayOfShort; +ClassArray* Classpath::ArrayOfBool; +ClassArray* Classpath::ArrayOfLong; +ClassArray* Classpath::ArrayOfFloat; +ClassArray* Classpath::ArrayOfDouble; +ClassArray* Classpath::ArrayOfObject; + +ClassPrimitive* Classpath::OfByte; +ClassPrimitive* Classpath::OfChar; +ClassPrimitive* Classpath::OfInt; +ClassPrimitive* Classpath::OfShort; +ClassPrimitive* Classpath::OfBool; +ClassPrimitive* Classpath::OfLong; +ClassPrimitive* Classpath::OfFloat; +ClassPrimitive* Classpath::OfDouble; +ClassPrimitive* Classpath::OfVoid; + +JavaField* Classpath::methodClass; +JavaField* Classpath::fieldClass; +JavaField* Classpath::constructorClass; + +#endif + void Classpath::createInitialThread(Jnjvm* vm, JavaObject* th) { - JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader; - JCL->loadName(newVMThread->name, true, true); - vm->initialiseClass(newVMThread); + JnjvmClassLoader* JCL = vm->bootstrapLoader; + JCL->loadName(newVMThread->getName(), true, true); + newVMThread->initialiseClass(vm); JavaObject* vmth = newVMThread->doNew(vm); - name->setVirtualObjectField(th, (JavaObject*)vm->asciizToStr("main")); - priority->setVirtualInt32Field(th, (uint32)1); - daemon->setVirtualInt8Field(th, (uint32)0); - vmThread->setVirtualObjectField(th, vmth); - assocThread->setVirtualObjectField(vmth, th); - running->setVirtualInt8Field(vmth, (uint32)1); - - JCL->loadName(rootGroup->classDef->name, true, true); - vm->initialiseClass(rootGroup->classDef); - JavaObject* RG = rootGroup->getStaticObjectField(); - group->setVirtualObjectField(th, RG); - groupAddThread->invokeIntSpecial(vm, RG, th); + name->setObjectField(th, (JavaObject*)vm->asciizToStr("main")); + priority->setInt32Field(th, (uint32)1); + daemon->setInt8Field(th, (uint32)0); + vmThread->setObjectField(th, vmth); + assocThread->setObjectField(vmth, th); + running->setInt8Field(vmth, (uint32)1); + + JCL->loadName(threadGroup->getName(), true, true); + threadGroup->initialiseClass(vm); + JavaObject* Stat = threadGroup->getStaticInstance(); + JavaObject* RG = rootGroup->getObjectField(Stat); + group->setObjectField(th, RG); + groupAddThread->invokeIntSpecial(vm, threadGroup, RG, th); } void Classpath::mapInitialThread(Jnjvm* vm) { - JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader; - JCL->loadName(newThread->name, true, true); - vm->initialiseClass(newThread); + JnjvmClassLoader* JCL = vm->bootstrapLoader; + JCL->loadName(newThread->getName(), true, true); + newThread->initialiseClass(vm); JavaObject* th = newThread->doNew(vm); createInitialThread(vm, th); JavaThread* myth = JavaThread::get(); myth->javaThread = th; - JavaObject* vmth = vmThread->getVirtualObjectField(th); - vmdataVMThread->setVirtualObjectField(vmth, (JavaObject*)myth); - finaliseCreateInitialThread->invokeIntStatic(vm, th); + JavaObject* vmth = vmThread->getObjectField(th); + vmdataVMThread->setObjectField(vmth, (JavaObject*)myth); + finaliseCreateInitialThread->invokeIntStatic(vm, inheritableThreadLocal, th); } void Classpath::initialiseClasspath(JnjvmClassLoader* loader) { + + newClassLoader = + UPCALL_CLASS(loader, "java/lang/ClassLoader"); + getSystemClassLoader = UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader", "()Ljava/lang/ClassLoader;", ACC_STATIC); @@ -479,6 +517,9 @@ UPCALL_FIELD(loader, "java/lang/VMThread", "vmdata", "Ljava/lang/Object;", ACC_VIRTUAL); + inheritableThreadLocal = + UPCALL_CLASS(loader, "java/lang/InheritableThreadLocal"); + finaliseCreateInitialThread = UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal", "newChildThread", "(Ljava/lang/Thread;)V", ACC_STATIC); @@ -486,6 +527,10 @@ initVMThread = UPCALL_METHOD(loader, "java/lang/VMThread", "", "(Ljava/lang/Thread;)V", ACC_VIRTUAL); + + runVMThread = + UPCALL_METHOD(loader, "java/lang/VMThread", "run", "()V", ACC_VIRTUAL); + groupAddThread = UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread", @@ -508,6 +553,9 @@ running = UPCALL_FIELD(loader, "java/lang/VMThread", "running", "Z", ACC_VIRTUAL); + threadGroup = + UPCALL_CLASS(loader, "java/lang/ThreadGroup"); + rootGroup = UPCALL_FIELD(loader, "java/lang/ThreadGroup", "root", "Ljava/lang/ThreadGroup;", ACC_STATIC); @@ -520,6 +568,18 @@ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "uncaughtException", "(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL); + + methodClass = + UPCALL_FIELD(loader, "java/lang/reflect/Method", "declaringClass", + "Ljava/lang/Class;", ACC_VIRTUAL); + + fieldClass = + UPCALL_FIELD(loader, "java/lang/reflect/Field", "declaringClass", + "Ljava/lang/Class;", ACC_VIRTUAL); + + constructorClass = + UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "clazz", + "Ljava/lang/Class;", ACC_VIRTUAL); loader->loadName(loader->asciizConstructUTF8("java/lang/String"), true, false); @@ -553,8 +613,9 @@ } extern "C" uint8 isArray(JavaObject* klass) { - CommonClass* cl = - (CommonClass*)((Classpath::vmdataClass->getVirtualObjectField(klass))); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = + (UserCommonClass*)((vm->upcalls->vmdataClass->getObjectField(klass))); - return (uint8)cl->isArray; + return (uint8)cl->isArray(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Thu Oct 2 18:28:36 2008 @@ -10,27 +10,30 @@ #ifndef JNJVM_JAVA_UPCALLS_H #define JNJVM_JAVA_UPCALLS_H +#include "JnjvmConfig.h" -#define UPCALL_CLASS(vm, name) \ +#define UPCALL_CLASS(vm, name) \ vm->loadName(vm->asciizConstructUTF8(name), false, false) -#define UPCALL_FIELD(vm, cl, name, type, acc) \ - UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \ +#define UPCALL_PRIMITIVE_CLASS(loader, name, nb) \ + new UserClassPrimitive(loader, loader->asciizConstructUTF8(name), nb) + +#define UPCALL_FIELD(vm, cl, name, type, acc) \ + UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \ vm->asciizConstructUTF8(type), acc) -#define UPCALL_METHOD(vm, cl, name, type, acc) \ - UPCALL_CLASS(vm, cl)->constructMethod(vm->asciizConstructUTF8(name), \ +#define UPCALL_METHOD(vm, cl, name, type, acc) \ + UPCALL_CLASS(vm, cl)->constructMethod(vm->asciizConstructUTF8(name), \ vm->asciizConstructUTF8(type), acc) -#define UPCALL_ARRAY_CLASS(vm, name, depth) \ - vm->constructArray( \ - AssessorDesc::constructArrayName(vm, 0, depth, \ - vm->asciizConstructUTF8(name))) +#define UPCALL_ARRAY_CLASS(loader, name, depth) \ + loader->constructArray( \ + loader->constructArrayName(depth, loader->asciizConstructUTF8(name))) -#define UPCALL_CLASS_EXCEPTION(loader, name) \ +#define UPCALL_CLASS_EXCEPTION(loader, name) \ name = UPCALL_CLASS(loader, "java/lang/"#name) -#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name) \ +#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name) \ name = UPCALL_CLASS(loader, "java/lang/reflect/"#name) #define UPCALL_METHOD_EXCEPTION(loader, name) \ @@ -53,151 +56,182 @@ class Classpath { public: - static JavaMethod* getSystemClassLoader; - static JavaMethod* setContextClassLoader; - static Class* newString; - static Class* newClass; - static Class* newThrowable; - static Class* newException; - static JavaMethod* initClass; - static JavaMethod* initClassWithProtectionDomain; - static JavaField* vmdataClass; - static JavaMethod* setProperty; - static JavaMethod* initString; - static JavaMethod* getCallingClassLoader; - static JavaMethod* initConstructor; - static ClassArray* constructorArrayClass; - static ClassArray* constructorArrayAnnotation; - static Class* newConstructor; - static JavaField* constructorSlot; - static JavaMethod* initMethod; - static JavaMethod* initField; - static ClassArray* methodArrayClass; - static ClassArray* fieldArrayClass; - static Class* newMethod; - static Class* newField; - static JavaField* methodSlot; - static JavaField* fieldSlot; - static ClassArray* classArrayClass; - static JavaMethod* loadInClassLoader; - static JavaMethod* initVMThrowable; - static JavaField* vmDataVMThrowable; - static Class* newVMThrowable; - static JavaField* bufferAddress; - static JavaField* dataPointer32; - static JavaField* vmdataClassLoader; - - static JavaField* boolValue; - static JavaField* byteValue; - static JavaField* shortValue; - static JavaField* charValue; - static JavaField* intValue; - static JavaField* longValue; - static JavaField* floatValue; - static JavaField* doubleValue; - - static Class* newStackTraceElement; - static ClassArray* stackTraceArray; - static JavaMethod* initStackTraceElement; - - static void initialiseClasspath(JnjvmClassLoader* loader); - - static Class* voidClass; - static Class* boolClass; - static Class* byteClass; - static Class* shortClass; - static Class* charClass; - static Class* intClass; - static Class* floatClass; - static Class* doubleClass; - static Class* longClass; - - static Class* vmStackWalker; - - static Class* newThread; - static Class* newVMThread; - static JavaField* assocThread; - static JavaField* vmdataVMThread; - static JavaMethod* finaliseCreateInitialThread; - static JavaMethod* initVMThread; - static JavaMethod* groupAddThread; - static JavaField* name; - static JavaField* priority; - static JavaField* daemon; - static JavaField* group; - static JavaField* running; - static JavaField* rootGroup; - static JavaField* vmThread; - static JavaMethod* uncaughtException; - - static Class* InvocationTargetException; - static Class* ArrayStoreException; - static Class* ClassCastException; - static Class* IllegalMonitorStateException; - static Class* IllegalArgumentException; - static Class* InterruptedException; - static Class* IndexOutOfBoundsException; - static Class* ArrayIndexOutOfBoundsException; - static Class* NegativeArraySizeException; - static Class* NullPointerException; - static Class* SecurityException; - static Class* ClassFormatError; - static Class* ClassCircularityError; - static Class* NoClassDefFoundError; - static Class* UnsupportedClassVersionError; - static Class* NoSuchFieldError; - static Class* NoSuchMethodError; - static Class* InstantiationError; - static Class* IllegalAccessError; - static Class* IllegalAccessException; - static Class* VerifyError; - static Class* ExceptionInInitializerError; - static Class* LinkageError; - static Class* AbstractMethodError; - static Class* UnsatisfiedLinkError; - static Class* InternalError; - static Class* OutOfMemoryError; - static Class* StackOverflowError; - static Class* UnknownError; - static Class* ClassNotFoundException; - - static JavaMethod* InitInvocationTargetException; - static JavaMethod* InitArrayStoreException; - static JavaMethod* InitClassCastException; - static JavaMethod* InitIllegalMonitorStateException; - static JavaMethod* InitIllegalArgumentException; - static JavaMethod* InitInterruptedException; - static JavaMethod* InitIndexOutOfBoundsException; - static JavaMethod* InitArrayIndexOutOfBoundsException; - static JavaMethod* InitNegativeArraySizeException; - static JavaMethod* InitNullPointerException; - static JavaMethod* InitSecurityException; - static JavaMethod* InitClassFormatError; - static JavaMethod* InitClassCircularityError; - static JavaMethod* InitNoClassDefFoundError; - static JavaMethod* InitUnsupportedClassVersionError; - static JavaMethod* InitNoSuchFieldError; - static JavaMethod* InitNoSuchMethodError; - static JavaMethod* InitInstantiationError; - static JavaMethod* InitIllegalAccessError; - static JavaMethod* InitIllegalAccessException; - static JavaMethod* InitVerifyError; - static JavaMethod* InitExceptionInInitializerError; - static JavaMethod* InitLinkageError; - static JavaMethod* InitAbstractMethodError; - static JavaMethod* InitUnsatisfiedLinkError; - static JavaMethod* InitInternalError; - static JavaMethod* InitOutOfMemoryError; - static JavaMethod* InitStackOverflowError; - static JavaMethod* InitUnknownError; - static JavaMethod* InitClassNotFoundException; - - static JavaMethod* ErrorWithExcpNoClassDefFoundError; - static JavaMethod* ErrorWithExcpExceptionInInitializerError; - static JavaMethod* ErrorWithExcpInvocationTargetException; + ISOLATE_STATIC UserClass* newClassLoader; + ISOLATE_STATIC JavaMethod* getSystemClassLoader; + ISOLATE_STATIC JavaMethod* setContextClassLoader; + ISOLATE_STATIC UserClass* newString; + ISOLATE_STATIC UserClass* newClass; + ISOLATE_STATIC UserClass* newThrowable; + ISOLATE_STATIC UserClass* newException; + ISOLATE_STATIC JavaMethod* initClass; + ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain; + ISOLATE_STATIC JavaField* vmdataClass; + ISOLATE_STATIC JavaMethod* setProperty; + ISOLATE_STATIC JavaMethod* initString; + ISOLATE_STATIC JavaMethod* getCallingClassLoader; + ISOLATE_STATIC JavaMethod* initConstructor; + ISOLATE_STATIC UserClassArray* constructorArrayClass; + ISOLATE_STATIC UserClassArray* constructorArrayAnnotation; + ISOLATE_STATIC UserClass* newConstructor; + ISOLATE_STATIC JavaField* constructorSlot; + ISOLATE_STATIC JavaMethod* initMethod; + ISOLATE_STATIC JavaMethod* initField; + ISOLATE_STATIC UserClassArray* methodArrayClass; + ISOLATE_STATIC UserClassArray* fieldArrayClass; + ISOLATE_STATIC UserClass* newMethod; + ISOLATE_STATIC UserClass* newField; + ISOLATE_STATIC JavaField* methodSlot; + ISOLATE_STATIC JavaField* fieldSlot; + ISOLATE_STATIC UserClassArray* classArrayClass; + ISOLATE_STATIC JavaMethod* loadInClassLoader; + ISOLATE_STATIC JavaMethod* initVMThrowable; + ISOLATE_STATIC JavaField* vmDataVMThrowable; + ISOLATE_STATIC UserClass* newVMThrowable; + ISOLATE_STATIC JavaField* bufferAddress; + ISOLATE_STATIC JavaField* dataPointer32; + ISOLATE_STATIC JavaField* vmdataClassLoader; + + ISOLATE_STATIC JavaField* boolValue; + ISOLATE_STATIC JavaField* byteValue; + ISOLATE_STATIC JavaField* shortValue; + ISOLATE_STATIC JavaField* charValue; + ISOLATE_STATIC JavaField* intValue; + ISOLATE_STATIC JavaField* longValue; + ISOLATE_STATIC JavaField* floatValue; + ISOLATE_STATIC JavaField* doubleValue; + + ISOLATE_STATIC UserClass* newStackTraceElement; + ISOLATE_STATIC UserClassArray* stackTraceArray; + ISOLATE_STATIC JavaMethod* initStackTraceElement; + + ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader); + + ISOLATE_STATIC UserClass* voidClass; + ISOLATE_STATIC UserClass* boolClass; + ISOLATE_STATIC UserClass* byteClass; + ISOLATE_STATIC UserClass* shortClass; + ISOLATE_STATIC UserClass* charClass; + ISOLATE_STATIC UserClass* intClass; + ISOLATE_STATIC UserClass* floatClass; + ISOLATE_STATIC UserClass* doubleClass; + ISOLATE_STATIC UserClass* longClass; + + ISOLATE_STATIC UserClass* vmStackWalker; + + ISOLATE_STATIC UserClass* newThread; + ISOLATE_STATIC UserClass* newVMThread; + ISOLATE_STATIC JavaField* assocThread; + ISOLATE_STATIC JavaField* vmdataVMThread; + ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread; + ISOLATE_STATIC JavaMethod* initVMThread; + ISOLATE_STATIC JavaMethod* runVMThread; + ISOLATE_STATIC JavaMethod* groupAddThread; + ISOLATE_STATIC JavaField* name; + ISOLATE_STATIC JavaField* priority; + ISOLATE_STATIC JavaField* daemon; + ISOLATE_STATIC JavaField* group; + ISOLATE_STATIC JavaField* running; + ISOLATE_STATIC UserClass* threadGroup; + ISOLATE_STATIC JavaField* rootGroup; + ISOLATE_STATIC JavaField* vmThread; + ISOLATE_STATIC JavaMethod* uncaughtException; + ISOLATE_STATIC UserClass* inheritableThreadLocal; + + + ISOLATE_STATIC UserClass* InvocationTargetException; + ISOLATE_STATIC UserClass* ArrayStoreException; + ISOLATE_STATIC UserClass* ClassCastException; + ISOLATE_STATIC UserClass* IllegalMonitorStateException; + ISOLATE_STATIC UserClass* IllegalArgumentException; + ISOLATE_STATIC UserClass* InterruptedException; + ISOLATE_STATIC UserClass* IndexOutOfBoundsException; + ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException; + ISOLATE_STATIC UserClass* NegativeArraySizeException; + ISOLATE_STATIC UserClass* NullPointerException; + ISOLATE_STATIC UserClass* SecurityException; + ISOLATE_STATIC UserClass* ClassFormatError; + ISOLATE_STATIC UserClass* ClassCircularityError; + ISOLATE_STATIC UserClass* NoClassDefFoundError; + ISOLATE_STATIC UserClass* UnsupportedClassVersionError; + ISOLATE_STATIC UserClass* NoSuchFieldError; + ISOLATE_STATIC UserClass* NoSuchMethodError; + ISOLATE_STATIC UserClass* InstantiationError; + ISOLATE_STATIC UserClass* IllegalAccessError; + ISOLATE_STATIC UserClass* IllegalAccessException; + ISOLATE_STATIC UserClass* VerifyError; + ISOLATE_STATIC UserClass* ExceptionInInitializerError; + ISOLATE_STATIC UserClass* LinkageError; + ISOLATE_STATIC UserClass* AbstractMethodError; + ISOLATE_STATIC UserClass* UnsatisfiedLinkError; + ISOLATE_STATIC UserClass* InternalError; + ISOLATE_STATIC UserClass* OutOfMemoryError; + ISOLATE_STATIC UserClass* StackOverflowError; + ISOLATE_STATIC UserClass* UnknownError; + ISOLATE_STATIC UserClass* ClassNotFoundException; + + ISOLATE_STATIC JavaMethod* InitInvocationTargetException; + ISOLATE_STATIC JavaMethod* InitArrayStoreException; + ISOLATE_STATIC JavaMethod* InitClassCastException; + ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException; + ISOLATE_STATIC JavaMethod* InitIllegalArgumentException; + ISOLATE_STATIC JavaMethod* InitInterruptedException; + ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException; + ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException; + ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException; + ISOLATE_STATIC JavaMethod* InitNullPointerException; + ISOLATE_STATIC JavaMethod* InitSecurityException; + ISOLATE_STATIC JavaMethod* InitClassFormatError; + ISOLATE_STATIC JavaMethod* InitClassCircularityError; + ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError; + ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError; + ISOLATE_STATIC JavaMethod* InitNoSuchFieldError; + ISOLATE_STATIC JavaMethod* InitNoSuchMethodError; + ISOLATE_STATIC JavaMethod* InitInstantiationError; + ISOLATE_STATIC JavaMethod* InitIllegalAccessError; + ISOLATE_STATIC JavaMethod* InitIllegalAccessException; + ISOLATE_STATIC JavaMethod* InitVerifyError; + ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError; + ISOLATE_STATIC JavaMethod* InitLinkageError; + ISOLATE_STATIC JavaMethod* InitAbstractMethodError; + ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError; + ISOLATE_STATIC JavaMethod* InitInternalError; + ISOLATE_STATIC JavaMethod* InitOutOfMemoryError; + ISOLATE_STATIC JavaMethod* InitStackOverflowError; + ISOLATE_STATIC JavaMethod* InitUnknownError; + ISOLATE_STATIC JavaMethod* InitClassNotFoundException; + + ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError; + ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError; + ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException; + + ISOLATE_STATIC void createInitialThread(Jnjvm* vm, JavaObject* th); + ISOLATE_STATIC void mapInitialThread(Jnjvm* vm); + + + ISOLATE_STATIC UserClassArray* ArrayOfByte; + ISOLATE_STATIC UserClassArray* ArrayOfChar; + ISOLATE_STATIC UserClassArray* ArrayOfInt; + ISOLATE_STATIC UserClassArray* ArrayOfShort; + ISOLATE_STATIC UserClassArray* ArrayOfBool; + ISOLATE_STATIC UserClassArray* ArrayOfLong; + ISOLATE_STATIC UserClassArray* ArrayOfFloat; + ISOLATE_STATIC UserClassArray* ArrayOfDouble; + ISOLATE_STATIC UserClassArray* ArrayOfObject; + ISOLATE_STATIC UserClassArray* ArrayOfString; + + ISOLATE_STATIC UserClassPrimitive* OfByte; + ISOLATE_STATIC UserClassPrimitive* OfChar; + ISOLATE_STATIC UserClassPrimitive* OfInt; + ISOLATE_STATIC UserClassPrimitive* OfShort; + ISOLATE_STATIC UserClassPrimitive* OfBool; + ISOLATE_STATIC UserClassPrimitive* OfLong; + ISOLATE_STATIC UserClassPrimitive* OfFloat; + ISOLATE_STATIC UserClassPrimitive* OfDouble; + ISOLATE_STATIC UserClassPrimitive* OfVoid; - static void createInitialThread(Jnjvm* vm, JavaObject* th); - static void mapInitialThread(Jnjvm* vm); + ISOLATE_STATIC JavaField* methodClass; + ISOLATE_STATIC JavaField* fieldClass; + ISOLATE_STATIC JavaField* constructorClass; }; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Thu Oct 2 18:28:36 2008 @@ -63,17 +63,18 @@ BEGIN_EXCEPTION JnjvmClassLoader* loader = 0; - Class* currentClass = JavaJIT::getCallingClass(); + Jnjvm* vm = JavaThread::get()->isolate; + UserClass* currentClass = JavaJIT::getCallingClass(); if (currentClass) loader = currentClass->classLoader; - else loader = JnjvmClassLoader::bootstrapLoader; + else loader = vm->bootstrapLoader; const UTF8* utf8 = loader->asciizConstructUTF8(asciiz); sint32 len = utf8->size; - - CommonClass* cl = loader->lookupClassFromUTF8(utf8, 0, len, true, true); - JavaThread::get()->isolate->initialiseClass(cl); - return (jclass)(cl->getClassDelegatee()); + const UTF8* internal = utf8->javaToInternal(loader->hashUTF8, 0, len); + UserCommonClass* cl = loader->lookupClassFromUTF8(internal, true, true); + cl->initialiseClass(vm); + return (jclass)(cl->getClassDelegatee(vm)); END_EXCEPTION return 0; @@ -84,16 +85,17 @@ BEGIN_EXCEPTION + Jnjvm* vm = NativeUtil::myVM(env); + Classpath* upcalls = vm->upcalls; JavaObject* meth = (JavaObject*)method; - CommonClass* cl = meth->classOf; - if (cl == Classpath::newConstructor) { - return (jmethodID)Classpath::constructorSlot->getVirtualInt32Field(meth); - } else if (cl == Classpath::newMethod) { - return (jmethodID)Classpath::methodSlot->getVirtualInt32Field(meth); + UserCommonClass* cl = meth->classOf; + if (cl == upcalls->newConstructor) { + return (jmethodID)upcalls->constructorSlot->getInt32Field(meth); + } else if (cl == upcalls->newMethod) { + return (jmethodID)upcalls->methodSlot->getInt32Field(meth); } else { - JavaThread::get()->isolate->unknownError( - "%s is not a constructor or a method", - meth->printString()); + vm->unknownError("%s is not a constructor or a method", + meth->printString()); } END_EXCEPTION @@ -112,8 +114,8 @@ BEGIN_EXCEPTION - CommonClass* cl2 = NativeUtil::resolvedImplClass(sup, false); - CommonClass* cl1 = NativeUtil::resolvedImplClass(sub, false); + UserCommonClass* cl2 = NativeUtil::resolvedImplClass(sup, false); + UserCommonClass* cl1 = NativeUtil::resolvedImplClass(sub, false); return cl1->isAssignableFrom(cl2); @@ -135,13 +137,14 @@ JavaThread* th = JavaThread::get(); Jnjvm* vm = th->isolate; - CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); - if (cl->isArray) assert(0 && "implement me"); - JavaObject* res = ((Class*)cl)->doNew(vm); - JavaMethod* init = - cl->lookupMethod(Jnjvm::initName, - cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"), 0, 1); - init->invokeIntSpecial(vm, res, vm->asciizToStr(msg)); + UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + if (cl->isArray()) assert(0 && "implement me"); + JavaObject* res = ((UserClass*)cl)->doNew(vm); + UserClass* methodCl = 0; + JavaMethod* init = cl->lookupMethod(Jnjvm::initName, + cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"), + false, true, methodCl); + init->invokeIntSpecial(vm, (UserClass*)cl, res, vm->asciizToStr(msg)); th->pendingException = res; th->returnFromNative(); return 1; @@ -209,9 +212,9 @@ BEGIN_EXCEPTION - CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); - if (cl->isArray) JavaThread::get()->isolate->unknownError("implement me"); - return (jobject)((Class*)cl)->doNew(JavaThread::get()->isolate); + UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + if (cl->isArray()) JavaThread::get()->isolate->unknownError("implement me"); + return (jobject)((UserClass*)cl)->doNew(JavaThread::get()->isolate); END_EXCEPTION return 0; @@ -224,10 +227,10 @@ va_list ap; va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; - Class* cl = (Class*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); Jnjvm* vm = JavaThread::get()->isolate; JavaObject* res = cl->doNew(vm); - meth->invokeIntSpecialAP(vm, res, ap); + meth->invokeIntSpecialAP(vm, cl, res, ap); va_end(ap); return (jobject)res; @@ -245,7 +248,14 @@ jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue *args) { - assert(0 && "implement me"); + BEGIN_EXCEPTION + JavaMethod* meth = (JavaMethod*)methodID; + Class* cl = (Class*)NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + JavaObject* res = cl->doNew(vm); + meth->invokeIntSpecialBuf(vm, cl, res, (void*)args); + return (jobject)res; + END_EXCEPTION return 0; } @@ -255,7 +265,8 @@ BEGIN_EXCEPTION verifyNull((JavaObject*)obj); - return (jclass)((JavaObject*)obj)->classOf->getClassDelegatee(); + Jnjvm* vm = JavaThread::get()->isolate; + return (jclass)((JavaObject*)obj)->classOf->getClassDelegatee(vm); END_EXCEPTION return 0; @@ -294,12 +305,14 @@ BEGIN_EXCEPTION // TODO: find a better place for creating UTF8 - CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); + UserClass* methodCl = 0; JavaMethod* meth = cl->lookupMethod( name->javaToInternal(cl->classLoader->hashUTF8, 0, name->size), - type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), false, true); + type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), false, + true, methodCl); return (jmethodID)meth; @@ -317,7 +330,13 @@ JavaObject* self = (JavaObject*)obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* res = meth->invokeJavaObjectVirtualAP(vm, self, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = self->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + JavaObject* res = meth->invokeJavaObjectVirtualAP(vm, cl, self, ap); va_end(ap); return (jobject)res; @@ -349,7 +368,13 @@ JavaObject* self = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - uint32 res = meth->invokeIntVirtualAP(vm, self, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = self->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + uint32 res = meth->invokeIntVirtualAP(vm, cl, self, ap); va_end(ap); return res; @@ -441,7 +466,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - uint32 res = meth->invokeIntVirtualAP(vm, obj, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + uint32 res = meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -495,7 +526,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - jfloat res = meth->invokeFloatVirtualAP(vm, obj, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + jfloat res = meth->invokeFloatVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -528,7 +565,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - jdouble res = meth->invokeDoubleVirtualAP(vm, obj, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + jdouble res = meth->invokeDoubleVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -545,7 +588,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - return meth->invokeDoubleVirtualAP(vm, obj, args); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + return meth->invokeDoubleVirtualAP(vm, cl, obj, args); END_EXCEPTION return 0.0; @@ -570,7 +619,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - meth->invokeIntVirtualAP(vm, obj, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); END_EXCEPTION @@ -585,7 +640,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - meth->invokeIntVirtualAP(vm, obj, args); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + meth->invokeIntVirtualAP(vm, cl, obj, args); END_EXCEPTION } @@ -805,7 +866,13 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - meth->invokeIntSpecialAP(vm, obj, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = obj->classOf->lookupClassFromMethod(meth); +#else + cl = meth->classDef; +#endif + meth->invokeIntSpecialAP(vm, cl, obj, ap); va_end(ap); END_EXCEPTION @@ -830,10 +897,11 @@ BEGIN_EXCEPTION // TODO: find a better place to store the UTF8 - CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* realCl = 0; return (jfieldID) cl->lookupField(cl->classLoader->asciizConstructUTF8(name), - cl->classLoader->asciizConstructUTF8(sig), 0, 1); + cl->classLoader->asciizConstructUTF8(sig), 0, 1, realCl); END_EXCEPTION return 0; @@ -847,7 +915,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (jobject)field->getVirtualObjectField(o); + return (jobject)field->getObjectField(o); END_EXCEPTION return 0; @@ -860,7 +928,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (uint8)field->getVirtualInt8Field(o); + return (uint8)field->getInt8Field(o); END_EXCEPTION return 0; @@ -873,7 +941,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (sint8)field->getVirtualInt8Field(o); + return (sint8)field->getInt8Field(o); END_EXCEPTION return 0; @@ -886,7 +954,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (uint16)field->getVirtualInt16Field(o); + return (uint16)field->getInt16Field(o); END_EXCEPTION return 0; @@ -899,7 +967,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (sint16)field->getVirtualInt16Field(o); + return (sint16)field->getInt16Field(o); END_EXCEPTION return 0; @@ -912,7 +980,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (sint32)field->getVirtualInt32Field(o); + return (sint32)field->getInt32Field(o); END_EXCEPTION return 0; @@ -925,7 +993,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (sint64)field->getVirtualLongField(o); + return (sint64)field->getLongField(o); END_EXCEPTION return 0; @@ -938,7 +1006,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return field->getVirtualFloatField(o); + return field->getFloatField(o); END_EXCEPTION return 0; @@ -951,7 +1019,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - return (jdouble)field->getVirtualDoubleField(o); + return (jdouble)field->getDoubleField(o); END_EXCEPTION return 0; @@ -964,7 +1032,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualObjectField(o, (JavaObject*)value); + field->setObjectField(o, (JavaObject*)value); END_EXCEPTION } @@ -977,7 +1045,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualInt8Field(o, (uint8)value); + field->setInt8Field(o, (uint8)value); END_EXCEPTION } @@ -989,7 +1057,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualInt8Field(o, (uint8)value); + field->setInt8Field(o, (uint8)value); END_EXCEPTION } @@ -1001,7 +1069,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualInt16Field(o, (uint16)value); + field->setInt16Field(o, (uint16)value); END_EXCEPTION } @@ -1013,7 +1081,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualInt16Field(o, (sint16)value); + field->setInt16Field(o, (sint16)value); END_EXCEPTION } @@ -1025,7 +1093,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualInt32Field(o, (sint32)value); + field->setInt32Field(o, (sint32)value); END_EXCEPTION } @@ -1037,7 +1105,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualLongField(o, (sint64)value); + field->setLongField(o, (sint64)value); END_EXCEPTION } @@ -1049,7 +1117,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualFloatField(o, (float)value); + field->setFloatField(o, (float)value); END_EXCEPTION } @@ -1061,7 +1129,7 @@ JavaField* field = (JavaField*)fieldID; JavaObject* o = (JavaObject*)obj; - field->setVirtualDoubleField(o, (float)value); + field->setDoubleField(o, (float)value); END_EXCEPTION } @@ -1073,12 +1141,14 @@ BEGIN_EXCEPTION // TODO: find a better place to store the UTF8 - CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); + UserClass* methodCl = 0; JavaMethod* meth = cl->lookupMethod( name->javaToInternal(cl->classLoader->hashUTF8, 0, name->size), - type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), true, true); + type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), true, + true, methodCl); return (jmethodID)meth; @@ -1116,7 +1186,13 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - uint32 res = meth->invokeIntStaticAP(vm, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); +#else + cl = meth->classDef; +#endif + uint32 res = meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); return res; @@ -1291,7 +1367,13 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - meth->invokeIntStaticAP(vm, ap); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); +#else + cl = meth->classDef; +#endif + meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); END_EXCEPTION @@ -1305,7 +1387,13 @@ JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - meth->invokeIntStaticAP(vm, args); + UserClass* cl = 0; +#ifdef MULTIPLE_VM + cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); +#else + cl = meth->classDef; +#endif + meth->invokeIntStaticAP(vm, cl, args); END_EXCEPTION } @@ -1323,10 +1411,12 @@ BEGIN_EXCEPTION // TODO: find a better place to store the UTF8 - CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* realCl = 0; return (jfieldID) cl->lookupField(cl->classLoader->asciizConstructUTF8(name), - cl->classLoader->asciizConstructUTF8(sig), true, true); + cl->classLoader->asciizConstructUTF8(sig), true, true, + realCl); END_EXCEPTION return 0; @@ -1338,7 +1428,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jobject)field->getStaticObjectField(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jobject)field->getObjectField(Stat); END_EXCEPTION return 0; @@ -1350,7 +1442,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jboolean)field->getStaticInt8Field(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jboolean)field->getInt8Field(Stat); END_EXCEPTION return 0; @@ -1362,7 +1456,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jbyte)field->getStaticInt8Field(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jbyte)field->getInt8Field(Stat); END_EXCEPTION return 0; @@ -1374,7 +1470,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jchar)field->getStaticInt16Field(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jchar)field->getInt16Field(Stat); END_EXCEPTION return 0; @@ -1386,7 +1484,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jshort)field->getStaticInt16Field(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jshort)field->getInt16Field(Stat); END_EXCEPTION return 0; @@ -1398,7 +1498,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jint)field->getStaticInt32Field(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jint)field->getInt32Field(Stat); END_EXCEPTION return 0; @@ -1410,7 +1512,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jlong)field->getStaticLongField(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jlong)field->getLongField(Stat); END_EXCEPTION return 0; @@ -1422,7 +1526,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jfloat)field->getStaticFloatField(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jfloat)field->getFloatField(Stat); END_EXCEPTION return 0; @@ -1434,7 +1540,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - return (jdouble)field->getStaticDoubleField(); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + return (jdouble)field->getDoubleField(Stat); END_EXCEPTION return 0; @@ -1447,7 +1555,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticObjectField((JavaObject*)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setObjectField(Stat, (JavaObject*)value); END_EXCEPTION } @@ -1459,7 +1569,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticInt8Field((uint8)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setInt8Field(Stat, (uint8)value); END_EXCEPTION } @@ -1471,7 +1583,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticInt8Field((sint8)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setInt8Field(Stat, (sint8)value); END_EXCEPTION } @@ -1483,7 +1597,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticInt16Field((uint16)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setInt16Field(Stat, (uint16)value); END_EXCEPTION } @@ -1495,7 +1611,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticInt16Field((sint16)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setInt16Field(Stat, (sint16)value); END_EXCEPTION } @@ -1507,7 +1625,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticInt32Field((sint32)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setInt32Field(Stat, (sint32)value); END_EXCEPTION } @@ -1519,7 +1639,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticLongField((sint64)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setLongField(Stat, (sint64)value); END_EXCEPTION } @@ -1531,7 +1653,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticFloatField((float)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setFloatField(Stat, (float)value); END_EXCEPTION } @@ -1543,7 +1667,9 @@ BEGIN_EXCEPTION JavaField* field = (JavaField*)fieldID; - field->setStaticDoubleField((double)value); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + JavaObject* Stat = cl->getStaticInstance(); + field->setDoubleField(Stat, (double)value); END_EXCEPTION } @@ -1624,11 +1750,11 @@ Jnjvm* vm = NativeUtil::myVM(env); if (length < 0) vm->negativeArraySizeException(length); - CommonClass* base = NativeUtil::resolvedImplClass(elementClass, true); + UserCommonClass* base = NativeUtil::resolvedImplClass(elementClass, true); JnjvmClassLoader* loader = base->classLoader; - const UTF8* name = base->name; - const UTF8* arrayName = AssessorDesc::constructArrayName(loader, 0, 1, name); - ClassArray* array = loader->constructArray(arrayName); + const UTF8* name = base->getName(); + const UTF8* arrayName = loader->constructArrayName(1, name); + UserClassArray* array = loader->constructArray(arrayName); ArrayObject* res = ArrayObject::acons(length, array, &(vm->allocator)); if (initialElement) { memset(res->elements, (int)initialElement, @@ -1673,7 +1799,9 @@ BEGIN_EXCEPTION ArrayUInt8* res = 0; - res = ArrayUInt8::acons(len, JavaArray::ofBool, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArrayUInt8::acons(len, vm->bootstrapLoader->upcalls->ArrayOfBool, + &vm->allocator); return (jbooleanArray)res; END_EXCEPTION @@ -1686,7 +1814,9 @@ BEGIN_EXCEPTION ArraySInt8* res = 0; - res = ArraySInt8::acons(len, JavaArray::ofByte, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArraySInt8::acons(len, vm->bootstrapLoader->upcalls->ArrayOfByte, + &vm->allocator); return (jbyteArray) res; END_EXCEPTION @@ -1699,7 +1829,9 @@ BEGIN_EXCEPTION ArrayUInt16* res = 0; - res = ArrayUInt16::acons(len, JavaArray::ofChar, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArrayUInt16::acons(len, vm->bootstrapLoader->upcalls->ArrayOfChar, + &vm->allocator); return (jcharArray) res; END_EXCEPTION @@ -1712,7 +1844,9 @@ BEGIN_EXCEPTION ArraySInt16* res = 0; - res = ArraySInt16::acons(len, JavaArray::ofShort, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArraySInt16::acons(len, vm->bootstrapLoader->upcalls->ArrayOfShort, + &vm->allocator); return (jshortArray) res; END_EXCEPTION @@ -1725,7 +1859,9 @@ BEGIN_EXCEPTION ArraySInt32* res = 0; - res = ArraySInt32::acons(len, JavaArray::ofInt, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArraySInt32::acons(len, vm->bootstrapLoader->upcalls->ArrayOfInt, + &vm->allocator); return (jintArray) res; END_EXCEPTION @@ -1738,7 +1874,9 @@ BEGIN_EXCEPTION ArrayLong* res = 0; - res = ArrayLong::acons(len, JavaArray::ofLong, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArrayLong::acons(len, vm->bootstrapLoader->upcalls->ArrayOfLong, + &vm->allocator); return (jlongArray) res; END_EXCEPTION @@ -1751,7 +1889,9 @@ BEGIN_EXCEPTION ArrayFloat* res = 0; - res = ArrayFloat::acons(len, JavaArray::ofFloat, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArrayFloat::acons(len, vm->bootstrapLoader->upcalls->ArrayOfFloat, + &vm->allocator); return (jfloatArray) res; END_EXCEPTION @@ -1764,7 +1904,9 @@ BEGIN_EXCEPTION ArrayDouble* res = 0; - res = ArrayDouble::acons(len, JavaArray::ofDouble, &NativeUtil::myVM(env)->allocator); + Jnjvm* vm = NativeUtil::myVM(env); + res = ArrayDouble::acons(len, vm->bootstrapLoader->upcalls->ArrayOfDouble, + &vm->allocator); return (jdoubleArray) res; END_EXCEPTION @@ -2143,10 +2285,11 @@ BEGIN_EXCEPTION + Jnjvm* vm = NativeUtil::myVM(env); JavaObject* buf = (JavaObject*)_buf; - JavaObject* address = Classpath::bufferAddress->getVirtualObjectField(buf); + JavaObject* address = vm->upcalls->bufferAddress->getObjectField(buf); if (address != 0) { - int res = Classpath::dataPointer32->getVirtualInt32Field(address); + int res = vm->upcalls->dataPointer32->getInt32Field(address); return (void*)res; } else { 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=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Oct 2 18:28:36 2008 @@ -83,53 +83,66 @@ #ifndef MULTIPLE_VM /// If we're not in a multi-vm environment, this can be made static. std::vector Jnjvm::nativeLibs; +JnjvmBootstrapLoader* Jnjvm::bootstrapLoader; +std::map Jnjvm::primitiveMap; #endif -typedef void (*clinit_t)(Jnjvm* vm); +typedef void (*clinit_t)(Jnjvm* vm, UserConstantPool*); -void Jnjvm::initialiseClass(CommonClass* cl) { - JavaState* status = cl->getStatus(); +void UserCommonClass::initialiseClass(Jnjvm* vm) { // Primitives are initialized at boot time - if (cl->isArray) { - *status = ready; - } else if (!(*status == ready)) { - cl->acquire(); - JavaState* status = cl->getStatus(); - if (*status == ready) { - cl->release(); - } else if (*status >= resolved && *status != clinitParent && - *status != inClinit) { - *status = clinitParent; - cl->release(); - if (cl->super) { - initialiseClass(cl->super); + if (isArray()) { + status = ready; + } else if (status != ready) { + acquire(); + if (status == ready) { + release(); + } else if (status >= resolved && status != clinitParent && + status != inClinit) { + UserClass* cl = (UserClass*)this; + status = clinitParent; + release(); + UserCommonClass* super = getSuper(); + if (super) { + super->initialiseClass(vm); } - - cl->classLoader->TheModule->resolveStaticClass((Class*)cl); - *status = inClinit; - JavaMethod* meth = cl->lookupMethodDontThrow(clinitName, clinitType, true, - false); + cl->resolveStaticClass(); + + status = inClinit; + UserClass* methodCl; + JavaMethod* meth = lookupMethodDontThrow(Jnjvm::clinitName, + Jnjvm::clinitType, true, + false, methodCl); PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0); PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "clinit ", 0); - PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s::%s\n", printString(), - cl->printString()); - - ((Class*)cl)->createStaticInstance(); + PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", printString()); + JavaObject* val = + (JavaObject*)vm->allocator.allocateObject(cl->getStaticSize(), + cl->getStaticVT()); + val->initialise(cl); + CommonClass::field_map* map = cl->getStaticFields(); + for (CommonClass::field_iterator i = map->begin(), e = map->end(); i!= e; + ++i) { + i->second->initField(val, vm); + } + + cl->setStaticInstance(val); + if (meth) { JavaObject* exc = 0; try{ clinit_t pred = (clinit_t)(intptr_t)meth->compiledPtr(); - pred(JavaThread::get()->isolate); + pred(vm, cl->getConstantPool()); } catch(...) { exc = JavaThread::getJavaException(); assert(exc && "no exception?"); JavaThread::clearException(); } if (exc) { - if (exc->classOf->isAssignableFrom(Classpath::newException)) { + if (exc->classOf->isAssignableFrom(vm->upcalls->newException)) { JavaThread::get()->isolate->initializerError(exc); } else { JavaThread::throwException(exc); @@ -137,30 +150,30 @@ } } - *status = ready; - cl->broadcastClass(); - } else if (*status < resolved) { - cl->release(); - unknownError("try to clinit a not-read class..."); + status = ready; + broadcastClass(); + } else if (status < resolved) { + release(); + vm->unknownError("try to clinit a not-read class..."); } else { - if (!cl->ownerClass()) { - while (*status < ready) cl->waitClass(); - cl->release(); - initialiseClass(cl); + if (!ownerClass()) { + while (status < ready) waitClass(); + release(); + initialiseClass(vm); } - cl->release(); + release(); } } } -void Jnjvm::errorWithExcp(Class* cl, JavaMethod* init, const JavaObject* excp) { +void Jnjvm::errorWithExcp(UserClass* cl, JavaMethod* init, const JavaObject* excp) { JavaObject* obj = cl->doNew(this); - init->invokeIntSpecial(this, obj, excp); + init->invokeIntSpecial(this, cl, obj, excp); JavaThread::throwException(obj); } -void Jnjvm::error(Class* cl, JavaMethod* init, const char* fmt, ...) { +void Jnjvm::error(UserClass* cl, JavaMethod* init, const char* fmt, ...) { char* tmp = (char*)alloca(4096); va_list ap; va_start(ap, fmt); @@ -168,23 +181,23 @@ va_end(ap); JavaObject* obj = cl->doNew(this); - init->invokeIntSpecial(this, obj, asciizToStr(tmp)); + init->invokeIntSpecial(this, cl, obj, asciizToStr(tmp)); JavaThread::throwException(obj); } void Jnjvm::arrayStoreException() { - error(Classpath::ArrayStoreException, - Classpath::InitArrayStoreException, ""); + error(upcalls->ArrayStoreException, + upcalls->InitArrayStoreException, ""); } void Jnjvm::indexOutOfBounds(const JavaObject* obj, sint32 entry) { - error(Classpath::ArrayIndexOutOfBoundsException, - Classpath::InitArrayIndexOutOfBoundsException, "%d", entry); + error(upcalls->ArrayIndexOutOfBoundsException, + upcalls->InitArrayIndexOutOfBoundsException, "%d", entry); } void Jnjvm::negativeArraySizeException(sint32 size) { - error(Classpath::NegativeArraySizeException, - Classpath::InitNegativeArraySizeException, "%d", size); + error(upcalls->NegativeArraySizeException, + upcalls->InitNegativeArraySizeException, "%d", size); } void Jnjvm::nullPointerException(const char* fmt, ...) { @@ -192,115 +205,115 @@ va_start(ap, fmt); char* val = va_arg(ap, char*); va_end(ap); - error(Classpath::NullPointerException, - Classpath::InitNullPointerException, fmt, val); + error(upcalls->NullPointerException, + upcalls->InitNullPointerException, fmt, val); } void Jnjvm::illegalAccessException(const char* msg) { - error(Classpath::IllegalAccessException, - Classpath::InitIllegalAccessException, msg); + error(upcalls->IllegalAccessException, + upcalls->InitIllegalAccessException, msg); } void Jnjvm::illegalMonitorStateException(const JavaObject* obj) { - error(Classpath::IllegalMonitorStateException, - Classpath::InitIllegalMonitorStateException, ""); + error(upcalls->IllegalMonitorStateException, + upcalls->InitIllegalMonitorStateException, ""); } void Jnjvm::interruptedException(const JavaObject* obj) { - error(Classpath::InterruptedException, - Classpath::InitInterruptedException, ""); + error(upcalls->InterruptedException, + upcalls->InitInterruptedException, ""); } void Jnjvm::initializerError(const JavaObject* excp) { - errorWithExcp(Classpath::ExceptionInInitializerError, - Classpath::ErrorWithExcpExceptionInInitializerError, + errorWithExcp(upcalls->ExceptionInInitializerError, + upcalls->ErrorWithExcpExceptionInInitializerError, excp); } void Jnjvm::invocationTargetException(const JavaObject* excp) { - errorWithExcp(Classpath::InvocationTargetException, - Classpath::ErrorWithExcpInvocationTargetException, + errorWithExcp(upcalls->InvocationTargetException, + upcalls->ErrorWithExcpInvocationTargetException, excp); } void Jnjvm::outOfMemoryError(sint32 n) { - error(Classpath::OutOfMemoryError, - Classpath::InitOutOfMemoryError, "%d", n); + error(upcalls->OutOfMemoryError, + upcalls->InitOutOfMemoryError, "%d", n); } void Jnjvm::illegalArgumentExceptionForMethod(JavaMethod* meth, - CommonClass* required, - CommonClass* given) { - error(Classpath::IllegalArgumentException, - Classpath::InitIllegalArgumentException, + UserCommonClass* required, + UserCommonClass* given) { + error(upcalls->IllegalArgumentException, + upcalls->InitIllegalArgumentException, "for method %s", meth->printString()); } void Jnjvm::illegalArgumentExceptionForField(JavaField* field, - CommonClass* required, - CommonClass* given) { - error(Classpath::IllegalArgumentException, - Classpath::InitIllegalArgumentException, + UserCommonClass* required, + UserCommonClass* given) { + error(upcalls->IllegalArgumentException, + upcalls->InitIllegalArgumentException, "for field %s", field->printString()); } void Jnjvm::illegalArgumentException(const char* msg) { - error(Classpath::IllegalArgumentException, - Classpath::InitIllegalArgumentException, + error(upcalls->IllegalArgumentException, + upcalls->InitIllegalArgumentException, msg); } -void Jnjvm::classCastException(const char* msg) { - error(Classpath::ClassCastException, - Classpath::InitClassCastException, - msg); +void Jnjvm::classCastException(JavaObject* obj, UserCommonClass* cl) { + error(upcalls->ClassCastException, + upcalls->InitClassCastException, + ""); } void Jnjvm::noSuchFieldError(CommonClass* cl, const UTF8* name) { - error(Classpath::NoSuchFieldError, - Classpath::InitNoSuchFieldError, + error(upcalls->NoSuchFieldError, + upcalls->InitNoSuchFieldError, "unable to find %s in %s", - name->UTF8ToAsciiz(), cl->printString()); + name->UTF8ToAsciiz(), cl->name->UTF8ToAsciiz()); } void Jnjvm::noSuchMethodError(CommonClass* cl, const UTF8* name) { - error(Classpath::NoSuchMethodError, - Classpath::InitNoSuchMethodError, + error(upcalls->NoSuchMethodError, + upcalls->InitNoSuchMethodError, "unable to find %s in %s", - name->UTF8ToAsciiz(), cl->printString()); + name->UTF8ToAsciiz(), cl->name->UTF8ToAsciiz()); } void Jnjvm::classFormatError(const char* msg, ...) { - error(Classpath::ClassFormatError, - Classpath::InitClassFormatError, + error(upcalls->ClassFormatError, + upcalls->InitClassFormatError, msg); } void Jnjvm::noClassDefFoundError(JavaObject* obj) { - errorWithExcp(Classpath::NoClassDefFoundError, - Classpath::ErrorWithExcpNoClassDefFoundError, + errorWithExcp(upcalls->NoClassDefFoundError, + upcalls->ErrorWithExcpNoClassDefFoundError, obj); } void Jnjvm::noClassDefFoundError(const char* fmt, ...) { - error(Classpath::NoClassDefFoundError, - Classpath::InitNoClassDefFoundError, + error(upcalls->NoClassDefFoundError, + upcalls->InitNoClassDefFoundError, fmt); } void Jnjvm::classNotFoundException(JavaString* str) { - error(Classpath::ClassNotFoundException, - Classpath::InitClassNotFoundException, + error(upcalls->ClassNotFoundException, + upcalls->InitClassNotFoundException, "unable to load %s", str->strToAsciiz()); } void Jnjvm::unknownError(const char* fmt, ...) { - error(Classpath::UnknownError, - Classpath::InitUnknownError, + error(upcalls->UnknownError, + upcalls->InitUnknownError, fmt); } @@ -312,8 +325,7 @@ JavaString* Jnjvm::asciizToStr(const char* asciiz) { // asciizToStr is called by jnjvm code, so utf8s created // by this method are stored in the bootstrap class loader - JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader; - const UTF8* var = JCL->asciizConstructUTF8(asciiz); + const UTF8* var = bootstrapLoader->asciizConstructUTF8(asciiz); return UTF8ToStr(var); } @@ -321,41 +333,23 @@ postProperties.push_back(std::make_pair(key, value)); } -#ifndef MULTIPLE_VM -JavaObject* Jnjvm::getClassDelegatee(CommonClass* cl, JavaObject* pd) { - cl->acquire(); - if (!(cl->delegatee)) { - JavaObject* delegatee = Classpath::newClass->doNew(this); - cl->delegatee = delegatee; - if (!pd) { - Classpath::initClass->invokeIntSpecial(this, delegatee, cl); - } else { - Classpath::initClassWithProtectionDomain->invokeIntSpecial(this, - delegatee, - cl, pd); - } - } - cl->release(); - return cl->delegatee; -} -#else -JavaObject* Jnjvm::getClassDelegatee(CommonClass* cl, JavaObject* pd) { - cl->acquire(); - JavaObject* val = delegatees->lookup(cl); - if (!val) { - val = Classpath::newClass->doNew(this); - delegatees->hash(cl, val); +JavaObject* UserCommonClass::getClassDelegatee(Jnjvm* vm, JavaObject* pd) { + acquire(); + if (!(delegatee)) { + UserClass* cl = vm->upcalls->newClass; + JavaObject* delegatee = cl->doNew(vm); if (!pd) { - Classpath::initClass->invokeIntSpecial(this, val, cl); + vm->upcalls->initClass->invokeIntSpecial(vm, cl, delegatee, this); } else { - Classpath::initClassWithProtectionDomain->invokeIntSpecial(this, val, cl, - pd); + vm->upcalls->initClassWithProtectionDomain->invokeIntSpecial(vm, cl, + delegatee, + this, pd); } + this->delegatee = delegatee; } - cl->release(); - return val; + release(); + return delegatee; } -#endif Jnjvm::~Jnjvm() { #ifdef MULTIPLE_GC @@ -448,14 +442,15 @@ sprintf(temp, "%s:%s", vm->classpath, jarFile); vm->setClasspath(temp); - ArrayUInt8* bytes = Reader::openFile(JnjvmClassLoader::bootstrapLoader, + ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, jarFile); ZipArchive archive(bytes); if (archive.getOfscd() != -1) { ZipFile* file = archive.getFile(PATH_MANIFEST); if (file) { - ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, &vm->allocator); + UserClassArray* array = vm->bootstrapLoader->upcalls->ArrayOfByte; + ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, array, &vm->allocator); int ok = archive.readFile(res, file); if (ok) { char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS); @@ -570,7 +565,7 @@ printInformation(); } else { char* path = &cur[16]; - JnjvmClassLoader::bootstrapLoader->analyseClasspathEnv(path); + vm->bootstrapLoader->analyseClasspathEnv(path); } } else if (!(strcmp(cur, "-enableassertions"))) { nyi(); @@ -654,71 +649,83 @@ JnjvmClassLoader* Jnjvm::loadAppClassLoader() { if (appClassLoader == 0) { - JavaObject* loader = Classpath::getSystemClassLoader->invokeJavaObjectStatic(this); - appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader); + UserClass* cl = upcalls->newClassLoader; + JavaObject* loader = + upcalls->getSystemClassLoader->invokeJavaObjectStatic(this, cl); + appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, + this); } return appClassLoader; } void Jnjvm::mapInitialThread() { - Classpath::mapInitialThread(this); + upcalls->mapInitialThread(this); } void Jnjvm::loadBootstrap() { - JnjvmClassLoader* loader = JnjvmClassLoader::bootstrapLoader; + JnjvmClassLoader* loader = bootstrapLoader; #define LOAD_CLASS(cl) \ cl->resolveClass(); \ - initialiseClass(cl); + cl->initialiseClass(this); - LOAD_CLASS(Classpath::newClass); - LOAD_CLASS(Classpath::newConstructor); - LOAD_CLASS(Classpath::newString); - LOAD_CLASS(Classpath::newMethod); - LOAD_CLASS(Classpath::newField); - LOAD_CLASS(Classpath::newStackTraceElement); - LOAD_CLASS(Classpath::newVMThrowable); - LOAD_CLASS(Classpath::InvocationTargetException); - LOAD_CLASS(Classpath::ArrayStoreException); - LOAD_CLASS(Classpath::ClassCastException); - LOAD_CLASS(Classpath::IllegalMonitorStateException); - LOAD_CLASS(Classpath::IllegalArgumentException); - LOAD_CLASS(Classpath::InterruptedException); - LOAD_CLASS(Classpath::IndexOutOfBoundsException); - LOAD_CLASS(Classpath::ArrayIndexOutOfBoundsException); - LOAD_CLASS(Classpath::NegativeArraySizeException); - LOAD_CLASS(Classpath::NullPointerException); - LOAD_CLASS(Classpath::SecurityException); - LOAD_CLASS(Classpath::ClassFormatError); - LOAD_CLASS(Classpath::ClassCircularityError); - LOAD_CLASS(Classpath::NoClassDefFoundError); - LOAD_CLASS(Classpath::UnsupportedClassVersionError); - LOAD_CLASS(Classpath::NoSuchFieldError); - LOAD_CLASS(Classpath::NoSuchMethodError); - LOAD_CLASS(Classpath::InstantiationError); - LOAD_CLASS(Classpath::IllegalAccessError); - LOAD_CLASS(Classpath::IllegalAccessException); - LOAD_CLASS(Classpath::VerifyError); - LOAD_CLASS(Classpath::ExceptionInInitializerError); - LOAD_CLASS(Classpath::LinkageError); - LOAD_CLASS(Classpath::AbstractMethodError); - LOAD_CLASS(Classpath::UnsatisfiedLinkError); - LOAD_CLASS(Classpath::InternalError); - LOAD_CLASS(Classpath::OutOfMemoryError); - LOAD_CLASS(Classpath::StackOverflowError); - LOAD_CLASS(Classpath::UnknownError); - LOAD_CLASS(Classpath::ClassNotFoundException); + LOAD_CLASS(upcalls->newClass); + LOAD_CLASS(upcalls->newConstructor); + LOAD_CLASS(upcalls->newString); + LOAD_CLASS(upcalls->newMethod); + LOAD_CLASS(upcalls->newField); + LOAD_CLASS(upcalls->newStackTraceElement); + LOAD_CLASS(upcalls->newVMThrowable); + LOAD_CLASS(upcalls->boolClass); + LOAD_CLASS(upcalls->byteClass); + LOAD_CLASS(upcalls->charClass); + LOAD_CLASS(upcalls->shortClass); + LOAD_CLASS(upcalls->intClass); + LOAD_CLASS(upcalls->longClass); + LOAD_CLASS(upcalls->floatClass); + LOAD_CLASS(upcalls->doubleClass); + LOAD_CLASS(upcalls->InvocationTargetException); + LOAD_CLASS(upcalls->ArrayStoreException); + LOAD_CLASS(upcalls->ClassCastException); + LOAD_CLASS(upcalls->IllegalMonitorStateException); + LOAD_CLASS(upcalls->IllegalArgumentException); + LOAD_CLASS(upcalls->InterruptedException); + LOAD_CLASS(upcalls->IndexOutOfBoundsException); + LOAD_CLASS(upcalls->ArrayIndexOutOfBoundsException); + LOAD_CLASS(upcalls->NegativeArraySizeException); + LOAD_CLASS(upcalls->NullPointerException); + LOAD_CLASS(upcalls->SecurityException); + LOAD_CLASS(upcalls->ClassFormatError); + LOAD_CLASS(upcalls->ClassCircularityError); + LOAD_CLASS(upcalls->NoClassDefFoundError); + LOAD_CLASS(upcalls->UnsupportedClassVersionError); + LOAD_CLASS(upcalls->NoSuchFieldError); + LOAD_CLASS(upcalls->NoSuchMethodError); + LOAD_CLASS(upcalls->InstantiationError); + LOAD_CLASS(upcalls->IllegalAccessError); + LOAD_CLASS(upcalls->IllegalAccessException); + LOAD_CLASS(upcalls->VerifyError); + LOAD_CLASS(upcalls->ExceptionInInitializerError); + LOAD_CLASS(upcalls->LinkageError); + LOAD_CLASS(upcalls->AbstractMethodError); + LOAD_CLASS(upcalls->UnsatisfiedLinkError); + LOAD_CLASS(upcalls->InternalError); + LOAD_CLASS(upcalls->OutOfMemoryError); + LOAD_CLASS(upcalls->StackOverflowError); + LOAD_CLASS(upcalls->UnknownError); + LOAD_CLASS(upcalls->ClassNotFoundException); #undef LOAD_CLASS mapInitialThread(); loadAppClassLoader(); JavaObject* obj = JavaThread::currentThread(); - Classpath::setContextClassLoader->invokeIntSpecial(this, obj, - appClassLoader->getJavaClassLoader()); + JavaObject* javaLoader = appClassLoader->getJavaClassLoader(); + upcalls->setContextClassLoader->invokeIntSpecial(this, upcalls->newThread, + obj, javaLoader); // load and initialise math since it is responsible for dlopen'ing // libjavalang.so and we are optimizing some math operations - CommonClass* math = + UserCommonClass* math = loader->loadName(loader->asciizConstructUTF8("java/lang/Math"), true, true); - initialiseClass(math); + math->initialiseClass(this); } void Jnjvm::executeClass(const char* className, ArrayObject* args) { @@ -733,10 +740,10 @@ JavaThread::clearException(); JavaObject* obj = JavaThread::currentThread(); JavaObject* group = - Classpath::group->getVirtualObjectField(obj); + upcalls->group->getObjectField(obj); try{ - Classpath::uncaughtException->invokeIntSpecial(this, group, obj, - exc); + upcalls->uncaughtException->invokeIntSpecial(this, upcalls->threadGroup, + group, obj, exc); }catch(...) { printf("Even uncaught exception throwed an exception!\n"); assert(0); @@ -789,9 +796,9 @@ executePremain(i->first, args, instrumenter); } } - - ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString, - &allocator); + + UserClassArray* array = bootstrapLoader->upcalls->ArrayOfString; + ArrayObject* args = ArrayObject::acons(argc - 2, array, &allocator); for (int i = 2; i < argc; ++i) { args->elements[i - 2] = (JavaObject*)asciizToStr(argv[i]); } @@ -843,10 +850,43 @@ isolate->hashStr = new StringMap(); isolate->globalRefsLock = mvm::Lock::allocNormal(); + #ifdef MULTIPLE_VM - isolate->statics = allocator_new(&isolate->allocator, StaticInstanceMap)(); - isolate->delegatees = allocator_new(&isolate->allocator, DelegateeMap)(); + isolate->initialiseStatics(); #endif + + isolate->upcalls = isolate->bootstrapLoader->upcalls; +#ifdef MULTIPLE_VM + isolate->throwable = isolate->upcalls->newThrowable; +#endif + isolate->arrayClasses[JavaArray::T_BOOLEAN - 4] = + isolate->upcalls->ArrayOfBool; + isolate->arrayClasses[JavaArray::T_BYTE - 4] = + isolate->upcalls->ArrayOfByte; + isolate->arrayClasses[JavaArray::T_CHAR - 4] = + isolate->upcalls->ArrayOfChar; + isolate->arrayClasses[JavaArray::T_SHORT - 4] = + isolate->upcalls->ArrayOfShort; + isolate->arrayClasses[JavaArray::T_INT - 4] = + isolate->upcalls->ArrayOfInt; + isolate->arrayClasses[JavaArray::T_FLOAT - 4] = + isolate->upcalls->ArrayOfFloat; + isolate->arrayClasses[JavaArray::T_LONG - 4] = + isolate->upcalls->ArrayOfLong; + isolate->arrayClasses[JavaArray::T_DOUBLE - 4] = + isolate->upcalls->ArrayOfDouble; + + isolate->primitiveMap[I_VOID] = isolate->upcalls->OfVoid; + isolate->primitiveMap[I_BOOL] = isolate->upcalls->OfBool; + isolate->primitiveMap[I_BYTE] = isolate->upcalls->OfByte; + isolate->primitiveMap[I_CHAR] = isolate->upcalls->OfChar; + isolate->primitiveMap[I_SHORT] = isolate->upcalls->OfShort; + isolate->primitiveMap[I_INT] = isolate->upcalls->OfInt; + isolate->primitiveMap[I_FLOAT] = isolate->upcalls->OfFloat; + isolate->primitiveMap[I_LONG] = isolate->upcalls->OfLong; + isolate->primitiveMap[I_DOUBLE] = isolate->upcalls->OfDouble; + + isolate->upcalls->initialiseClasspath(bootstrapLoader); return isolate; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Oct 2 18:28:36 2008 @@ -21,41 +21,27 @@ #include "mvm/Threads/Locks.h" #include "JavaAllocator.h" +#include "JavaTypes.h" +#include "JnjvmConfig.h" namespace jnjvm { class ArrayObject; -class ArrayUInt8; -class Attribut; -class Class; -class ClassArray; +class Classpath; class CommonClass; class JavaField; class JavaMethod; class JavaObject; class JavaString; class JavaThread; +class JnjvmBootstrapLoader; class JnjvmClassLoader; -class JnjvmModule; -class JnjvmModuleProvider; -class Reader; -class Typedef; -class UTF8; -class UTF8Map; -class ClassMap; -class DelegateeMap; -class FieldMap; -class MethodMap; -class Signdef; -class SignMap; -class StaticInstanceMap; class StringMap; -class TypeMap; -class FunctionMap; -class FunctionDefMap; -class FunctionDefMap; -class AllocationMap; -class ZipArchive; +class UserClass; +class UserClassArray; +class UserClassPrimitive; +class UserCommonClass; +class UTF8; /// ThreadSystem - Thread management of a JVM. Each JVM has one thread /// management system to count the number of non-daemon threads it owns. @@ -103,8 +89,21 @@ /// Jnjvm - A JVM. Each execution of a program allocates a Jnjvm. /// class Jnjvm : public mvm::VirtualMachine { +public: +#ifdef MULTIPLE_GC + /// GC - The garbage collector of this JVM. + /// + Collector* GC; +#endif + +#ifdef MULTIPLE_VM + UserClass* throwable; +#endif + std::map arrayClasses; private: + ISOLATE_STATIC std::map primitiveMap; + /// bootstrapThread - The initial thread of this JVM. /// JavaThread* bootstrapThread; @@ -113,11 +112,11 @@ /// that calls this functions. This is used internally by Jnjvm to control /// which pair class/method are used. /// - void error(Class* cl, JavaMethod* meth, const char* fmt, ...); + void error(UserClass* cl, JavaMethod* meth, const char* fmt, ...); /// errorWithExcp - Throws an exception whose cause is the Java object excp. /// - void errorWithExcp(Class* cl, JavaMethod* meth, const JavaObject* excp); + void errorWithExcp(UserClass* cl, JavaMethod* meth, const JavaObject* excp); /// loadAppClassLoader - Loads the application class loader, so that VMKit /// knowns which loader has to load the main class. @@ -215,13 +214,16 @@ static const UTF8* sinh; static const UTF8* tanh; static const UTF8* finalize; + + /// bootstraLoader - Bootstrap loader for base classes of this virtual + /// machine. + /// + ISOLATE_STATIC JnjvmBootstrapLoader* bootstrapLoader; -#ifdef MULTIPLE_GC - /// GC - The garbage collector of this JVM. + /// upcalls - Upcalls to call Java methods and access Java fields. /// - Collector* GC; -#endif - + Classpath* upcalls; + /// threadSystem - The thread system to manage non-daemon threads and /// control the end of the JVM's execution. /// @@ -245,10 +247,7 @@ /// nativeLibs - Native libraries (e.g. '.so') loaded by this JVM. /// -#ifndef MULTIPLE_VM - static -#endif - std::vector nativeLibs; + ISOLATE_STATIC std::vector nativeLibs; /// classpath - The CLASSPATH value, or the paths given in command line. /// @@ -274,18 +273,6 @@ /// StringMap * hashStr; -#ifdef MULTIPLE_VM - /// statics - The static instances of classes, in a multi-vm environment. - /// - StaticInstanceMap* statics; - -private: - /// delegatees - The java/lang/Class equivalents of internal classes. This is - /// also in a multi-vm environment. - /// - DelegateeMap* delegatees; -#endif - public: /// Exceptions - These are the only exceptions VMKit will make. /// @@ -299,12 +286,12 @@ void initializerError(const JavaObject* excp); void invocationTargetException(const JavaObject* obj); void outOfMemoryError(sint32 n); - void illegalArgumentExceptionForMethod(JavaMethod* meth, CommonClass* required, - CommonClass* given); - void illegalArgumentExceptionForField(JavaField* field, CommonClass* required, - CommonClass* given); + void illegalArgumentExceptionForMethod(JavaMethod* meth, UserCommonClass* required, + UserCommonClass* given); + void illegalArgumentExceptionForField(JavaField* field, UserCommonClass* required, + UserCommonClass* given); void illegalArgumentException(const char* msg); - void classCastException(const char* msg); + void classCastException(JavaObject* obj, UserCommonClass* cl); void unknownError(const char* fmt, ...); void noSuchFieldError(CommonClass* cl, const UTF8* name); void noSuchMethodError(CommonClass* cl, const UTF8* name); @@ -313,12 +300,6 @@ void noClassDefFoundError(const char* fmt, ...); void classNotFoundException(JavaString* str); - - /// initialiseClass - Initialise the class for this JVM, and call the - /// "" function. - /// - void initialiseClass(CommonClass* cl); - /// asciizToStr - Constructs a java/lang/String object from the given asciiz. /// JavaString* asciizToStr(const char* asciiz); @@ -327,11 +308,6 @@ /// JavaString* UTF8ToStr(const UTF8* utf8); - /// getClassDelegatee - Get the java/lang/Class object representing the - /// internal class. - /// - JavaObject* getClassDelegatee(CommonClass* cl, JavaObject* pd = 0); - /// ~Jnjvm - Destroy the JVM. /// ~Jnjvm(); @@ -349,6 +325,15 @@ void setClasspath(char* cp) { classpath = cp; } + + /// initialiseStatics - Initializes the isolate. The function initialize + /// static variables in a single environment. + /// + ISOLATE_STATIC void initialiseStatics(); + + ISOLATE_STATIC UserClassPrimitive* getPrimitiveClass(char id) { + return primitiveMap[id]; + } /// allocateIsolate - Allocates a new JVM. /// @@ -364,7 +349,7 @@ /// User-visible function, inherited by the VirtualMachine class. /// virtual void runApplication(int argc, char** argv); - + }; } // 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=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Oct 2 18:28:36 2008 @@ -14,6 +14,7 @@ #include "debug.h" #include "JavaAllocator.h" +#include "JavaClass.h" #include "JavaConstantPool.h" #include "JavaThread.h" #include "JavaUpcalls.h" @@ -26,12 +27,13 @@ using namespace jnjvm; +#ifndef MULTIPLE_VM JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0; - -#ifdef MULTIPLE_VM -JnjvmSharedLoader* JnjvmClassLoader::sharedLoader = 0; +UserClass* JnjvmBootstrapLoader::SuperArray = 0; +std::vector JnjvmBootstrapLoader::InterfacesArray; #endif + extern const char* GNUClasspathGlibj; extern const char* GNUClasspathLibs; @@ -44,7 +46,7 @@ JCL->allocator = new JavaAllocator(); - JCL->hashUTF8 = new UTF8Map(JCL->allocator); + JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0); JCL->classes = allocator_new(allocator, ClassMap)(); JCL->javaTypes = new TypeMap(); JCL->javaSignatures = new SignMap(); @@ -60,32 +62,17 @@ } JCL->analyseClasspathEnv(JCL->bootClasspathEnv); - - return JCL; -} - -#ifdef MULTIPLE_VM -JnjvmSharedLoader* JnjvmSharedLoader::createSharedLoader() { - - JnjvmSharedLoader* JCL = gc_new(JnjvmSharedLoader)(); - JCL->TheModule = new JnjvmModule("Bootstrap JnJVM"); - JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule); - JCL->TheModule->initialise(); - - JCL->allocator = new JavaAllocator(); - - JCL->hashUTF8 = new UTF8Map(JCL->allocator); - JCL->classes = allocator_new(allocator, ClassMap)(); - JCL->javaTypes = new TypeMap(); - JCL->javaSignatures = new SignMap(); + JCL->upcalls = new Classpath(); + JCL->bootstrapLoader = JCL; return JCL; } -#endif -JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* I) { +JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, + Jnjvm* I) { TheModule = JCL.TheModule; TheModuleProvider = JCL.TheModuleProvider; + bootstrapLoader = JCL.bootstrapLoader; allocator = &(isolate->allocator); @@ -97,6 +84,13 @@ javaLoader = loader; isolate = I; +#ifdef MULTIPLE_VM + JavaMethod* meth = bootstrapLoader->upcalls->loadInClassLoader; + loader->classOf->lookupMethodDontThrow(meth->name, meth->type, false, true, + loadClass); + assert(loadClass && "Loader does not have a loadClass function"); +#endif + } ArrayUInt8* JnjvmBootstrapLoader::openName(const UTF8* utf8) { @@ -129,9 +123,9 @@ } -Class* JnjvmBootstrapLoader::internalLoad(const UTF8* name) { +UserClass* JnjvmBootstrapLoader::internalLoad(const UTF8* name) { - CommonClass* cl = lookupClass(name); + UserCommonClass* cl = lookupClass(name); if (!cl) { ArrayUInt8* bytes = openName(name); @@ -140,31 +134,38 @@ } } - if (cl) assert(!cl->isArray); - return (Class*)cl; + if (cl) assert(!cl->isArray()); + return (UserClass*)cl; } -Class* JnjvmClassLoader::internalLoad(const UTF8* name) { - CommonClass* cl = lookupClass(name); +UserClass* JnjvmClassLoader::internalLoad(const UTF8* name) { + UserCommonClass* cl = lookupClass(name); if (!cl) { const UTF8* javaName = name->internalToJava(hashUTF8, 0, name->size); JavaString* str = isolate->UTF8ToStr(javaName); + Classpath* upcalls = bootstrapLoader->upcalls; + UserClass* forCtp = 0; +#ifdef MULTIPLE_VM + forCtp = loadClass; +#else + forCtp = upcalls->loadInClassLoader->classDef; +#endif JavaObject* obj = (JavaObject*) - Classpath::loadInClassLoader->invokeJavaObjectVirtual(isolate, javaLoader, - str); - cl = (CommonClass*)(Classpath::vmdataClass->getVirtualObjectField(obj)); + upcalls->loadInClassLoader->invokeJavaObjectVirtual(isolate, forCtp, + javaLoader, str); + cl = (UserCommonClass*)(upcalls->vmdataClass->getObjectField(obj)); } - if (cl) assert(!cl->isArray); - return (Class*)cl; + if (cl) assert(!cl->isArray()); + return (UserClass*)cl; } -Class* JnjvmClassLoader::loadName(const UTF8* name, bool doResolve, +UserClass* JnjvmClassLoader::loadName(const UTF8* name, bool doResolve, bool doThrow) { - Class* cl = internalLoad(name); + UserClass* cl = internalLoad(name); if (!cl && doThrow) { if (!(name->equals(Jnjvm::NoClassDefFoundError))) { @@ -178,18 +179,18 @@ return cl; } -CommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* utf8, unsigned int start, - unsigned int len, - bool doResolve, - bool doThrow) { +UserCommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* name, + bool doResolve, + bool doThrow) { + uint32 len = name->size; + uint32 start = 0; uint32 origLen = len; - const UTF8* name = utf8->javaToInternal(hashUTF8, start, len); bool doLoop = true; - CommonClass* ret = 0; + UserCommonClass* ret = 0; if (len == 0) { return 0; - } else if (name->elements[0] == AssessorDesc::I_TAB) { + } else if (name->elements[0] == I_TAB) { while (doLoop) { --len; @@ -197,15 +198,15 @@ doLoop = false; } else { ++start; - if (name->elements[start] != AssessorDesc::I_TAB) { - if (name->elements[start] == AssessorDesc::I_REF) { + if (name->elements[start] != I_TAB) { + if (name->elements[start] == I_REF) { uint32 size = (uint32)name->size; if ((size == (start + 1)) || (size == (start + 2)) || - (name->elements[start + 1] == AssessorDesc::I_TAB) || - (utf8->elements[origLen - 1] != AssessorDesc::I_END_REF)) { + (name->elements[start + 1] == I_TAB) || + (name->elements[origLen - 1] != I_END_REF)) { doLoop = false; } else { - const UTF8* componentName = utf8->javaToInternal(hashUTF8, + const UTF8* componentName = name->javaToInternal(hashUTF8, start + 1, len - 2); if (loadName(componentName, doResolve, doThrow)) { @@ -218,10 +219,10 @@ } } else { uint16 cur = name->elements[start]; - if ((cur == AssessorDesc::I_BOOL || cur == AssessorDesc::I_BYTE || - cur == AssessorDesc::I_CHAR || cur == AssessorDesc::I_SHORT || - cur == AssessorDesc::I_INT || cur == AssessorDesc::I_FLOAT || - cur == AssessorDesc::I_DOUBLE || cur == AssessorDesc::I_LONG) + if ((cur == I_BOOL || cur == I_BYTE || + cur == I_CHAR || cur == I_SHORT || + cur == I_INT || cur == I_FLOAT || + cur == I_DOUBLE || cur == I_LONG) && ((uint32)name->size) == start + 1) { ret = constructArray(name); @@ -242,57 +243,87 @@ } } -CommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, +UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, bool doResolve, bool doThrow) { - return lookupClassFromUTF8(str->value, str->offset, str->count, - doResolve, doThrow); -} + + const UTF8* name = 0; + + if (str->value->elements[str->offset] != I_TAB) + name = str->value->checkedJavaToInternal(hashUTF8, str->offset, + str->count); + else + name = str->value->javaToInternal(hashUTF8, str->offset, str->count); -CommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) { - return classes->lookup(utf8); + if (name) + return lookupClassFromUTF8(name, doResolve, doThrow); + + return 0; } -static CommonClass* arrayDup(const UTF8*& name, JnjvmClassLoader* loader) { - ClassArray* cl = allocator_new(loader->allocator, ClassArray)(loader, name); - return cl; +UserCommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) { + return classes->lookup(utf8); } -ClassArray* JnjvmClassLoader::constructArray(const UTF8* name) { - if (javaLoader != 0) { - JnjvmClassLoader * ld = - ClassArray::arrayLoader(name, this, 1, name->size - 1); - ClassArray* res = - (ClassArray*)ld->classes->lookupOrCreate(name, this, arrayDup); - return res; +UserCommonClass* JnjvmClassLoader::loadBaseClass(const UTF8* name, + uint32 start, uint32 len) { + + if (name->elements[start] == I_TAB) { + UserCommonClass* baseClass = loadBaseClass(name, start + 1, len - 1); + JnjvmClassLoader* loader = baseClass->classLoader; + const UTF8* arrayName = name->extract(loader->hashUTF8, start, start + len); + return loader->constructArray(arrayName); + } else if (name->elements[start] == I_REF) { + const UTF8* componentName = name->extract(hashUTF8, + start + 1, start + len - 1); + UserCommonClass* cl = loadName(componentName, false, true); + return cl; } else { - return (ClassArray*)classes->lookupOrCreate(name, this, arrayDup); + Classpath* upcalls = bootstrapLoader->upcalls; + UserClassPrimitive* prim = + UserClassPrimitive::byteIdToPrimitive(name->elements[start], upcalls); + assert(prim && "No primitive found"); + return prim; } } -Class* JnjvmSharedLoader::constructSharedClass(const UTF8* name, - ArrayUInt8* bytes) { - - return 0; -} +UserClassArray* JnjvmClassLoader::constructArray(const UTF8* name) { + UserCommonClass* cl = loadBaseClass(name, 1, name->size - 1); + assert(cl && "no base class for an array"); + JnjvmClassLoader* ld = cl->classLoader; + return ld->constructArray(name, cl); +} -Class* JnjvmClassLoader::constructClass(const UTF8* name, ArrayUInt8* bytes) { +UserClass* JnjvmClassLoader::constructClass(const UTF8* name, ArrayUInt8* bytes) { assert(bytes && "constructing a class without bytes"); -#ifdef MULTIPLE_VM - if (this != bootstrapLoader && this != sharedLoader && bytes) { - Class* cl = sharedLoader->constructSharedClass(name, bytes); - if (cl) return cl; + classes->lock->lock(); + ClassMap::iterator End = classes->map.end(); + ClassMap::iterator I = classes->map.find(name); + UserClass* res = 0; + if (I == End) { + res = allocator_new(allocator, UserClass)(this, name, bytes); + classes->map.insert(std::make_pair(name, res)); + } else { + res = ((UserClass*)(I->second)); } -#endif + classes->lock->unlock(); + return res; +} + +UserClassArray* JnjvmClassLoader::constructArray(const UTF8* name, + UserCommonClass* baseClass) { + assert(baseClass && "constructing an array class without a base class"); + assert(baseClass->classLoader == this && + "constructing an array with wrong loader"); classes->lock->lock(); ClassMap::iterator End = classes->map.end(); ClassMap::iterator I = classes->map.find(name); - Class* res = 0; + UserClassArray* res = 0; if (I == End) { - res = allocator_new(allocator, Class)(this, name, bytes); + res = allocator_new(allocator, UserClassArray)(this, name, baseClass); classes->map.insert(std::make_pair(name, res)); } else { - res = ((Class*)(I->second)); + res = ((UserClassArray*)(I->second)); } classes->lock->unlock(); return res; @@ -301,11 +332,14 @@ Typedef* JnjvmClassLoader::constructType(const UTF8* name) { Typedef* res = javaTypes->lookup(name); if (res == 0) { - res = new Typedef(name, this); + res = Typedef::constructType(name, hashUTF8, isolate); javaTypes->lock->lock(); Typedef* tmp = javaTypes->lookup(name); if (tmp == 0) javaTypes->hash(name, res); - else res = tmp; + else { + delete res; + res = tmp; + } javaTypes->lock->unlock(); } return res; @@ -318,24 +352,28 @@ javaSignatures->lock->lock(); Signdef* tmp = javaSignatures->lookup(name); if (tmp == 0) javaSignatures->hash(name, res); - else res = tmp; + else { + delete res; + res = tmp; + } javaSignatures->lock->unlock(); } return res; } -JnjvmClassLoader* JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader) { +JnjvmClassLoader* JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader, Jnjvm* vm) { if (loader == 0) - return bootstrapLoader; - + return vm->bootstrapLoader; + + Classpath* upcalls = vm->bootstrapLoader->upcalls; JnjvmClassLoader* JCL = - (JnjvmClassLoader*)(Classpath::vmdataClassLoader->getVirtualObjectField(loader)); + (JnjvmClassLoader*)(upcalls->vmdataClassLoader->getObjectField(loader)); if (!JCL) { - JCL = gc_new(JnjvmClassLoader)(*bootstrapLoader, loader, JavaThread::get()->isolate); - (Classpath::vmdataClassLoader->setVirtualObjectField(loader, (JavaObject*)JCL)); + JCL = gc_new(JnjvmClassLoader)(*vm->bootstrapLoader, loader, JavaThread::get()->isolate); + (upcalls->vmdataClassLoader->setObjectField(loader, (JavaObject*)JCL)); } return JCL; @@ -370,7 +408,7 @@ if (top != 0) { memcpy(buf, cur, top); buf[top] = 0; - char* rp = (char*)malloc(PATH_MAX); + char* rp = (char*)alloca(PATH_MAX); memset(rp, 0, PATH_MAX); rp = realpath(buf, rp); if (rp[PATH_MAX - 1] == 0 && strlen(rp) != 0) { @@ -383,11 +421,9 @@ temp[len] = Jnjvm::dirSeparator[0]; temp[len + 1] = 0; bootClasspath.push_back(temp); - free(rp); } else { ArrayUInt8* bytes = Reader::openFile(this, rp); - free(rp); if (bytes) { ZipArchive *archive = new ZipArchive(bytes); if (archive) { @@ -395,9 +431,7 @@ } } } - } else { - free(rp); - } + } } cur = cur + top + 1; top = 0; @@ -405,3 +439,30 @@ } } +const UTF8* JnjvmClassLoader::constructArrayName(uint32 steps, + const UTF8* className) { + uint32 len = className->size; + uint32 pos = steps; + bool isTab = (className->elements[0] == I_TAB ? true : false); + uint32 n = steps + len + (isTab ? 0 : 2); + uint16* buf = (uint16*)alloca(n * sizeof(uint16)); + + for (uint32 i = 0; i < steps; i++) { + buf[i] = I_TAB; + } + + if (!isTab) { + ++pos; + buf[steps] = I_REF; + } + + for (uint32 i = 0; i < len; i++) { + buf[pos + i] = className->elements[i]; + } + + if (!isTab) { + buf[n - 1] = I_END_REF; + } + + return readerConstructUTF8(buf, n); +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Thu Oct 2 18:28:36 2008 @@ -16,15 +16,19 @@ #include "types.h" #include "mvm/Object.h" +#include "mvm/PrintBuffer.h" + +#include "JnjvmConfig.h" namespace jnjvm { class ArrayUInt8; class Attribut; -class Class; -class ClassArray; +class UserClass; +class UserClassArray; class ClassMap; -class CommonClass; +class Classpath; +class UserCommonClass; class JavaAllocator; class JavaObject; class JavaString; @@ -41,10 +45,6 @@ class UTF8Map; class ZipArchive; -#ifdef MULTIPLE_VM -class JnjvmSharedLoader; -#endif - /// JnjvmClassLoader - Runtime representation of a class loader. It contains /// its own tables (signatures, UTF8, types) which are mapped to a single /// table for non-isolate environments. @@ -64,7 +64,7 @@ /// internalLoad - Load the class with the given name. /// - virtual Class* internalLoad(const UTF8* utf8); + virtual UserClass* internalLoad(const UTF8* utf8); /// JnjvmClassLoader - Allocate a user-defined class loader. Called on /// first use of a Java class loader. @@ -126,7 +126,7 @@ /// getJnjvmLoaderFromJavaObject - Return the Jnjvm runtime representation /// of the given class loader. /// - static JnjvmClassLoader* getJnjvmLoaderFromJavaObject(JavaObject*); + static JnjvmClassLoader* getJnjvmLoaderFromJavaObject(JavaObject*, Jnjvm *vm); /// getJavaClassLoader - Return the Java representation of this class loader. /// @@ -136,33 +136,35 @@ /// loadName - Loads the class of the given name. /// - Class* loadName(const UTF8* name, bool doResolve, bool doThrow); + UserClass* loadName(const UTF8* name, bool doResolve, bool doThrow); /// lookupClassFromUTF8 - Lookup a class from an UTF8 name and load it. /// - CommonClass* lookupClassFromUTF8(const UTF8* utf8, unsigned int start, - unsigned int len, bool doResolve, - bool doThrow); + UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, bool doResolve, + bool doThrow); /// lookupClassFromJavaString - Lookup a class from a Java String and load it. /// - CommonClass* lookupClassFromJavaString(JavaString* str, bool doResolve, + UserCommonClass* lookupClassFromJavaString(JavaString* str, bool doResolve, bool doThrow); /// lookupClass - Finds the class of th given name in the class loader's /// table. /// - CommonClass* lookupClass(const UTF8* utf8); + UserCommonClass* lookupClass(const UTF8* utf8); /// constructArray - Hashes a runtime representation of a class with /// the given name. /// - ClassArray* constructArray(const UTF8* name); + UserClassArray* constructArray(const UTF8* name); + UserClassArray* constructArray(const UTF8* name, UserCommonClass* base); + + UserCommonClass* loadBaseClass(const UTF8* name, uint32 start, uint32 len); /// constructClass - Hashes a runtime representation of a class with /// the given name. /// - Class* constructClass(const UTF8* name, ArrayUInt8* bytes); + UserClass* constructClass(const UTF8* name, ArrayUInt8* bytes); /// constructType - Hashes a Typedef, an internal representation of a class /// still not loaded. @@ -185,14 +187,8 @@ /// bootstrapLoader - The bootstrap loader of the JVM. Loads the base /// classes. /// - static JnjvmBootstrapLoader* bootstrapLoader; + ISOLATE_STATIC JnjvmBootstrapLoader* bootstrapLoader; -#ifdef MULTIPLE_VM - /// sharedLoader - Shared loader when multiple vms are executing. - /// - static JnjvmSharedLoader* sharedLoader; -#endif - /// ~JnjvmClassLoader - Destroy the loader. Depending on the JVM /// configuration, this may destroy the tables, JIT module and /// module provider. @@ -210,35 +206,13 @@ isolate = 0; } -}; - -class JnjvmSharedLoader : public JnjvmClassLoader { -private: - - /// internalLoad - Load the class with the given name. - /// - virtual Class* internalLoad(const UTF8* utf8) { - fprintf(stderr, "Don't use me"); - exit(1); - } - -public: +#ifdef MULTIPLE_VM + UserClass* loadClass; +#endif - /// VT - The virtual table of this class. - /// - static VirtualTable* VT; - - - /// constructSharedClass - Create a shared representation of the class. - /// If two classes have the same name but not the same array of bytes, - /// raise an exception. - /// - Class* constructSharedClass(const UTF8* name, ArrayUInt8* bytes); - - static JnjvmSharedLoader* createSharedLoader(); + const UTF8* constructArrayName(uint32 steps, const UTF8* className); }; - /// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which /// loads base classes, ie glibj.zip or rt.jar and -Xbootclasspath. /// @@ -246,7 +220,7 @@ private: /// internalLoad - Load the class with the given name. /// - virtual Class* internalLoad(const UTF8* utf8); + virtual UserClass* internalLoad(const UTF8* utf8); /// bootClasspath - List of paths for the base classes. /// @@ -295,7 +269,13 @@ /// static JnjvmBootstrapLoader* createBootstrapLoader(); - + /// upcalls - Upcall classes, fields and methods so that C++ code can call + /// Java code. + /// + Classpath* upcalls; + + ISOLATE_STATIC std::vector InterfacesArray; + ISOLATE_STATIC UserClass* SuperArray; }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Thu Oct 2 18:28:36 2008 @@ -8,7 +8,6 @@ //===----------------------------------------------------------------------===// #include "llvm/CallingConv.h" -#include "llvm/ParameterAttributes.h" #include "llvm/Support/MutexGuard.h" @@ -45,6 +44,8 @@ const llvm::Type* JnjvmModule::JavaArrayObjectType = 0; const llvm::Type* JnjvmModule::CacheNodeType = 0; const llvm::Type* JnjvmModule::EnveloppeType = 0; +const llvm::Type* JnjvmModule::JnjvmType = 0; +const llvm::Type* JnjvmModule::ConstantPoolType = 0; llvm::Constant* JnjvmModule::JavaObjectNullConstant; llvm::Constant* JnjvmModule::UTF8NullConstant; @@ -57,6 +58,8 @@ llvm::ConstantInt* JnjvmModule::OffsetVTInClassConstant; llvm::ConstantInt* JnjvmModule::OffsetDepthInClassConstant; llvm::ConstantInt* JnjvmModule::OffsetDisplayInClassConstant; +llvm::ConstantInt* JnjvmModule::OffsetStatusInClassConstant; +llvm::ConstantInt* JnjvmModule::OffsetCtpInClassConstant; const llvm::Type* JnjvmModule::JavaClassType; const llvm::Type* JnjvmModule::VTType; llvm::ConstantInt* JnjvmModule::JavaArrayElementsOffsetConstant; @@ -81,7 +84,8 @@ llvm::Function* JnjvmModule::OutOfMemoryErrorFunction = 0; llvm::Function* JnjvmModule::JavaObjectAllocateFunction = 0; llvm::Function* JnjvmModule::InterfaceLookupFunction = 0; -llvm::Function* JnjvmModule::FieldLookupFunction = 0; +llvm::Function* JnjvmModule::StaticFieldLookupFunction = 0; +llvm::Function* JnjvmModule::VirtualFieldLookupFunction = 0; #ifndef WITHOUT_VTABLE llvm::Function* JnjvmModule::VirtualLookupFunction = 0; #endif @@ -102,10 +106,18 @@ llvm::Function* JnjvmModule::AquireObjectFunction = 0; llvm::Function* JnjvmModule::ReleaseObjectFunction = 0; llvm::Function* JnjvmModule::MultiCallNewFunction = 0; +llvm::Function* JnjvmModule::GetConstantPoolAtFunction = 0; #ifdef MULTIPLE_VM llvm::Function* JnjvmModule::StringLookupFunction = 0; -llvm::Function* JnjvmModule::GetStaticInstanceFunction = 0; +llvm::Function* JnjvmModule::GetCtpCacheNodeFunction = 0; +llvm::Function* JnjvmModule::GetCtpClassFunction = 0; +llvm::Function* JnjvmModule::EnveloppeLookupFunction = 0; +llvm::Function* JnjvmModule::GetJnjvmExceptionClassFunction = 0; +llvm::Function* JnjvmModule::GetJnjvmArrayClassFunction = 0; +llvm::Function* JnjvmModule::StaticCtpLookupFunction = 0; +llvm::Function* JnjvmModule::GetArrayClassFunction = 0; +llvm::Function* JnjvmModule::SpecialCtpLookupFunction = 0; #endif llvm::Function* JnjvmModule::GetClassDelegateeFunction = 0; llvm::Function* JnjvmModule::ArrayLengthFunction = 0; @@ -164,7 +176,7 @@ Value* LLVMCommonClassInfo::getDelegatee(JavaJIT* jit) { #ifndef MULTIPLE_VM if (!delegateeGV) { - JavaObject* obj = classDef->getClassDelegatee(); + JavaObject* obj = classDef->getClassDelegatee(JavaThread::get()->isolate); Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(obj)), JnjvmModule::JavaObjectType); @@ -175,9 +187,8 @@ } return new LoadInst(delegateeGV, "", jit->currentBlock); #else - Value* ld = getVar(jit); - return llvm::CallInst::Create(JnjvmModule::GetClassDelegateeFunction, ld, "", - jit->currentBlock); + fprintf(stderr, "implement me\n"); + abort(); #endif } @@ -203,6 +214,7 @@ VirtualTable* VT = 0; if (meth->name->equals(Jnjvm::finalize)) { VT = allocateVT(cl, ++meths); +#ifndef MULTIPLE_VM meth->offset = 0; Function* func = cl->classLoader->TheModuleProvider->parseFunction(meth); if (!cl->super) meth->canBeInlined = true; @@ -215,10 +227,13 @@ // LLVM does not allow recursive compilation. Create the code now. ((void**)VT)[0] = EE->getPointerToFunction(func); } +#endif } else { + Class* methodCl = 0; JavaMethod* parent = cl->super? - cl->super->lookupMethodDontThrow(meth->name, meth->type, false, true) : + cl->super->lookupMethodDontThrow(meth->name, meth->type, false, true, + methodCl) : 0; uint64_t offset = 0; @@ -252,26 +267,21 @@ memcpy(res, JavaObject::VT, VT_SIZE); #ifndef WITHOUT_VTABLE } else { + if (cl->super) { + cl->virtualTableSize = cl->super->virtualTableSize; + } else { + cl->virtualTableSize = VT_NB_FUNCS; + } res = allocateVT(cl, cl->virtualMethods.begin()); if (!(cl->super)) { - // 12 = number of virtual methods in java/lang/Object (!!!) - uint32 size = 12 * sizeof(void*); + uint32 size = (cl->virtualTableSize - VT_NB_FUNCS) * sizeof(void*); #define COPY(CLASS) \ memcpy((void*)((unsigned)CLASS::VT + VT_SIZE), \ (void*)((unsigned)res + VT_SIZE), size); + COPY(JavaArray) COPY(JavaObject) - COPY(ArrayUInt8) - COPY(ArraySInt8) - COPY(ArrayUInt16) - COPY(ArraySInt16) - COPY(ArrayUInt32) - COPY(ArraySInt32) - COPY(ArrayLong) - COPY(ArrayFloat) - COPY(ArrayDouble) - COPY(UTF8) COPY(ArrayObject) #undef COPY @@ -319,7 +329,7 @@ for (CommonClass::field_iterator i = fields.begin(), e = fields.end(); i!= e; ++i) { - if (i->second->getSignature()->funcs->doTrace) { + if (i->second->getSignature()->trace()) { LLVMFieldInfo* LFI = getFieldInfo(i->second); std::vector args; //size = 2 args.push_back(zero); @@ -346,6 +356,8 @@ void* codePtr = mvm::jit::executionEngine->getPointerToGlobal(func); ((void**)res)[VT_TRACER_OFFSET] = codePtr; + func->deleteBody(); + if (!stat) { LCI->virtualTracerFunction = func; } else { @@ -378,8 +390,8 @@ for (uint32 index = 0; index < classDef->virtualFields.size(); ++index) { - uint8 id = array[index]->getSignature()->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + Typedef* type = array[index]->getSignature(); + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); fields.push_back(LAI.llvmType); } @@ -423,8 +435,8 @@ for (uint32 index = 0; index < classDef->staticFields.size(); ++index) { JavaField* field = array[index]; - uint8 id = field->getSignature()->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + Typedef* type = field->getSignature(); + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); fields.push_back(LAI.llvmType); } @@ -445,29 +457,15 @@ uint64 size = mvm::jit::getTypeSize(structType); cl->staticSize = size; cl->staticVT = VT; - -#ifndef MULTIPLE_VM - JavaObject* val = - (JavaObject*)JavaThread::get()->isolate->allocator.allocateObject(cl->staticSize, - cl->staticVT); - val->initialise(classDef); - for (CommonClass::field_iterator i = cl->staticFields.begin(), - e = cl->staticFields.end(); i!= e; ++i) { - - i->second->initField(val); - } - - cl->_staticInstance = val; -#endif } return staticType; } -Value* LLVMClassInfo::getStaticVar(JavaJIT* jit) { #ifndef MULTIPLE_VM +Value* LLVMClassInfo::getStaticVar(JavaJIT* jit) { if (!staticVarGV) { getStaticType(); - JavaObject* obj = ((Class*)classDef)->staticInstance(); + JavaObject* obj = ((Class*)classDef)->getStaticInstance(); Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (obj)), JnjvmModule::JavaObjectType); @@ -479,15 +477,8 @@ } return new LoadInst(staticVarGV, "", jit->currentBlock); - -#else - Value* ld = getVar(jit); - ld = jit->invoke(JnjvmModule::InitialisationCheckFunction, ld, "", - jit->currentBlock); - return jit->invoke(JnjvmModule::GetStaticInstanceFunction, ld, - jit->isolateLocal, "", jit->currentBlock); -#endif } +#endif Value* LLVMClassInfo::getVirtualTable(JavaJIT* jit) { if (!virtualTableGV) { @@ -583,17 +574,17 @@ llvmArgs.push_back(JnjvmModule::JavaObjectType); for (uint32 i = 0; i < size; ++i) { - uint8 id = signature->args.at(i)->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + Typedef* type = signature->args.at(i); + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); llvmArgs.push_back(LAI.llvmType); } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) - llvmArgs.push_back(mvm::jit::ptrType); // domain +#if defined(MULTIPLE_VM) + llvmArgs.push_back(JnjvmModule::JnjvmType); // vm + llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif - uint8 id = signature->ret->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); virtualType = FunctionType::get(LAI.llvmType, llvmArgs, false); } return virtualType; @@ -607,17 +598,17 @@ unsigned int size = signature->args.size(); for (uint32 i = 0; i < size; ++i) { - uint8 id = signature->args.at(i)->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + Typedef* type = signature->args.at(i); + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); llvmArgs.push_back(LAI.llvmType); } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) - llvmArgs.push_back(mvm::jit::ptrType); // domain +#if defined(MULTIPLE_VM) + llvmArgs.push_back(JnjvmModule::JnjvmType); // vm + llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif - uint8 id = signature->ret->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); staticType = FunctionType::get(LAI.llvmType, llvmArgs, false); } return staticType; @@ -634,17 +625,17 @@ llvmArgs.push_back(JnjvmModule::JavaObjectType); // Class for (uint32 i = 0; i < size; ++i) { - uint8 id = signature->args.at(i)->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + Typedef* type = signature->args.at(i); + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); llvmArgs.push_back(LAI.llvmType); } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) - llvmArgs.push_back(mvm::jit::ptrType); // domain +#if defined(MULTIPLE_VM) + llvmArgs.push_back(JnjvmModule::JnjvmType); // vm + llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif - uint8 id = signature->ret->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); nativeType = FunctionType::get(LAI.llvmType, llvmArgs, false); } return nativeType; @@ -665,10 +656,14 @@ BasicBlock* currentBlock = BasicBlock::Create("enter", res); Function::arg_iterator i = res->arg_begin(); Value *obj, *ptr, *func; -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) Value* vm = i; #endif ++i; +#if defined(MULTIPLE_VM) + Value* ctp = i; +#endif + ++i; func = i; ++i; if (virt) { @@ -681,25 +676,26 @@ for (std::vector::iterator i = signature->args.begin(), e = signature->args.end(); i!= e; ++i) { - const AssessorDesc* funcs = (*i)->funcs; ptr = GetElementPtrInst::Create(ptr, CI, "", currentBlock); - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[funcs->numId]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(*i); + const Type* type = LAI.llvmType; Value* val = new BitCastInst(ptr, LAI.llvmTypePtr, "", currentBlock); Value* arg = new LoadInst(val, "", currentBlock); Args.push_back(arg); - if (funcs == AssessorDesc::dLong || funcs == AssessorDesc::dDouble) { + if (type == Type::Int64Ty || type == Type::DoubleTy) { CI = mvm::jit::constantTwo; } else { CI = mvm::jit::constantOne; } } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) Args.push_back(vm); + Args.push_back(ctp); #endif Value* val = CallInst::Create(func, Args.begin(), Args.end(), "", currentBlock); - if (signature->ret->funcs != AssessorDesc::dVoid) + if (res->getFunctionType()->getReturnType() != Type::VoidTy) ReturnInst::Create(val, currentBlock); else ReturnInst::Create(currentBlock); @@ -720,10 +716,14 @@ BasicBlock* currentBlock = BasicBlock::Create("enter", res); Function::arg_iterator i = res->arg_begin(); Value *obj, *ap, *func; -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) Value* vm = i; #endif ++i; +#if defined(MULTIPLE_VM) + Value* ctp = i; +#endif + ++i; func = i; ++i; if (virt) { @@ -733,19 +733,19 @@ } ap = i; - for (std::vector::iterator i = signature->args.begin(), + for (std::vector::iterator i = signature->args.begin(), e = signature->args.end(); i!= e; i++) { - - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[(*i)->funcs->numId]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(*i); Args.push_back(new VAArgInst(ap, LAI.llvmType, "", currentBlock)); } -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(MULTIPLE_VM) Args.push_back(vm); + Args.push_back(ctp); #endif Value* val = CallInst::Create(func, Args.begin(), Args.end(), "", currentBlock); - if (signature->ret->funcs != AssessorDesc::dVoid) + if (res->getFunctionType()->getReturnType() != Type::VoidTy) ReturnInst::Create(val, currentBlock); else ReturnInst::Create(currentBlock); @@ -780,12 +780,12 @@ // Lock here because we are called by arbitrary code llvm::MutexGuard locked(mvm::jit::executionEngine->lock); std::vector Args2; - Args2.push_back(mvm::jit::ptrType); // vm + Args2.push_back(JnjvmModule::JnjvmType); // vm + Args2.push_back(JnjvmModule::ConstantPoolType); // ctp Args2.push_back(getVirtualPtrType()); Args2.push_back(JnjvmModule::JavaObjectType); Args2.push_back(PointerType::getUnqual(Type::Int32Ty)); - uint8 id = signature->ret->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); virtualBufType = FunctionType::get(LAI.llvmType, Args2, false); } return virtualBufType; @@ -796,11 +796,11 @@ // Lock here because we are called by arbitrary code llvm::MutexGuard locked(mvm::jit::executionEngine->lock); std::vector Args; - Args.push_back(mvm::jit::ptrType); // vm + Args.push_back(JnjvmModule::JnjvmType); // vm + Args.push_back(JnjvmModule::ConstantPoolType); // ctp Args.push_back(getStaticPtrType()); Args.push_back(PointerType::getUnqual(Type::Int32Ty)); - uint8 id = signature->ret->funcs->numId; - LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[id]; + LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(signature->ret); staticBufType = FunctionType::get(LAI.llvmType, Args, false); } return staticBufType; @@ -813,6 +813,7 @@ virtualBufFunction = createFunctionCallBuf(true); signature->setVirtualCallBuf((intptr_t) mvm::jit::executionEngine->getPointerToGlobal(virtualBufFunction)); + virtualBufFunction->deleteBody(); } return virtualBufFunction; } @@ -824,6 +825,7 @@ virtualAPFunction = createFunctionCallAP(true); signature->setVirtualCallAP((intptr_t) mvm::jit::executionEngine->getPointerToGlobal(virtualAPFunction)); + virtualAPFunction->deleteBody(); } return virtualAPFunction; } @@ -835,6 +837,7 @@ staticBufFunction = createFunctionCallBuf(false); signature->setStaticCallBuf((intptr_t) mvm::jit::executionEngine->getPointerToGlobal(staticBufFunction)); + staticBufFunction->deleteBody(); } return staticBufFunction; } @@ -846,6 +849,7 @@ staticAPFunction = createFunctionCallAP(false); signature->setStaticCallAP((intptr_t) mvm::jit::executionEngine->getPointerToGlobal(staticAPFunction)); + staticAPFunction->deleteBody(); } return staticAPFunction; } @@ -918,6 +922,11 @@ jnjvm::llvm_runtime::makeLLVMModuleContents(module); VTType = module->getTypeByName("VT"); + + JnjvmType = + PointerType::getUnqual(module->getTypeByName("Jnjvm")); + ConstantPoolType = + PointerType::getUnqual(module->getTypeByName("ConstantPool")); JavaObjectType = PointerType::getUnqual(module->getTypeByName("JavaObject")); @@ -960,13 +969,15 @@ InitialisationCheckFunction = module->getFunction("initialisationCheck"); ForceInitialisationCheckFunction = module->getFunction("forceInitialisationCheck"); - + + GetConstantPoolAtFunction = module->getFunction("getConstantPoolAt"); ArrayLengthFunction = module->getFunction("arrayLength"); GetVTFunction = module->getFunction("getVT"); GetClassFunction = module->getFunction("getClass"); - ClassLookupFunction = module->getFunction("newLookup"); + ClassLookupFunction = module->getFunction("classLookup"); GetVTFromClassFunction = module->getFunction("getVTFromClass"); - GetObjectSizeFromClassFunction = module->getFunction("getObjectSizeFromClass"); + GetObjectSizeFromClassFunction = + module->getFunction("getObjectSizeFromClass"); GetClassDelegateeFunction = module->getFunction("getClassDelegatee"); InstanceOfFunction = module->getFunction("instanceOf"); @@ -980,7 +991,8 @@ ReleaseObjectFunction = module->getFunction("JavaObjectRelease"); OverflowThinLockFunction = module->getFunction("overflowThinLock"); - FieldLookupFunction = module->getFunction("fieldLookup"); + VirtualFieldLookupFunction = module->getFunction("virtualFieldLookup"); + StaticFieldLookupFunction = module->getFunction("staticFieldLookup"); GetExceptionFunction = module->getFunction("JavaThreadGetException"); GetJavaExceptionFunction = module->getFunction("JavaThreadGetJavaException"); @@ -989,7 +1001,8 @@ module->getFunction("jniProceedPendingException"); GetSJLJBufferFunction = module->getFunction("getSJLJBuffer"); - NullPointerExceptionFunction = module->getFunction("jnjvmNullPointerException"); + NullPointerExceptionFunction = + module->getFunction("jnjvmNullPointerException"); ClassCastExceptionFunction = module->getFunction("jnjvmClassCastException"); IndexOutOfBoundsExceptionFunction = module->getFunction("indexOutOfBoundsException"); @@ -1009,8 +1022,16 @@ #ifdef MULTIPLE_VM - GetStaticInstanceFunction = module->getFunction("getStaticInstance"); StringLookupFunction = module->getFunction("stringLookup"); + EnveloppeLookupFunction = module->getFunction("enveloppeLookup"); + GetCtpCacheNodeFunction = module->getFunction("getCtpCacheNode"); + GetCtpClassFunction = module->getFunction("getCtpClass"); + GetJnjvmExceptionClassFunction = + module->getFunction("getJnjvmExceptionClass"); + GetJnjvmArrayClassFunction = module->getFunction("getJnjvmArrayClass"); + StaticCtpLookupFunction = module->getFunction("staticCtpLookup"); + SpecialCtpLookupFunction = module->getFunction("specialCtpLookup"); + GetArrayClassFunction = module->getFunction("getArrayClass"); #endif #ifdef SERVICE_VM @@ -1074,24 +1095,32 @@ OffsetVTInClassConstant = mvm::jit::constantTwo; OffsetDisplayInClassConstant = mvm::jit::constantThree; OffsetDepthInClassConstant = mvm::jit::constantFour; + OffsetStatusInClassConstant = mvm::jit::constantFive; + OffsetCtpInClassConstant = mvm::jit::constantSix; LLVMAssessorInfo::initialise(); } void JnjvmModule::InitField(JavaField* field, JavaObject* obj, uint64 val) { - const AssessorDesc* funcs = field->getSignature()->funcs; - if (funcs == AssessorDesc::dLong) { + Typedef* type = field->getSignature(); + if (!type->isPrimitive()) { + ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; + return; + } + + PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isLong()) { ((sint64*)((uint64)obj + field->ptrOffset))[0] = val; - } else if (funcs == AssessorDesc::dInt) { + } else if (prim->isInt()) { ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - } else if (funcs == AssessorDesc::dChar) { + } else if (prim->isChar()) { ((uint16*)((uint64)obj + field->ptrOffset))[0] = (uint16)val; - } else if (funcs == AssessorDesc::dShort) { + } else if (prim->isShort()) { ((sint16*)((uint64)obj + field->ptrOffset))[0] = (sint16)val; - } else if (funcs == AssessorDesc::dByte) { + } else if (prim->isByte()) { ((sint8*)((uint64)obj + field->ptrOffset))[0] = (sint8)val; - } else if (funcs == AssessorDesc::dBool) { + } else if (prim->isBool()) { ((uint8*)((uint64)obj + field->ptrOffset))[0] = (uint8)val; } else { // 0 value for everything else @@ -1127,72 +1156,77 @@ setDataLayout(str); } void LLVMAssessorInfo::initialise() { - AssessorInfo[VOID_ID].llvmType = Type::VoidTy; - AssessorInfo[VOID_ID].llvmTypePtr = 0; - AssessorInfo[VOID_ID].llvmNullConstant = 0; - AssessorInfo[VOID_ID].sizeInBytesConstant = 0; - - AssessorInfo[BOOL_ID].llvmType = Type::Int8Ty; - AssessorInfo[BOOL_ID].llvmTypePtr = PointerType::getUnqual(Type::Int8Ty); - AssessorInfo[BOOL_ID].llvmNullConstant = + AssessorInfo[I_VOID].llvmType = Type::VoidTy; + AssessorInfo[I_VOID].llvmTypePtr = 0; + AssessorInfo[I_VOID].llvmNullConstant = 0; + AssessorInfo[I_VOID].sizeInBytesConstant = 0; + + AssessorInfo[I_BOOL].llvmType = Type::Int8Ty; + AssessorInfo[I_BOOL].llvmTypePtr = PointerType::getUnqual(Type::Int8Ty); + AssessorInfo[I_BOOL].llvmNullConstant = Constant::getNullValue(Type::Int8Ty); - AssessorInfo[BOOL_ID].sizeInBytesConstant = mvm::jit::constantOne; + AssessorInfo[I_BOOL].sizeInBytesConstant = mvm::jit::constantOne; - AssessorInfo[BYTE_ID].llvmType = Type::Int8Ty; - AssessorInfo[BYTE_ID].llvmTypePtr = PointerType::getUnqual(Type::Int8Ty); - AssessorInfo[BYTE_ID].llvmNullConstant = + AssessorInfo[I_BYTE].llvmType = Type::Int8Ty; + AssessorInfo[I_BYTE].llvmTypePtr = PointerType::getUnqual(Type::Int8Ty); + AssessorInfo[I_BYTE].llvmNullConstant = Constant::getNullValue(Type::Int8Ty); - AssessorInfo[BYTE_ID].sizeInBytesConstant = mvm::jit::constantOne; + AssessorInfo[I_BYTE].sizeInBytesConstant = mvm::jit::constantOne; - AssessorInfo[SHORT_ID].llvmType = Type::Int16Ty; - AssessorInfo[SHORT_ID].llvmTypePtr = PointerType::getUnqual(Type::Int16Ty); - AssessorInfo[SHORT_ID].llvmNullConstant = + AssessorInfo[I_SHORT].llvmType = Type::Int16Ty; + AssessorInfo[I_SHORT].llvmTypePtr = PointerType::getUnqual(Type::Int16Ty); + AssessorInfo[I_SHORT].llvmNullConstant = Constant::getNullValue(Type::Int16Ty); - AssessorInfo[SHORT_ID].sizeInBytesConstant = mvm::jit::constantTwo; + AssessorInfo[I_SHORT].sizeInBytesConstant = mvm::jit::constantTwo; - AssessorInfo[CHAR_ID].llvmType = Type::Int16Ty; - AssessorInfo[CHAR_ID].llvmTypePtr = PointerType::getUnqual(Type::Int16Ty); - AssessorInfo[CHAR_ID].llvmNullConstant = + AssessorInfo[I_CHAR].llvmType = Type::Int16Ty; + AssessorInfo[I_CHAR].llvmTypePtr = PointerType::getUnqual(Type::Int16Ty); + AssessorInfo[I_CHAR].llvmNullConstant = Constant::getNullValue(Type::Int16Ty); - AssessorInfo[CHAR_ID].sizeInBytesConstant = mvm::jit::constantTwo; + AssessorInfo[I_CHAR].sizeInBytesConstant = mvm::jit::constantTwo; - AssessorInfo[INT_ID].llvmType = Type::Int32Ty; - AssessorInfo[INT_ID].llvmTypePtr = PointerType::getUnqual(Type::Int32Ty); - AssessorInfo[INT_ID].llvmNullConstant = + AssessorInfo[I_INT].llvmType = Type::Int32Ty; + AssessorInfo[I_INT].llvmTypePtr = PointerType::getUnqual(Type::Int32Ty); + AssessorInfo[I_INT].llvmNullConstant = Constant::getNullValue(Type::Int32Ty); - AssessorInfo[INT_ID].sizeInBytesConstant = mvm::jit::constantFour; + AssessorInfo[I_INT].sizeInBytesConstant = mvm::jit::constantFour; - AssessorInfo[FLOAT_ID].llvmType = Type::FloatTy; - AssessorInfo[FLOAT_ID].llvmTypePtr = PointerType::getUnqual(Type::FloatTy); - AssessorInfo[FLOAT_ID].llvmNullConstant = + AssessorInfo[I_FLOAT].llvmType = Type::FloatTy; + AssessorInfo[I_FLOAT].llvmTypePtr = PointerType::getUnqual(Type::FloatTy); + AssessorInfo[I_FLOAT].llvmNullConstant = Constant::getNullValue(Type::FloatTy); - AssessorInfo[FLOAT_ID].sizeInBytesConstant = mvm::jit::constantFour; + AssessorInfo[I_FLOAT].sizeInBytesConstant = mvm::jit::constantFour; - AssessorInfo[LONG_ID].llvmType = Type::Int64Ty; - AssessorInfo[LONG_ID].llvmTypePtr = PointerType::getUnqual(Type::Int64Ty); - AssessorInfo[LONG_ID].llvmNullConstant = + AssessorInfo[I_LONG].llvmType = Type::Int64Ty; + AssessorInfo[I_LONG].llvmTypePtr = PointerType::getUnqual(Type::Int64Ty); + AssessorInfo[I_LONG].llvmNullConstant = Constant::getNullValue(Type::Int64Ty); - AssessorInfo[LONG_ID].sizeInBytesConstant = mvm::jit::constantEight; + AssessorInfo[I_LONG].sizeInBytesConstant = mvm::jit::constantEight; - AssessorInfo[DOUBLE_ID].llvmType = Type::DoubleTy; - AssessorInfo[DOUBLE_ID].llvmTypePtr = PointerType::getUnqual(Type::DoubleTy); - AssessorInfo[DOUBLE_ID].llvmNullConstant = + AssessorInfo[I_DOUBLE].llvmType = Type::DoubleTy; + AssessorInfo[I_DOUBLE].llvmTypePtr = PointerType::getUnqual(Type::DoubleTy); + AssessorInfo[I_DOUBLE].llvmNullConstant = Constant::getNullValue(Type::DoubleTy); - AssessorInfo[DOUBLE_ID].sizeInBytesConstant = mvm::jit::constantEight; + AssessorInfo[I_DOUBLE].sizeInBytesConstant = mvm::jit::constantEight; - AssessorInfo[ARRAY_ID].llvmType = JnjvmModule::JavaObjectType; - AssessorInfo[ARRAY_ID].llvmTypePtr = + AssessorInfo[I_TAB].llvmType = JnjvmModule::JavaObjectType; + AssessorInfo[I_TAB].llvmTypePtr = PointerType::getUnqual(JnjvmModule::JavaObjectType); - AssessorInfo[ARRAY_ID].llvmNullConstant = + AssessorInfo[I_TAB].llvmNullConstant = JnjvmModule::JavaObjectNullConstant; - AssessorInfo[ARRAY_ID].sizeInBytesConstant = mvm::jit::constantPtrSize; + AssessorInfo[I_TAB].sizeInBytesConstant = mvm::jit::constantPtrSize; - AssessorInfo[OBJECT_ID].llvmType = JnjvmModule::JavaObjectType; - AssessorInfo[OBJECT_ID].llvmTypePtr = + AssessorInfo[I_REF].llvmType = JnjvmModule::JavaObjectType; + AssessorInfo[I_REF].llvmTypePtr = PointerType::getUnqual(JnjvmModule::JavaObjectType); - AssessorInfo[OBJECT_ID].llvmNullConstant = + AssessorInfo[I_REF].llvmNullConstant = JnjvmModule::JavaObjectNullConstant; - AssessorInfo[OBJECT_ID].sizeInBytesConstant = mvm::jit::constantPtrSize; + AssessorInfo[I_REF].sizeInBytesConstant = mvm::jit::constantPtrSize; +} + +std::map LLVMAssessorInfo::AssessorInfo; + +LLVMAssessorInfo& JnjvmModule::getTypedefInfo(Typedef* type) { + return LLVMAssessorInfo::AssessorInfo[type->getKey()->elements[0]]; } -LLVMAssessorInfo LLVMAssessorInfo::AssessorInfo[NUM_ASSESSORS]; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Thu Oct 2 18:28:36 2008 @@ -45,7 +45,7 @@ llvm::ConstantInt* sizeInBytesConstant; static void initialise(); - static LLVMAssessorInfo AssessorInfo[]; + static std::map AssessorInfo; }; @@ -62,11 +62,9 @@ /// llvm::GlobalVariable* varGV; -#ifndef MULTIPLE_VM /// delegateeGV - The LLVM global variable representing the /// java/lang/Class instance of this class. llvm::GlobalVariable* delegateeGV; -#endif public: @@ -75,10 +73,8 @@ LLVMCommonClassInfo(CommonClass* cl) : classDef(cl), - varGV(0) -#ifndef MULTIPLE_VM - ,delegateeGV(0) -#endif + varGV(0), + delegateeGV(0) {} }; @@ -308,6 +304,8 @@ static const llvm::Type* JavaCacheType; static const llvm::Type* EnveloppeType; static const llvm::Type* CacheNodeType; + static const llvm::Type* JnjvmType; + static const llvm::Type* ConstantPoolType; #ifdef WITH_TRACER static llvm::Function* MarkAndTraceFunction; @@ -317,7 +315,8 @@ static llvm::Function* GetSJLJBufferFunction; static llvm::Function* InterfaceLookupFunction; - static llvm::Function* FieldLookupFunction; + static llvm::Function* VirtualFieldLookupFunction; + static llvm::Function* StaticFieldLookupFunction; static llvm::Function* PrintExecutionFunction; static llvm::Function* PrintMethodStartFunction; static llvm::Function* PrintMethodEndFunction; @@ -337,6 +336,7 @@ static llvm::Function* GetDisplayFunction; static llvm::Function* AquireObjectFunction; static llvm::Function* ReleaseObjectFunction; + static llvm::Function* GetConstantPoolAtFunction; #ifdef SERVICE_VM static llvm::Function* AquireObjectInSharedDomainFunction; static llvm::Function* ReleaseObjectInSharedDomainFunction; @@ -347,7 +347,14 @@ #ifdef MULTIPLE_VM static llvm::Function* StringLookupFunction; - static llvm::Function* GetStaticInstanceFunction; + static llvm::Function* GetCtpCacheNodeFunction; + static llvm::Function* GetCtpClassFunction; + static llvm::Function* EnveloppeLookupFunction; + static llvm::Function* GetJnjvmExceptionClassFunction; + static llvm::Function* GetJnjvmArrayClassFunction; + static llvm::Function* StaticCtpLookupFunction; + static llvm::Function* SpecialCtpLookupFunction; + static llvm::Function* GetArrayClassFunction; #endif static llvm::Function* GetClassDelegateeFunction; @@ -369,6 +376,8 @@ static llvm::ConstantInt* OffsetVTInClassConstant; static llvm::ConstantInt* OffsetDepthInClassConstant; static llvm::ConstantInt* OffsetDisplayInClassConstant; + static llvm::ConstantInt* OffsetStatusInClassConstant; + static llvm::ConstantInt* OffsetCtpInClassConstant; static llvm::Constant* JavaClassNullConstant; @@ -408,7 +417,7 @@ } static LLVMCommonClassInfo* getClassInfo(CommonClass* cl) { - if (cl->isArray || cl->isPrimitive) { + if (cl->isArray() || cl->isPrimitive()) { return cl->getInfo(); } @@ -427,6 +436,8 @@ return ctp->getInfo(); } + static LLVMAssessorInfo& getTypedefInfo(Typedef* type); + LLVMStringInfo* getStringInfo(JavaString* str); #ifdef SERVICE_VM Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Thu Oct 2 18:28:36 2008 @@ -36,16 +36,20 @@ Signdef* sign = 0; ctpInfo->resolveMethod(index, cl, utf8, sign); - JavaMethod* meth = cl->lookupMethod(utf8, sign->keyName, isStatic, true); - + Class* methodCl = 0; + JavaMethod* meth = cl->lookupMethod(utf8, sign->keyName, isStatic, true, + methodCl); + +#ifndef MULTIPLE_VM + // 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)) - JavaThread::get()->isolate->initialiseClass(cl); - + cl->initialiseClass(JavaThread::get()->isolate); +#endif + meth->compiledPtr(); - LLVMMethodInfo* LMI = ((JnjvmModule*)TheModule)->getMethodInfo(meth); - ctpInfo->ctpRes[index] = LMI->getMethod(); - return meth; } @@ -93,42 +97,28 @@ LLVMMethodInfo* LMI = ((JnjvmModule*)TheModule)->getMethodInfo(meth); uint64_t offset = LMI->getOffset()->getZExtValue(); assert(meth->classDef->isResolved() && "Class not resolved"); +#ifndef MULTIPLE_VM assert(meth->classDef->isReady() && "Class not ready"); +#endif assert(meth->classDef->virtualVT && "Class has no VT"); assert(meth->classDef->virtualTableSize > offset && "The method's offset is greater than the virtual table size"); ((void**)meth->classDef->virtualVT)[offset] = val; } else { - JavaThread::get()->isolate->initialiseClass(meth->classDef); +#ifndef MULTIPLE_VM + meth->classDef->initialiseClass(JavaThread::get()->isolate); +#endif } return false; } - void* JnjvmModuleProvider::materializeFunction(JavaMethod* meth) { Function* func = parseFunction(meth); void* res = mvm::jit::executionEngine->getPointerToGlobal(func); mvm::Code* m = mvm::jit::getCodeFromPointer(res); if (m) m->setMetaInfo(meth); - - /* - if (compilingMethod->name == - compilingClass->isolate->asciizConstructUTF8("main")) { - llvmFunction->print(llvm::cout); - printf("\n"); - void* res = mvm::jit::executionEngine->getPointerToGlobal(llvmFunction); - void* base = res; - while (base < (void*)((char*)res + 100)) { - printf("%08x\t", (unsigned)base); - int n= mvm::jit::disassemble((unsigned int *)base); - printf("\n"); - base= ((void *)((char *)base + n)); - } - printf("\n"); - fflush(stdout); - } - */ + func->deleteBody(); return res; } @@ -158,7 +148,7 @@ Signdef* sign, bool stat) { void* key = &(cl->getConstantPool()->ctpRes[index]); - + reverse_callback_iterator CI = reverseCallbacks.find(key); if (CI != reverseCallbacks.end()) { return CI->second; @@ -204,9 +194,9 @@ static void AddStandardCompilePasses(FunctionPassManager *PM) { llvm::MutexGuard locked(mvm::jit::executionEngine->lock); // LLVM does not allow calling functions from other modules in verifier - //PM->add(llvm::createVerifierPass()); // Verify that input is correct + //PM->add(llvm::createVerifierPass()); // Verify that input is correct - addPass(PM, llvm::createCFGSimplificationPass()); // Clean up disgusting code + addPass(PM, llvm::createCFGSimplificationPass()); // Clean up disgusting code addPass(PM, llvm::createPromoteMemoryToRegisterPass());// Kill useless allocas addPass(PM, createInstructionCombiningPass()); // Cleanup for scalarrepl. @@ -229,8 +219,9 @@ addPass(PM, createGVNPass()); // Remove redundancies addPass(PM, createSCCPPass()); // Constant prop with SCCP addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs - - addPass(PM, mvm::createEscapeAnalysisPass(JnjvmModule::JavaObjectAllocateFunction)); + + Function* func = JnjvmModule::JavaObjectAllocateFunction; + addPass(PM, mvm::createEscapeAnalysisPass(func)); addPass(PM, mvm::createLowerConstantCallsPass()); // Run instcombine after redundancy elimination to exploit opportunities Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp Thu Oct 2 18:28:36 2008 @@ -91,7 +91,7 @@ } if (res == 0) { - UTF8* tmp = (UTF8*)UTF8::acons(size, JavaArray::ofChar, allocator); + UTF8* tmp = (UTF8*)UTF8::acons(size, array, allocator); for (sint32 i = 0; i < size; i++) { tmp->elements[i] = asciiz[i]; } @@ -119,7 +119,7 @@ } if (res == 0) { - UTF8* tmp = (UTF8*)UTF8::acons(size, JavaArray::ofChar, allocator); + UTF8* tmp = (UTF8*)UTF8::acons(size, array, allocator); memcpy(tmp->elements, buf, len * sizeof(uint16)); res = (const UTF8*)tmp; map.insert(std::make_pair(key, res)); Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Thu Oct 2 18:28:36 2008 @@ -97,15 +97,17 @@ mvm::Lock* lock; JavaAllocator* allocator; + UserClassArray* array; std::multimap map; const UTF8* lookupOrCreateAsciiz(const char* asciiz); const UTF8* lookupOrCreateReader(const uint16* buf, uint32 size); const UTF8* lookupAsciiz(const char* asciiz); const UTF8* lookupReader(const uint16* buf, uint32 size); - UTF8Map(JavaAllocator* A) { + UTF8Map(JavaAllocator* A, UserClassArray* cl) { lock = mvm::Lock::allocNormal(); allocator = A; + array = cl; } ~UTF8Map() { @@ -126,7 +128,7 @@ }; class ClassMap : - public LockedMap { + public LockedMap { public: static VirtualTable* VT; @@ -245,41 +247,6 @@ }; -class StaticInstanceMap : - public LockedMap*, std::less, Jnjvm* > { -public: - static VirtualTable* VT; - - StaticInstanceMap() { - lock = mvm::Lock::allocNormal(); - } - - virtual void TRACER; - - ~StaticInstanceMap() { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - delete i->second; - } - delete lock; - } -}; - -class DelegateeMap : - public LockedMap, Jnjvm* > { -public: - static VirtualTable* VT; - - DelegateeMap() { - lock = mvm::Lock::allocNormal(); - } - - ~DelegateeMap() { - delete lock; - } - - virtual void TRACER; -}; - } // end namespace jnjvm #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Thu Oct 2 18:28:36 2008 @@ -11,6 +11,7 @@ #include "llvm/Pass.h" #include "llvm/Function.h" #include "llvm/Instructions.h" +#include "llvm/Support/CallSite.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" @@ -18,6 +19,7 @@ #include "JnjvmModule.h" +#include using namespace llvm; using namespace jnjvm; @@ -34,7 +36,6 @@ char LowerConstantCalls::ID = 0; static RegisterPass X("LowerConstantCalls", "Lower Constant calls"); - bool LowerConstantCalls::runOnFunction(Function& F) { bool Changed = false; for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; BI++) { @@ -42,11 +43,13 @@ 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); + CallSite Call = CallSite::get(I); + Instruction* CI = Call.getInstruction(); + if (CI) { + Value* V = Call.getCalledValue(); if (V == jnjvm::JnjvmModule::ArrayLengthFunction) { Changed = true; - Value* val = CI->getOperand(1); // get the array + Value* val = Call.getArgument(0); // get the array Value* array = new BitCastInst(val, jnjvm::JnjvmModule::JavaArrayType, "", CI); std::vector args; //size= 2 @@ -59,7 +62,7 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetVTFunction) { Changed = true; - Value* val = CI->getOperand(1); // get the object + Value* val = Call.getArgument(0); // get the object std::vector indexes; //[3]; indexes.push_back(mvm::jit::constantZero); indexes.push_back(mvm::jit::constantZero); @@ -70,7 +73,7 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetClassFunction) { Changed = true; - Value* val = CI->getOperand(1); // get the object + Value* val = Call.getArgument(0); // get the object std::vector args2; args2.push_back(mvm::jit::constantZero); args2.push_back(jnjvm::JnjvmModule::JavaObjectClassOffsetConstant); @@ -82,7 +85,7 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetVTFromClassFunction) { Changed = true; - Value* val = CI->getOperand(1); + Value* val = Call.getArgument(0); std::vector indexes; indexes.push_back(mvm::jit::constantZero); indexes.push_back(jnjvm::JnjvmModule::OffsetVTInClassConstant); @@ -93,7 +96,7 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetObjectSizeFromClassFunction) { Changed = true; - Value* val = CI->getOperand(1); + Value* val = Call.getArgument(0); std::vector indexes; indexes.push_back(mvm::jit::constantZero); indexes.push_back(JnjvmModule::OffsetObjectSizeInClassConstant); @@ -104,7 +107,7 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetDepthFunction) { Changed = true; - Value* val = CI->getOperand(1); + Value* val = Call.getArgument(0); std::vector indexes; indexes.push_back(mvm::jit::constantZero); indexes.push_back(JnjvmModule::OffsetDepthInClassConstant); @@ -115,7 +118,7 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetDisplayFunction) { Changed = true; - Value* val = CI->getOperand(1); + Value* val = Call.getArgument(0); std::vector indexes; indexes.push_back(mvm::jit::constantZero); indexes.push_back(JnjvmModule::OffsetDisplayInClassConstant); @@ -126,21 +129,21 @@ CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::GetClassInDisplayFunction) { Changed = true; - Value* val = CI->getOperand(1); - Value* depth = CI->getOperand(2); + Value* val = Call.getArgument(0); + Value* depth = Call.getArgument(1); Value* ClassPtr = GetElementPtrInst::Create(val, depth, "", CI); Value* Class = new LoadInst(ClassPtr, "", CI); CI->replaceAllUsesWith(Class); CI->eraseFromParent(); } else if (V == jnjvm::JnjvmModule::InstanceOfFunction) { - ConstantExpr* CE = dyn_cast(CI->getOperand(2)); + 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 = CI->getOperand(1); + Value* obj = Call.getArgument(0); Instruction* cmp = new ICmpInst(ICmpInst::ICMP_EQ, obj, JnjvmModule::JavaObjectNullConstant, "", CI); @@ -175,7 +178,7 @@ args.begin(), args.end(), "", notEquals); node->addIncoming(cmp, notEquals); BranchInst::Create(ifTrue, notEquals); - } else if (cl->isArray) { + } else if (cl->isArray()) { std::vector args; args.push_back(objCl); args.push_back(CE); @@ -225,10 +228,84 @@ break; } } + + else if (V == jnjvm::JnjvmModule::GetConstantPoolAtFunction) { + Function* resolver = dyn_cast(Call.getArgument(0)); + assert(resolver && "Wrong use of GetConstantPoolAt"); + const Type* returnType = resolver->getReturnType(); + Value* CTP = Call.getArgument(1); + Value* Index = Call.getArgument(3); + Changed = true; + BasicBlock* NBB = 0; + if (CI->getParent()->getTerminator() != CI) { + NBB = II->getParent()->splitBasicBlock(II); + CI->getParent()->getTerminator()->eraseFromParent(); + } else { + InvokeInst* Invoke = dyn_cast(CI); + assert(Invoke && "Last instruction is not an invoke"); + NBB = Invoke->getNormalDest(); + } + + std::vector indexes; //[3]; +#ifdef MULTIPLE_VM + ConstantInt* Cons = dyn_cast(Index); + assert(CI && "Wrong use of GetConstantPoolAt"); + uint64 val = Cons->getZExtValue(); + indexes.push_back(ConstantInt::get(Type::Int32Ty, val + 1)); +#else + indexes.push_back(Index); +#endif + Value* arg1 = GetElementPtrInst::Create(CTP, indexes.begin(), + indexes.end(), "", CI); + arg1 = new LoadInst(arg1, "", false, CI); + Value* test = new ICmpInst(ICmpInst::ICMP_EQ, arg1, + mvm::jit::constantPtrNull, "", CI); + + BasicBlock* trueCl = BasicBlock::Create("Ctp OK", &F); + BasicBlock* falseCl = BasicBlock::Create("Ctp Not OK", &F); + PHINode* node = llvm::PHINode::Create(returnType, "", trueCl); + node->addIncoming(arg1, CI->getParent()); + BranchInst::Create(falseCl, trueCl, test, CI); + + std::vector Args; + unsigned ArgSize = Call.arg_size(), i = 1; + while (++i < ArgSize) { + Args.push_back(Call.getArgument(i)); + } + + Value* res = 0; + if (InvokeInst* Invoke = dyn_cast(CI)) { + BasicBlock* UI = Invoke->getUnwindDest(); + res = InvokeInst::Create(resolver, trueCl, UI, Args.begin(), + Args.end(), "", falseCl); + + // For some reason, an LLVM pass may add PHI nodes to the + // exception destination. + BasicBlock::iterator Temp = UI->getInstList().begin(); + while (PHINode* PHI = dyn_cast(Temp)) { + Value* Val = PHI->getIncomingValueForBlock(CI->getParent()); + PHI->removeIncomingValue(CI->getParent(), false); + PHI->addIncoming(Val, falseCl); + Temp++; + } + } else { + res = CallInst::Create(resolver, Args.begin(), Args.end(), "", + falseCl); + BranchInst::Create(trueCl, falseCl); + } + + node->addIncoming(res, falseCl); + + + CI->replaceAllUsesWith(node); + CI->eraseFromParent(); + BranchInst::Create(NBB, trueCl); + break; + } #ifdef MULTIPLE_GC else if (V == jnjvm::JnjvmModule::GetCollectorFunction) { Changed = true; - Value* val = CI->getOperand(1); + Value* val = Call.getArgument(0); std::vector indexes; indexes.push_back(mvm::jit::constantOne); val = new BitCastInst(val, mvm::jit::ptrPtrType, "", CI); @@ -240,6 +317,56 @@ CI->eraseFromParent(); } #endif + +#ifdef MULTIPLE_VM + else if (V == jnjvm::JnjvmModule::GetCtpClassFunction) { + Changed = true; + Value* val = Call.getArgument(0); + std::vector indexes; + indexes.push_back(mvm::jit::constantZero); + indexes.push_back(jnjvm::JnjvmModule::OffsetCtpInClassConstant); + Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), + indexes.end(), "", CI); + Value* VT = new LoadInst(VTPtr, "", CI); + CI->replaceAllUsesWith(VT); + CI->eraseFromParent(); + } else if (V == jnjvm::JnjvmModule::GetCtpCacheNodeFunction) { + Changed = true; + Value* val = Call.getArgument(0); + std::vector indexes; + indexes.push_back(mvm::jit::constantZero); + indexes.push_back(mvm::jit::constantFour); + Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), + indexes.end(), "", CI); + Value* VT = new LoadInst(VTPtr, "", CI); + CI->replaceAllUsesWith(VT); + CI->eraseFromParent(); + } else if (V == jnjvm::JnjvmModule::GetJnjvmArrayClassFunction) { + Changed = true; + Value* val = Call.getArgument(0); + Value* index = Call.getArgument(1); + std::vector indexes; + indexes.push_back(mvm::jit::constantZero); + indexes.push_back(mvm::jit::constantTwo); + indexes.push_back(index); + Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), + indexes.end(), "", CI); + Value* VT = new LoadInst(VTPtr, "", CI); + CI->replaceAllUsesWith(VT); + CI->eraseFromParent(); + } else if (V == jnjvm::JnjvmModule::GetJnjvmExceptionClassFunction) { + Changed = true; + Value* val = Call.getArgument(0); + std::vector indexes; + indexes.push_back(mvm::jit::constantZero); + indexes.push_back(mvm::jit::constantOne); + Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), + indexes.end(), "", CI); + Value* VT = new LoadInst(VTPtr, "", CI); + CI->replaceAllUsesWith(VT); + CI->eraseFromParent(); + } +#endif } } } Modified: vmkit/trunk/lib/JnJVM/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Makefile (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Makefile Thu Oct 2 18:28:36 2008 @@ -9,6 +9,13 @@ LEVEL = ../../.. LIBRARYNAME = JnJVM + +include $(LEVEL)/Makefile.config + include $(LEVEL)/Makefile.common CXX.Flags += -I../LLVMRuntime $(CLASSPATH_FLAGS) + +ifeq ($(ISOLATE_BUILD), 1) + CXX.Flags += -I../Isolate +endif Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Thu Oct 2 18:28:36 2008 @@ -38,15 +38,12 @@ #define PRE "Java_" #define PRE_LEN 5 -static char* jniConsFromMeth(CommonClass* cl, JavaMethod* meth) { +static char* jniConsFromMeth(CommonClass* cl, JavaMethod* meth, char* buf) { 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*)malloc(3 + PRE_LEN + mnlen + clen + (mtlen << 1)); uint32 cur = 0; char* ptr = &(buf[PRE_LEN]); @@ -75,15 +72,12 @@ } -static char* jniConsFromMeth2(CommonClass* cl, JavaMethod* meth) { +static char* jniConsFromMeth2(CommonClass* cl, JavaMethod* meth, char* buf) { 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*)malloc(3 + PRE_LEN + mnlen + clen + (mtlen << 1)); uint32 cur = 0; char* ptr = &(buf[PRE_LEN]); @@ -117,15 +111,13 @@ } -static char* jniConsFromMeth3(CommonClass* cl, JavaMethod* meth) { +static char* jniConsFromMeth3(CommonClass* cl, JavaMethod* meth, char* buf) { 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*)malloc(3 + PRE_LEN + mnlen + clen + (mtlen << 1)); uint32 cur = 0; char* ptr = &(buf[PRE_LEN]); @@ -151,7 +143,7 @@ sint32 i = 0; while (i < jniConsType->size) { char c = jniConsType->elements[i++]; - if (c == AssessorDesc::I_PARG) { + if (c == I_PARG) { ptr[0] = '_'; ptr[1] = '_'; ptr += 2; @@ -162,15 +154,15 @@ ptr[0] = '_'; ptr[1] = '1'; ptr += 2; - } else if (c == AssessorDesc::I_END_REF) { + } else if (c == I_END_REF) { ptr[0] = '_'; ptr[1] = '2'; ptr += 2; - } else if (c == AssessorDesc::I_TAB) { + } else if (c == I_TAB) { ptr[0] = '_'; ptr[1] = '3'; ptr += 2; - } else if (c == AssessorDesc::I_PARD) { + } else if (c == I_PARD) { break; } else { ptr[0] = c; @@ -183,7 +175,6 @@ return buf; } -#undef PRE_LEN static void* loadName(char* buf, bool& jnjvm) { void* res = dlsym(SELF_HANDLE, buf); @@ -205,13 +196,21 @@ } void* NativeUtil::nativeLookup(CommonClass* cl, JavaMethod* meth, bool& jnjvm) { - char* buf = jniConsFromMeth(cl, meth); + 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 + PRE_LEN + mnlen + clen + (mtlen << 1)); + jniConsFromMeth(cl, meth, buf); void* res = loadName(buf, jnjvm); if (!res) { - buf = jniConsFromMeth2(cl, meth); + buf = jniConsFromMeth2(cl, meth, buf); res = loadName(buf, jnjvm); if (!res) { - buf = jniConsFromMeth3(cl, meth); + buf = jniConsFromMeth3(cl, meth, buf); res = loadName(buf, jnjvm); if (!res) { printf("Native function %s not found. Probably " @@ -222,25 +221,27 @@ } } } - free(buf); return res; } -CommonClass* NativeUtil::resolvedImplClass(jclass clazz, bool doClinit) { +#undef PRE_LEN + +UserCommonClass* NativeUtil::resolvedImplClass(jclass clazz, bool doClinit) { + Jnjvm* vm = JavaThread::get()->isolate; JavaObject *Cl = (JavaObject*)clazz; - CommonClass* cl = (CommonClass*)Classpath::vmdataClass->getVirtualObjectField(Cl); + UserCommonClass* cl = + (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl); cl->resolveClass(); - if (doClinit) JavaThread::get()->isolate->initialiseClass(cl); + if (doClinit) cl->initialiseClass(vm); return cl; } void NativeUtil::decapsulePrimitive(Jnjvm *vm, void** &buf, JavaObject* obj, Typedef* signature) { - const AssessorDesc* funcs = signature->funcs; - if (funcs == AssessorDesc::dRef || funcs == AssessorDesc::dTab) { - if (obj && !(obj->classOf->isOfTypeName(signature->pseudoAssocClassName))) { + if (!signature->isPrimitive()) { + if (obj && !(obj->classOf->isOfTypeName(signature->getName()))) { vm->illegalArgumentException("wrong type argument"); } ((JavaObject**)buf)[0] = obj; @@ -249,122 +250,123 @@ } else if (obj == 0) { vm->illegalArgumentException(""); } else { - CommonClass* cl = obj->classOf; - AssessorDesc* value = AssessorDesc::classToPrimitive(cl); - + UserCommonClass* cl = obj->classOf; + UserClassPrimitive* value = cl->toPrimitive(vm); + PrimitiveTypedef* prim = (PrimitiveTypedef*)signature; + if (value == 0) { vm->illegalArgumentException(""); } - if (funcs == AssessorDesc::dShort) { - if (value == AssessorDesc::dShort) { - ((uint16*)buf)[0] = Classpath::shortValue->getVirtualInt16Field(obj); + if (prim->isShort()) { + if (value == vm->upcalls->OfShort) { + ((uint16*)buf)[0] = vm->upcalls->shortValue->getInt16Field(obj); buf++; return; - } else if (value == AssessorDesc::dByte) { + } else if (value == vm->upcalls->OfByte) { ((sint16*)buf)[0] = - (sint16)Classpath::byteValue->getVirtualInt8Field(obj); + (sint16)vm->upcalls->byteValue->getInt8Field(obj); buf++; return; } else { vm->illegalArgumentException(""); } - } else if (funcs == AssessorDesc::dByte) { - if (value == AssessorDesc::dByte) { - ((uint8*)buf)[0] = Classpath::byteValue->getVirtualInt8Field(obj); + } else if (prim->isByte()) { + if (value == vm->upcalls->OfByte) { + ((uint8*)buf)[0] = vm->upcalls->byteValue->getInt8Field(obj); buf++; return; } else { vm->illegalArgumentException(""); } - } else if (funcs == AssessorDesc::dBool) { - if (value == AssessorDesc::dBool) { - ((uint8*)buf)[0] = Classpath::boolValue->getVirtualInt8Field(obj); + } else if (prim->isBool()) { + if (value == vm->upcalls->OfBool) { + ((uint8*)buf)[0] = vm->upcalls->boolValue->getInt8Field(obj); buf++; return; } else { vm->illegalArgumentException(""); } - } else if (funcs == AssessorDesc::dInt) { + } else if (prim->isInt()) { sint32 val = 0; - if (value == AssessorDesc::dInt) { - val = Classpath::intValue->getVirtualInt32Field(obj); - } else if (value == AssessorDesc::dByte) { - val = (sint32)Classpath::byteValue->getVirtualInt8Field(obj); - } else if (value == AssessorDesc::dChar) { - val = (uint32)Classpath::charValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dShort) { - val = (sint32)Classpath::shortValue->getVirtualInt16Field(obj); + 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++; return; - } else if (funcs == AssessorDesc::dChar) { + } else if (prim->isChar()) { uint16 val = 0; - if (value == AssessorDesc::dChar) { - val = (uint16)Classpath::charValue->getVirtualInt16Field(obj); + if (value == vm->upcalls->OfChar) { + val = (uint16)vm->upcalls->charValue->getInt16Field(obj); } else { vm->illegalArgumentException(""); } ((uint16*)buf)[0] = val; buf++; return; - } else if (funcs == AssessorDesc::dFloat) { + } else if (prim->isFloat()) { float val = 0; - if (value == AssessorDesc::dFloat) { - val = (float)Classpath::floatValue->getVirtualFloatField(obj); - } else if (value == AssessorDesc::dByte) { - val = (float)(sint32)Classpath::byteValue->getVirtualInt8Field(obj); - } else if (value == AssessorDesc::dChar) { - val = (float)(uint32)Classpath::charValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dShort) { - val = (float)(sint32)Classpath::shortValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dInt) { - val = (float)(sint32)Classpath::intValue->getVirtualInt32Field(obj); - } else if (value == AssessorDesc::dLong) { - val = (float)Classpath::longValue->getVirtualLongField(obj); + 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++; return; - } else if (funcs == AssessorDesc::dDouble) { + } else if (prim->isDouble()) { double val = 0; - if (value == AssessorDesc::dDouble) { - val = (double)Classpath::doubleValue->getVirtualDoubleField(obj); - } else if (value == AssessorDesc::dFloat) { - val = (double)Classpath::floatValue->getVirtualFloatField(obj); - } else if (value == AssessorDesc::dByte) { - val = (double)(sint64)Classpath::byteValue->getVirtualInt8Field(obj); - } else if (value == AssessorDesc::dChar) { - val = (double)(uint64)Classpath::charValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dShort) { - val = (double)(sint16)Classpath::shortValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dInt) { - val = (double)(sint32)Classpath::intValue->getVirtualInt32Field(obj); - } else if (value == AssessorDesc::dLong) { - val = (double)(sint64)Classpath::longValue->getVirtualLongField(obj); + 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 += 2; return; - } else if (funcs == AssessorDesc::dLong) { + } else if (prim->isLong()) { sint64 val = 0; - if (value == AssessorDesc::dByte) { - val = (sint64)Classpath::byteValue->getVirtualInt8Field(obj); - } else if (value == AssessorDesc::dChar) { - val = (sint64)(uint64)Classpath::charValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dShort) { - val = (sint64)Classpath::shortValue->getVirtualInt16Field(obj); - } else if (value == AssessorDesc::dInt) { - val = (sint64)Classpath::intValue->getVirtualInt32Field(obj); - } else if (value == AssessorDesc::dLong) { - val = (sint64)Classpath::intValue->getVirtualLongField(obj); + 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(""); } @@ -378,13 +380,16 @@ } JavaObject* NativeUtil::getClassType(JnjvmClassLoader* loader, Typedef* type) { - CommonClass* res = type->assocClass(loader); - return res->getClassDelegatee(); + Jnjvm* vm = JavaThread::get()->isolate; + 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()->isolate; std::vector& args = meth->getSignature()->args; - ArrayObject* res = ArrayObject::acons(args.size(), Classpath::classArrayClass, + ArrayObject* res = ArrayObject::acons(args.size(), vm->upcalls->classArrayClass, &(JavaThread::get()->isolate->allocator)); sint32 index = 0; @@ -397,24 +402,24 @@ } -ArrayObject* NativeUtil::getExceptionTypes(JavaMethod* meth) { +ArrayObject* NativeUtil::getExceptionTypes(UserClass* cl, JavaMethod* meth) { Attribut* exceptionAtt = meth->lookupAttribut(Attribut::exceptionsAttribut); + Jnjvm* vm = JavaThread::get()->isolate; if (exceptionAtt == 0) { - return ArrayObject::acons(0, Classpath::classArrayClass, + return ArrayObject::acons(0, vm->upcalls->classArrayClass, &(JavaThread::get()->isolate->allocator)); } else { - Class* cl = meth->classDef; - JavaConstantPool* ctp = cl->getConstantPool(); + UserConstantPool* ctp = cl->getConstantPool(); Reader reader(exceptionAtt, cl->getBytes()); uint16 nbe = reader.readU2(); - ArrayObject* res = ArrayObject::acons(nbe, Classpath::classArrayClass, + ArrayObject* res = ArrayObject::acons(nbe, vm->upcalls->classArrayClass, &(JavaThread::get()->isolate->allocator)); for (uint16 i = 0; i < nbe; ++i) { uint16 idx = reader.readU2(); - CommonClass* cl = ctp->loadClass(idx); + UserCommonClass* cl = ctp->loadClass(idx); cl->resolveClass(); - JavaObject* obj = cl->getClassDelegatee(); + 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=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Thu Oct 2 18:28:36 2008 @@ -29,13 +29,13 @@ static Jnjvm* myVM(JNIEnv* env); static void* nativeLookup(CommonClass* cl, JavaMethod* meth, bool& jnjvm); - static CommonClass* resolvedImplClass(jclass clazz, bool doClinit); + static UserCommonClass* resolvedImplClass(jclass clazz, bool doClinit); static void decapsulePrimitive(Jnjvm *vm, void**&buf, JavaObject* obj, Typedef* signature); static JavaObject* getClassType(JnjvmClassLoader* loader, Typedef* type); static ArrayObject* getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth); - static ArrayObject* getExceptionTypes(JavaMethod* meth); + static ArrayObject* getExceptionTypes(UserClass* cl, JavaMethod* meth); }; Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Thu Oct 2 18:28:36 2008 @@ -15,6 +15,7 @@ #include "Jnjvm.h" #include "JavaArray.h" #include "JavaThread.h" +#include "JavaUpcalls.h" #include "Reader.h" #include "Zip.h" @@ -24,25 +25,28 @@ const int Reader::SeekCur = SEEK_CUR; const int Reader::SeekEnd = SEEK_END; -ArrayUInt8* Reader::openFile(JnjvmClassLoader* loader, char* path) { +ArrayUInt8* Reader::openFile(JnjvmBootstrapLoader* loader, char* path) { FILE* fp = fopen(path, "r"); ArrayUInt8* res = 0; if (fp != 0) { fseek(fp, 0, SeekEnd); long nbb = ftell(fp); fseek(fp, 0, SeekSet); - res = ArrayUInt8::acons(nbb, JavaArray::ofByte, loader->allocator); + UserClassArray* array = loader->upcalls->ArrayOfByte; + res = ArrayUInt8::acons(nbb, array, loader->allocator); fread(res->elements, nbb, 1, fp); fclose(fp); } return res; } -ArrayUInt8* Reader::openZip(JnjvmClassLoader* loader, ZipArchive* archive, char* filename) { +ArrayUInt8* Reader::openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive, + char* filename) { ArrayUInt8* ret = 0; ZipFile* file = archive->getFile(filename); if (file != 0) { - ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, loader->allocator); + UserClassArray* array = loader->upcalls->ArrayOfByte; + ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, array, loader->allocator); if (archive->readFile(res, file) != 0) { ret = res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Reader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Reader.h Thu Oct 2 18:28:36 2008 @@ -19,7 +19,7 @@ namespace jnjvm { -class JnjvmClassLoader; +class JnjvmBootstrapLoader; class ZipArchive; class Reader { @@ -76,8 +76,8 @@ static const int SeekCur; static const int SeekEnd; - static ArrayUInt8* openFile(JnjvmClassLoader* loader, char* path); - static ArrayUInt8* openZip(JnjvmClassLoader* loader, ZipArchive* archive, char* filename); + static ArrayUInt8* openFile(JnjvmBootstrapLoader* loader, char* path); + static ArrayUInt8* openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive, char* filename); uint8 readU1() { return bytes->elements[cursor++]; Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Thu Oct 2 18:28:36 2008 @@ -14,12 +14,17 @@ #include "JavaClass.h" #include "JavaObject.h" #include "JavaThread.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" #include "JnjvmClassLoader.h" #include "LockedMap.h" #ifdef SERVICE_VM #include "ServiceDomain.h" #endif +#ifdef MULTIPLE_VM +#include "SharedMaps.h" +#include "IsolateSharedLoader.h" +#endif using namespace jnjvm; @@ -33,12 +38,14 @@ INIT(JavaThread); INIT(Jnjvm); INIT(ClassMap); - INIT(StaticInstanceMap); - INIT(DelegateeMap); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); #ifdef MULTIPLE_VM INIT(JnjvmSharedLoader); + INIT(SharedClassByteMap); + INIT(UserClass); + INIT(UserClassArray); + INIT(UserConstantPool); #endif #ifdef SERVICE_VM INIT(ServiceDomain); @@ -102,12 +109,11 @@ void Jnjvm::TRACER { appClassLoader->MARK_AND_TRACE; TRACE_VECTOR(JavaObject*, gc_allocator, globalRefs); + bootstrapThread->MARK_AND_TRACE; + bootstrapLoader->MARK_AND_TRACE; #ifdef MULTIPLE_VM - statics->MARK_AND_TRACE; - delegatees->MARK_AND_TRACE; + JnjvmSharedLoader::sharedLoader->MARK_AND_TRACE; #endif - bootstrapThread->MARK_AND_TRACE; - JnjvmClassLoader::bootstrapLoader->MARK_AND_TRACE; } void ClassMap::TRACER { @@ -116,18 +122,6 @@ } } -void StaticInstanceMap::TRACER { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - i->second->second->MARK_AND_TRACE; - } -} - -void DelegateeMap::TRACER { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - i->second->MARK_AND_TRACE; - } -} - void JnjvmClassLoader::TRACER { javaLoader->MARK_AND_TRACE; classes->MARK_AND_TRACE; @@ -141,23 +135,50 @@ e = bootArchives.end(); i != e; ++i) { (*i)->bytes->MARK_AND_TRACE; } -#ifndef MULTIPLE_VM #define TRACE_DELEGATEE(prim) \ - prim->classType->delegatee->MARK_AND_TRACE + prim->delegatee->MARK_AND_TRACE - TRACE_DELEGATEE(AssessorDesc::dVoid); - TRACE_DELEGATEE(AssessorDesc::dBool); - TRACE_DELEGATEE(AssessorDesc::dByte); - TRACE_DELEGATEE(AssessorDesc::dChar); - TRACE_DELEGATEE(AssessorDesc::dShort); - TRACE_DELEGATEE(AssessorDesc::dInt); - TRACE_DELEGATEE(AssessorDesc::dFloat); - TRACE_DELEGATEE(AssessorDesc::dLong); - TRACE_DELEGATEE(AssessorDesc::dDouble); + TRACE_DELEGATEE(upcalls->OfVoid); + TRACE_DELEGATEE(upcalls->OfBool); + TRACE_DELEGATEE(upcalls->OfByte); + TRACE_DELEGATEE(upcalls->OfChar); + TRACE_DELEGATEE(upcalls->OfShort); + TRACE_DELEGATEE(upcalls->OfInt); + TRACE_DELEGATEE(upcalls->OfFloat); + TRACE_DELEGATEE(upcalls->OfLong); + TRACE_DELEGATEE(upcalls->OfDouble); #undef TRACE_DELEGATEE -#endif } +#ifdef MULTIPLE_VM +void UserClass::TRACER { + classLoader->MARK_AND_TRACE; + delegatee->MARK_AND_TRACE; + staticInstance->MARK_AND_TRACE; + ctpInfo->MARK_AND_TRACE; +} + +void UserClassPrimitive::TRACER { + classLoader->MARK_AND_TRACE; + delegatee->MARK_AND_TRACE; +} + +void UserClassArray::TRACER { + classLoader->MARK_AND_TRACE; + delegatee->MARK_AND_TRACE; +} + +void SharedClassByteMap::TRACER { + for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { + i->first->MARK_AND_TRACE; + } +} + +void JnjvmSharedLoader::TRACER { + byteClasses->MARK_AND_TRACE; +} +#endif + #ifdef SERVICE_VM void ServiceDomain::TRACER { JavaIsolate::PARENT_TRACER; Modified: vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gc.cpp Thu Oct 2 18:28:36 2008 @@ -234,8 +234,7 @@ if(!loc) /* a key is being destroyed */ COLLECTOR threads->another_mark(); else { - unsigned int* top; - register unsigned int **cur = ⊤ + register unsigned int **cur = (unsigned int**)(void*)&buf; register unsigned int **max = loc->base_sp(); GCChunkNode *node; Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Thu Oct 2 18:28:36 2008 @@ -315,12 +315,12 @@ #endif int mvm::jit::getBacktrace(void** stack, int size) { - void** blah = (void**)__builtin_frame_address(1); + void** addr = (void**)__builtin_frame_address(0); int cpt = 0; void* baseSP = mvm::Thread::get()->baseSP; - while (blah && cpt < size && blah < baseSP) { - stack[cpt++] = (void**)FRAME_IP(blah); - blah = (void**)blah[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/lib/Mvm/Runtime/LLVMRuntime.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll (original) +++ vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Thu Oct 2 18:28:36 2008 @@ -14,8 +14,8 @@ declare void @_Unwind_Resume_or_Rethrow(i8*) declare i8* @llvm.eh.exception() -declare i32 @llvm.eh.selector.i32(i8*, i8*, i8*, ...) -declare i64 @llvm.eh.selector.i64(i8*, i8*, i8*, ...) +declare i32 @llvm.eh.selector.i32(i8*, i8*, ...) +declare i64 @llvm.eh.selector.i64(i8*, i8*, ...) declare void @__gxx_personality_v0() declare i8* @__cxa_begin_catch(i8*) declare void @__cxa_end_catch() Modified: vmkit/trunk/lib/N3/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/Makefile (original) +++ vmkit/trunk/lib/N3/Makefile Thu Oct 2 18:28:36 2008 @@ -10,7 +10,7 @@ include $(LEVEL)/Makefile.config -DIRS = VMCore +DIRS = LLVMRuntime VMCore ifeq ($(WITH_N3_MONO), 1) DIRS += Mono Modified: vmkit/trunk/lib/N3/VMCore/CLIJit.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJit.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIJit.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLIJit.cpp Thu Oct 2 18:28:36 2008 @@ -14,6 +14,7 @@ #include "debug.h" #include "types.h" +#include "llvm/CallingConv.h" #include #include #include @@ -1497,33 +1498,6 @@ } -extern "C" VMObject* initialiseClass(VMClass* cl) { - cl->clinitClass(NULL); - return cl->staticInstance; -} - -extern "C" void n3ClassCastException() { - fflush(stdout); - assert(0 && "implement class cast exception"); -} - -extern "C" void n3NullPointerException() { - fflush(stdout); - assert(0 && "implement null pointer exception"); -} - -extern "C" void indexOutOfBounds() { - fflush(stdout); - assert(0 && "implement index out of bounds exception"); -} - - -extern "C" VMObject* newString(const UTF8* utf8) { - CLIString * str = - (CLIString*)(((N3*)VMThread::get()->vm)->UTF8ToStr(utf8)); - return str; -} - void CLIJit::initialise() { } @@ -1533,501 +1507,82 @@ mvm::jit::protectEngine->unlock(); } +namespace n3 { + namespace llvm_runtime { + #include "LLVMRuntime.inc" + } +} + + void CLIJit::initialiseBootstrapVM(N3* vm) { Module* module = vm->module; mvm::jit::protectEngine->lock(); mvm::jit::executionEngine->addModuleProvider(vm->TheModuleProvider); mvm::jit::protectEngine->unlock(); - - - - { - std::vector arg_types; - arg_types.insert (arg_types.begin (), llvm::PointerType::getUnqual(mvm::jit::ptrType)); - llvm::FunctionType *mtype = llvm::FunctionType::get (llvm::Type::VoidTy, arg_types, false); - Function::Create(mtype, llvm::GlobalValue::ExternalLinkage, "llvm.va_start", module); - } - - { - std::vector arg_types; - arg_types.insert (arg_types.begin (), llvm::Type::Int32Ty); - - llvm::FunctionType *mtype = llvm::FunctionType::get (llvm::PointerType::getUnqual(llvm::Type::Int8Ty), arg_types, false); - Function::Create(mtype, llvm::GlobalValue::ExternalLinkage, "llvm.frameaddress", module); - } + n3::llvm_runtime::makeLLVMModuleContents(module); - - { - const llvm::Type *BPTy = PointerType::getUnqual(llvm::Type::Int8Ty); - // Prototype malloc as "char* malloc(...)", because we don't know in - // doInitialization whether size_t is int or long. - FunctionType *FT = FunctionType::get(BPTy, std::vector(), true); - Function::Create(FT, llvm::GlobalValue::ExternalLinkage, "_ZN2gcnwEjP5gc_vt", module); - } - - - // Create VMObject::llvmType - const llvm::Type* Pty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); - - std::vector objectFields; - objectFields.push_back(Pty); // VT - objectFields.push_back(Pty); // Class - objectFields.push_back(Pty); // Lock VMObject::llvmType = - llvm::PointerType::getUnqual(llvm::StructType::get(objectFields, false)); - - // Create VMArray::llvmType - { - std::vector arrayFields; - arrayFields.push_back(VMObject::llvmType->getContainedType(0)); - arrayFields.push_back(llvm::Type::Int32Ty); - VMArray::llvmType = - llvm::PointerType::getUnqual(llvm::StructType::get(arrayFields, false)); - } - -#define ARRAY_TYPE(name, type) \ - { \ - std::vector arrayFields; \ - arrayFields.push_back(VMObject::llvmType->getContainedType(0)); \ - arrayFields.push_back(Type::Int32Ty); \ - arrayFields.push_back(ArrayType::get(type, 0)); \ - name::llvmType = PointerType::getUnqual(StructType::get(arrayFields, false)); \ - } - - ARRAY_TYPE(ArrayUInt8, Type::Int8Ty); - ARRAY_TYPE(ArraySInt8, Type::Int8Ty); - ARRAY_TYPE(ArrayUInt16, Type::Int16Ty); - ARRAY_TYPE(ArraySInt16, Type::Int16Ty); - ARRAY_TYPE(ArrayUInt32, Type::Int32Ty); - ARRAY_TYPE(ArraySInt32, Type::Int32Ty); - ARRAY_TYPE(ArrayLong, Type::Int64Ty); - ARRAY_TYPE(ArrayDouble, Type::DoubleTy); - ARRAY_TYPE(ArrayFloat, Type::FloatTy); - ARRAY_TYPE(ArrayObject, VMObject::llvmType); - -#undef ARRAY_TYPE - - // Create UTF8::llvmType - { - std::vector arrayFields; - arrayFields.push_back(VMObject::llvmType->getContainedType(0)); - arrayFields.push_back(llvm::Type::Int32Ty); - arrayFields.push_back(llvm::ArrayType::get(llvm::Type::Int16Ty, 0)); - UTF8::llvmType = - llvm::PointerType::getUnqual(llvm::StructType::get(arrayFields, false)); - } + PointerType::getUnqual(module->getTypeByName("CLIObject")); + VMArray::llvmType = + PointerType::getUnqual(module->getTypeByName("CLIArray")); + ArrayUInt8::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayUInt8")); + ArraySInt8::llvmType = + PointerType::getUnqual(module->getTypeByName("ArraySInt8")); + ArrayUInt16::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayUInt16")); + ArraySInt16::llvmType = + PointerType::getUnqual(module->getTypeByName("ArraySInt16")); + ArraySInt32::llvmType = + PointerType::getUnqual(module->getTypeByName("ArraySInt32")); + ArrayLong::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayLong")); + ArrayDouble::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayDouble")); + ArrayFloat::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayFloat")); + ArrayObject::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayObject")); + UTF8::llvmType = + PointerType::getUnqual(module->getTypeByName("ArrayUInt16")); + CacheNode::llvmType = + PointerType::getUnqual(module->getTypeByName("CacheNode")); + Enveloppe::llvmType = + PointerType::getUnqual(module->getTypeByName("Enveloppe")); - // Create CacheNode::llvmType - { - std::vector arrayFields; - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // VT - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // methPtr - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // lastCible - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // next - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // enveloppe - arrayFields.push_back(Type::Int1Ty); // box - CacheNode::llvmType = - PointerType::getUnqual(StructType::get(arrayFields, false)); - } - - // Create Enveloppe::llvmType - { - std::vector arrayFields; - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // VT - arrayFields.push_back(CacheNode::llvmType); // firstCache - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // cacheLock - arrayFields.push_back(PointerType::getUnqual(Type::Int8Ty)); // originalMethod - Enveloppe::llvmType = - PointerType::getUnqual(StructType::get(arrayFields, false)); - } - #ifdef WITH_TRACER - // Create markAndTraceLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); -#ifdef MULTIPLE_GC - args.push_back(mvm::jit::ptrType); -#endif - markAndTraceLLVMType = FunctionType::get(llvm::Type::VoidTy, args, false); - markAndTraceLLVM = Function::Create(markAndTraceLLVMType, - GlobalValue::ExternalLinkage, -#ifdef MULTIPLE_GC - "_ZNK2gc12markAndTraceEP9Collector", -#else - "_ZNK2gc12markAndTraceEv", -#endif - module); - } -#endif - - // Create vmObjectTracerLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); -#ifdef MULTIPLE_GC - args.push_back(mvm::jit::ptrType); -#endif - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - vmObjectTracerLLVM = Function::Create(type, - GlobalValue::ExternalLinkage, -#ifdef MULTIPLE_GC - "_ZN2n38VMObject6tracerEPv", -#else - "_ZN2n38VMObject6tracerEv", + markAndTraceLLVM = module->getFunction("MarkAndTrace"); + markAndTraceLLVMType = markAndTraceLLVM->getFunctionType(); + vmObjectTracerLLVM = module->getFunction("CLIObjectTracer"); #endif - module); - } - // Create intialiseClassLLVM - { - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, false); - initialiseClassLLVM = Function::Create(type, - GlobalValue::ExternalLinkage, - "initialiseClass", - module); - } - - // Create resolveStringLLVM - /*{ - std::vector args; - args.push_back(UTF8::llvmType); - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - args.push_back(llvm::Type::Int32Ty); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - false); - stringLookupLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n37CLIJit12stringLookupEPKNS_4UTF8EPNS_5ClassEj", - module); - }*/ - - // Create staticLookupLLVM - /*{ - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - args.push_back(llvm::Type::Int32Ty); - const FunctionType* type = - FunctionType::get(llvm::PointerType::getUnqual(llvm::Type::Int8Ty), args, - false); - - staticLookupLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n37CLIJit12staticLookupEPNS_5ClassEj", - module); - }*/ - - // Create virtualLookupLLVM - { - std::vector args; - //args.push_back(VMObject::llvmType); - //args.push_back(PointerType::getUnqual(Type::Int8Ty)); - //args.push_back(llvm::Type::Int32Ty); - args.push_back(CacheNode::llvmType); - args.push_back(VMObject::llvmType); - const FunctionType* type = - FunctionType::get(CacheNode::llvmType, args, false); - - virtualLookupLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "n3VirtualLookup", module); - -/* - virtualLookupLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n37CLIJit13virtualLookupEPNS_10VMObjectEPNS_5ClassEj", - module); -*/ - } - - // Create newLookupLLVM - /*{ - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - args.push_back(llvm::Type::Int32Ty); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - false); - - newLookupLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n37CLIJit9newLookupEPNS_5ClassEj", - module); - }*/ - - // Create arrayConsLLVM - { - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - args.push_back(Type::Int32Ty); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - false); - - arrayConsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n312VMClassArray5doNewEj", - module); - } - - // Create objConsLLVM - { - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - false); - - objConsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n37VMClass5doNewEv", - module); - } - - // Create objInitLLVM - { - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - args.push_back(VMObject::llvmType); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - false); - - objInitLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n37VMClass16initialiseObjectEPNS_8VMObjectE", - module); - PAListPtr func_toto_PAL; - SmallVector Attrs; - ParamAttrsWithIndex PAWI; - PAWI.Index = 0; PAWI.Attrs = 0 | ParamAttr::ReadNone; - Attrs.push_back(PAWI); - func_toto_PAL = PAListPtr::get(Attrs.begin(), Attrs.end()); - objInitLLVM->setParamAttrs(func_toto_PAL); - } - - // Create arrayLengthLLVM - { - std::vector args; - args.push_back(VMArray::llvmType); - const FunctionType* type = FunctionType::get(Type::Int32Ty, args, false); - - arrayLengthLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "arrayLength", - module); - PAListPtr func_toto_PAL; - SmallVector Attrs; - ParamAttrsWithIndex PAWI; - PAWI.Index = 0; PAWI.Attrs = 0 | ParamAttr::ReadNone; - Attrs.push_back(PAWI); - func_toto_PAL = PAListPtr::get(Attrs.begin(), Attrs.end()); - arrayLengthLLVM->setParamAttrs(func_toto_PAL); - } + initialiseClassLLVM = module->getFunction("initialiseClass"); + virtualLookupLLVM = module->getFunction("n3VirtualLookup"); - - // Create nullPointerExceptionLLVM - { - std::vector args; - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); + arrayConsLLVM = module->getFunction("newArray"); + objConsLLVM = module->getFunction("newObject"); + newStringLLVM = module->getFunction("newString"); + objInitLLVM = module->getFunction("initialiseObject"); + arrayMultiConsLLVM = module->getFunction("newMultiArray"); + arrayLengthLLVM = module->getFunction("arrayLength"); + instanceOfLLVM = module->getFunction("n3InstanceOf"); - nullPointerExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "n3NullPointerException", - module); - } - - // Create classCastExceptionLLVM - { - std::vector args; - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); + nullPointerExceptionLLVM = module->getFunction("n3NullPointerException"); + classCastExceptionLLVM = module->getFunction("n3ClassCastException"); + indexOutOfBoundsExceptionLLVM = module->getFunction("indexOutOfBounds"); - classCastExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "n3ClassCastException", - module); - } - - // Create indexOutOfBoundsExceptionLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); - args.push_back(Type::Int32Ty); - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - - indexOutOfBoundsExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "indexOutOfBounds", - module); - } - - // Create proceedPendingExceptionLLVM - /*{ - std::vector args; - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - - jniProceedPendingExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n37CLIJit26jniProceedPendingExceptionEv", - module); - }*/ - // Create printExecutionLLVM - { - std::vector args; - args.push_back(Type::Int32Ty); - args.push_back(Type::Int32Ty); - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); + throwExceptionLLVM = module->getFunction("ThrowException"); + clearExceptionLLVM = module->getFunction("ClearException"); + compareExceptionLLVM = module->getFunction("CompareException"); + getCppExceptionLLVM = module->getFunction("GetCppException"); + getCLIExceptionLLVM = module->getFunction("GetCLIException"); - printExecutionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n36CLIJit14printExecutionEPcPNS_8VMMethodE", - module); - } - - // Create throwExceptionLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - - throwExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n38VMThread14throwExceptionEPNS_8VMObjectE", - module); - } - - // Create clearExceptionLLVM - { - std::vector args; - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - clearExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n38VMThread14clearExceptionEv", - module); - } - - - // Create compareExceptionLLVM - { - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - const FunctionType* type = FunctionType::get(Type::Int1Ty, args, false); + printExecutionLLVM = module->getFunction("printExecution"); - compareExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n38VMThread16compareExceptionEPNS_7VMClassE", - module); - } - - // Create instanceOfLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - const FunctionType* type = FunctionType::get(Type::Int32Ty, args, false); - - instanceOfLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n38VMObject10instanceOfEPNS_13VMCommonClassE", - module); - } - - // Create arrayMultiConsLLVM - { - std::vector args; - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - true); - - arrayMultiConsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "doMultiNew", - module); - } - - /* - // Create aquireObjectLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - - aquireObjectLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n310VMObject6aquireEv", - module); - } - - // Create releaseObjectLLVM - { - std::vector args; - args.push_back(VMObject::llvmType); - const FunctionType* type = FunctionType::get(Type::VoidTy, args, false); - - releaseObjectLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n310VMObject6unlockEv", - module); - } - - */ - - - // Create *AconsLLVM - /*{ - std::vector args; - args.push_back(Type::Int32Ty); - args.push_back(PointerType::getUnqual(Type::Int8Ty)); - const FunctionType* type = FunctionType::get(VMObject::llvmType, args, - false); - - FloatAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n310ArrayFloat5aconsEiPNS_10VMClassArrayE", - module); - - Int8AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n310ArraySInt85aconsEiPNS_10VMClassArrayE", - module); - - DoubleAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n311ArrayDouble5aconsEiPNS_10VMClassArrayE", - module); - - Int16AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n311ArraySInt165aconsEiPNS_10VMClassArrayE", - module); - - Int32AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n311ArraySInt325aconsEiPNS_10VMClassArrayE", - module); - - UTF8AconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n34UTF85aconsEiPNS_10VMClassArrayE", - module); - - LongAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n39ArrayLong5aconsEiPNS_10VMClassArrayE", - module); - - ObjectAconsLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN5n311ArrayObject5aconsEiPNS_10VMClassArrayE", - module); - }*/ - - // Create getCppExceptionLLVM - { - std::vector args; - const FunctionType* type = FunctionType::get(mvm::jit::ptrType, - args, false); - - getCppExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n38VMThread15getCppExceptionEv", - module); - } - - // Create getCLIExceptionLLVM - { - std::vector args; - const FunctionType* type = FunctionType::get(VMObject::llvmType, - args, false); - - getCLIExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "_ZN2n38VMThread15getCLIExceptionEv", - module); - } - - // Create newStringLLVM - { - std::vector args; - args.push_back(mvm::jit::ptrType); - const FunctionType* type = FunctionType::get(VMObject::llvmType, - args, false); - - newStringLLVM = Function::Create(type, GlobalValue::ExternalLinkage, - "newString", - module); - } constantVMObjectNull = Constant::getNullValue(VMObject::llvmType); Added: vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp?rev=56982&view=auto ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp (added) +++ vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp Thu Oct 2 18:28:36 2008 @@ -0,0 +1,183 @@ +//===--- CLIRuntimeJIT.cpp - Runtime functions for the JIT compiled code --===// +// +// The vmkit project +// +// This file is distributed under the University Of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + + +#include + +#include "llvm/DerivedTypes.h" +#include "llvm/Instructions.h" + +#include "mvm/JIT.h" +#include "mvm/Object.h" +#include "mvm/PrintBuffer.h" +#include "mvm/Threads/Locks.h" + +#include "CLIString.h" +#include "MSCorlib.h" +#include "N3.h" +#include "VMArray.h" +#include "VMCache.h" +#include "VMClass.h" +#include "VMObject.h" +#include "VMThread.h" + +using namespace n3; +using namespace llvm; + +extern "C" VMObject* initialiseClass(VMClass* cl) { + cl->clinitClass(NULL); + return cl->staticInstance; +} + +extern "C" void n3ClassCastException() { + fflush(stdout); + assert(0 && "implement class cast exception"); +} + +extern "C" void n3NullPointerException() { + fflush(stdout); + assert(0 && "implement null pointer exception"); +} + +extern "C" void indexOutOfBounds() { + fflush(stdout); + assert(0 && "implement index out of bounds exception"); +} + +extern "C" VMObject* newString(const UTF8* utf8) { + CLIString * str = + (CLIString*)(((N3*)VMThread::get()->vm)->UTF8ToStr(utf8)); + return str; +} + +extern "C" bool n3InstanceOf(VMObject* obj, VMCommonClass* cl) { + return obj->instanceOf(cl); +} + +extern "C" void* GetCppException() { + return VMThread::getCppException(); +} + +extern "C" void ThrowException(VMObject* obj) { + return VMThread::throwException(obj); +} + +extern "C" VMObject* GetCLIException() { + return VMThread::getCLIException(); +} + +extern "C" bool CompareException(VMClass* cl) { + return VMThread::compareException(cl); +} + +extern "C" void ClearException() { + return VMThread::clearException(); +} + +static VMObject* doMultiNewIntern(VMClassArray* cl, uint32 dim, sint32* buf) { + if (dim <= 0) VMThread::get()->vm->error("Can't happen"); + sint32 n = buf[0]; + if (n < 0) VMThread::get()->vm->negativeArraySizeException(n); + + VMArray* res = (VMArray*)cl->doNew(n); + if (dim > 1) { + VMCommonClass* base = cl->baseClass; + if (n > 0) { + for (sint32 i = 0; i < n; ++i) { + res->elements[i] = doMultiNewIntern((VMClassArray*)base, dim - 1, &(buf[1])); + } + } + for (uint32 i = 1; i < dim; ++i) { + if (buf[i] < 0) VMThread::get()->vm->negativeArraySizeException(buf[i]); + } + } + return res; +} + +extern "C" VMObject* doMultiNew(VMClassArray* cl, ...) { + sint32* dimSizes = (sint32*)alloca(cl->dims * sizeof(sint32)); + va_list ap; + va_start(ap, cl); + for (uint32 i = 0; i < cl->dims; ++i) { + dimSizes[i] = va_arg(ap, sint32); + } + va_end(ap); + return doMultiNewIntern(cl, cl->dims, dimSizes); +} + +extern "C" CacheNode* n3VirtualLookup(CacheNode* cache, VMObject *obj) { + Enveloppe* enveloppe = cache->enveloppe; + VMCommonClass* ocl = obj->classOf; + VMMethod* orig = enveloppe->originalMethod; + + CacheNode* rcache = 0; + CacheNode* tmp = enveloppe->firstCache; + CacheNode* last = tmp; + enveloppe->cacheLock->lock(); + + while (tmp) { + if (ocl == tmp->lastCible) { + rcache = tmp; + break; + } else { + last = tmp; + tmp = tmp->next; + } + } + + if (!rcache) { + VMMethod* dmeth = ocl->lookupMethodDontThrow(orig->name, + orig->parameters, + false, true); + if (dmeth == 0) { + char* methAsciiz = orig->name->UTF8ToAsciiz(); + char* nameAsciiz = orig->classDef->name->UTF8ToAsciiz(); + char* nameSpaceAsciiz = orig->classDef->nameSpace->UTF8ToAsciiz(); + + char *buf = (char*)alloca(3 + strlen(methAsciiz) + + strlen(nameAsciiz) + + strlen(nameSpaceAsciiz)); + sprintf(buf, "%s.%s.%s", nameSpaceAsciiz, nameAsciiz, methAsciiz); + const UTF8* newName = VMThread::get()->vm->asciizConstructUTF8(buf); + dmeth = ocl->lookupMethod(newName, orig->parameters, false, true); + } + + if (cache->methPtr) { + rcache = CacheNode::allocate(); + rcache->enveloppe = enveloppe; + } else { + rcache = cache; + } + + Function* func = dmeth->compiledPtr(NULL); + rcache->methPtr = mvm::jit::executionEngine->getPointerToGlobal(func); + rcache->lastCible = (VMClass*)ocl; + rcache->box = (dmeth->classDef->super == MSCorlib::pValue); + } + + if (enveloppe->firstCache != rcache) { + CacheNode *f = enveloppe->firstCache; + enveloppe->firstCache = rcache; + last->next = rcache->next; + rcache->next = f; + + } + + enveloppe->cacheLock->unlock(); + + return rcache; +} + +extern "C" VMObject* newObject(VMClass* cl) { + return cl->doNew(); +} + +extern "C" VMObject* newArray(VMClassArray* cl, sint32 nb) { + return cl->doNew(nb); +} Modified: vmkit/trunk/lib/N3/VMCore/CLISignature.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLISignature.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLISignature.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLISignature.cpp Thu Oct 2 18:28:36 2008 @@ -300,10 +300,9 @@ if (currGenericMethod == NULL) { // when reading in signatures which contain references to generic arguments // of generic methods we need create a placeholder for each of them, - // this is done by creating a dummy VMClass, - // the token field is used to store the generic argument number + // this is done by creating a dummy VMClass which has the assembly field + // set to NULL, the token field is used to store the generic argument number VMClass* cl = gc_new(VMClass)(); - cl->isDummy = true; cl->token = number; cl->assembly = ass; cl->nameSpace = ass->name; Modified: vmkit/trunk/lib/N3/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/Makefile (original) +++ vmkit/trunk/lib/N3/VMCore/Makefile Thu Oct 2 18:28:36 2008 @@ -10,3 +10,5 @@ LIBRARYNAME = N3 include $(LEVEL)/Makefile.common + +CXX.Flags += -I../LLVMRuntime Modified: vmkit/trunk/lib/N3/VMCore/VMCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMCache.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMCache.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMCache.cpp Thu Oct 2 18:28:36 2008 @@ -157,66 +157,3 @@ push(ret); } } - -extern "C" CacheNode* n3VirtualLookup(CacheNode* cache, VMObject *obj) { - Enveloppe* enveloppe = cache->enveloppe; - VMCommonClass* ocl = obj->classOf; - VMMethod* orig = enveloppe->originalMethod; - - CacheNode* rcache = 0; - CacheNode* tmp = enveloppe->firstCache; - CacheNode* last = tmp; - enveloppe->cacheLock->lock(); - - while (tmp) { - if (ocl == tmp->lastCible) { - rcache = tmp; - break; - } else { - last = tmp; - tmp = tmp->next; - } - } - - if (!rcache) { - VMMethod* dmeth = ocl->lookupMethodDontThrow(orig->name, - orig->parameters, - false, true); - if (dmeth == 0) { - char* methAsciiz = orig->name->UTF8ToAsciiz(); - char* nameAsciiz = orig->classDef->name->UTF8ToAsciiz(); - char* nameSpaceAsciiz = orig->classDef->nameSpace->UTF8ToAsciiz(); - - char *buf = (char*)alloca(3 + strlen(methAsciiz) + - strlen(nameAsciiz) + - strlen(nameSpaceAsciiz)); - sprintf(buf, "%s.%s.%s", nameSpaceAsciiz, nameAsciiz, methAsciiz); - const UTF8* newName = VMThread::get()->vm->asciizConstructUTF8(buf); - dmeth = ocl->lookupMethod(newName, orig->parameters, false, true); - } - - if (cache->methPtr) { - rcache = CacheNode::allocate(); - rcache->enveloppe = enveloppe; - } else { - rcache = cache; - } - - Function* func = dmeth->compiledPtr(NULL); - rcache->methPtr = mvm::jit::executionEngine->getPointerToGlobal(func); - rcache->lastCible = (VMClass*)ocl; - rcache->box = (dmeth->classDef->super == MSCorlib::pValue); - } - - if (enveloppe->firstCache != rcache) { - CacheNode *f = enveloppe->firstCache; - enveloppe->firstCache = rcache; - last->next = rcache->next; - rcache->next = f; - - } - - enveloppe->cacheLock->unlock(); - - return rcache; -} Modified: vmkit/trunk/lib/N3/VMCore/VMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMClass.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMClass.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMClass.cpp Thu Oct 2 18:28:36 2008 @@ -168,7 +168,6 @@ this->isArray = isArray; this->isPointer = false; this->isPrimitive = false; - this->isDummy = false; this->naturalType = llvm::OpaqueType::get(); } @@ -640,38 +639,6 @@ return res; } -static VMObject* doMultiNewIntern(VMClassArray* cl, uint32 dim, sint32* buf) { - if (dim <= 0) VMThread::get()->vm->error("Can't happen"); - sint32 n = buf[0]; - if (n < 0) VMThread::get()->vm->negativeArraySizeException(n); - - VMArray* res = (VMArray*)cl->doNew(n); - if (dim > 1) { - VMCommonClass* base = cl->baseClass; - if (n > 0) { - for (sint32 i = 0; i < n; ++i) { - res->elements[i] = doMultiNewIntern((VMClassArray*)base, dim - 1, &(buf[1])); - } - } - for (uint32 i = 1; i < dim; ++i) { - if (buf[i] < 0) VMThread::get()->vm->negativeArraySizeException(buf[i]); - } - } - return res; -} - -extern "C" VMObject* doMultiNew(VMClassArray* cl, ...) { - sint32* dimSizes = (sint32*)alloca(cl->dims * sizeof(sint32)); - va_list ap; - va_start(ap, cl); - for (uint32 i = 0; i < cl->dims; ++i) { - dimSizes[i] = va_arg(ap, sint32); - } - va_end(ap); - return doMultiNewIntern(cl, cl->dims, dimSizes); -} - - static void disassembleStruct(std::vector &args, const llvm::Type* arg) { const llvm::StructType* STy = llvm::dyn_cast(arg); @@ -832,14 +799,16 @@ std::vector::iterator i = parameters.begin(), a = args.begin(), e = args.end(); + // dummy classes for generic arguments have a NULL assembly field // check whether both i and a point to a dummy class - if (((*i)->isDummy && !(*a)->isDummy) || (!(*i)->isDummy && (*a)->isDummy)) + if (((*i)->assembly == NULL && (*a)->assembly != NULL) || + ((*i)->assembly != NULL && (*a)->assembly == NULL)) return false; // dummy classes for generic arguments contain the // argument number in the token field // signature is only equal if the argument number matches - if ((*i)->isDummy && (*a)->isDummy) { + if ((*i)->assembly == NULL && (*a)->assembly == NULL) { if ((*i)->token != (*a)->token) { return false; } @@ -856,14 +825,16 @@ } for (; a != e; ++i, ++a) { + // dummy classes for generic arguments have a NULL assembly field // check whether both i and a point to a dummy class - if (((*i)->isDummy && !(*a)->isDummy) || (!(*i)->isDummy && (*a)->isDummy)) + if (((*i)->assembly == NULL && (*a)->assembly != NULL) || + ((*i)->assembly != NULL && (*a)->assembly == NULL)) return false; // dummy classes for generic arguments contain the // argument number in the token field // signature is only equal if the argument number matches - if ((*i)->isDummy && (*a)->isDummy) { + if ((*i)->assembly == NULL && (*a)->assembly == NULL) { if ((*i)->token != (*a)->token) { return false; } else { Modified: vmkit/trunk/lib/N3/VMCore/VMClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMClass.h?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMClass.h (original) +++ vmkit/trunk/lib/N3/VMCore/VMClass.h Thu Oct 2 18:28:36 2008 @@ -74,7 +74,6 @@ bool isArray; bool isPointer; bool isPrimitive; - bool isDummy; uint32 depth; VMClassState status; uint32 flags; Modified: vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp Thu Oct 2 18:28:36 2008 @@ -300,3 +300,13 @@ void Exception::TRACER { catchClass->MARK_AND_TRACE; } + +#ifdef MULTIPLE_GC +extern "C" void CLIObjectTracer(VMObject* obj, Collector* GC) { +#else +extern "C" void CLIObjectTracer(VMObject* obj) { +#endif + obj->classOf->MARK_AND_TRACE; + obj->lockObj->MARK_AND_TRACE; +} + Modified: vmkit/trunk/tools/jnjvm/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/jnjvm/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/tools/jnjvm/Makefile (original) +++ vmkit/trunk/tools/jnjvm/Makefile Thu Oct 2 18:28:36 2008 @@ -14,4 +14,8 @@ USEDLIBS = Allocator CommonThread Mvm JnJVM Classpath $(GCLIB) LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo +ifeq ($(ISOLATE_BUILD), 1) + USEDLIBS += Isolate +endif + include $(LEVEL)/Makefile.common Modified: vmkit/trunk/tools/vmkit/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/Makefile?rev=56982&r1=56981&r2=56982&view=diff ============================================================================== --- vmkit/trunk/tools/vmkit/Makefile (original) +++ vmkit/trunk/tools/vmkit/Makefile Thu Oct 2 18:28:36 2008 @@ -17,6 +17,10 @@ USEDLIBS += JnJVM Classpath endif +ifeq ($(ISOLATE_BUILD), 1) + USEDLIBS += Isolate +endif + ifeq ($(WITH_N3_PNETLIB), 1) USEDLIBS += N3 PNetLib endif @@ -29,3 +33,5 @@ LIBS += $(PNETLIB)/engine/libILEngine.a $(PNETLIB)/image/libILImage.a $(PNETLIB)/support/libILSupport.a \ $(PNETLIB)/libffi/.libs/libffi.a $(PNETLIB)//dumpasm/libILDumpAsm.a endif + + From nicolas.geoffray at lip6.fr Fri Oct 3 07:22:51 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 03 Oct 2008 14:22:51 -0000 Subject: [vmkit-commits] [vmkit] r57002 - /vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Message-ID: <200810031422.m93EMqvX030758@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 3 09:22:50 2008 New Revision: 57002 URL: http://llvm.org/viewvc/llvm-project?rev=57002&view=rev Log: Fix a copy/pasto that caused a memory error. 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=57002&r1=57001&r2=57002&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Oct 3 09:22:50 2008 @@ -331,8 +331,8 @@ assert(cl && virtualVT && "array class not resolved"); uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); - JavaArray* res = (JavaArray*) - vm->allocator.allocateObject(sizeof(name) + n * primSize, virtualVT); + uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize; + JavaArray* res = (JavaArray*)vm->allocator.allocateObject(size, virtualVT); res->initialise(this); res->size = n; return res; From nicolas.geoffray at lip6.fr Fri Oct 3 08:54:36 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 03 Oct 2008 15:54:36 -0000 Subject: [vmkit-commits] [vmkit] r57012 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Message-ID: <200810031554.m93FsaJs002053@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 3 10:54:36 2008 New Revision: 57012 URL: http://llvm.org/viewvc/llvm-project?rev=57012&view=rev Log: Comment which command line the llvm pass is equivalent to. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=57012&r1=57011&r2=57012&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Fri Oct 3 10:54:36 2008 @@ -191,6 +191,12 @@ PM->add(P); } +// 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 +// static void AddStandardCompilePasses(FunctionPassManager *PM) { llvm::MutexGuard locked(mvm::jit::executionEngine->lock); // LLVM does not allow calling functions from other modules in verifier From nicolas.geoffray at lip6.fr Mon Oct 6 08:29:00 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 06 Oct 2008 15:29:00 -0000 Subject: [vmkit-commits] [vmkit] r57170 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Message-ID: <200810061529.m96FT0XM001399@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 6 10:29:00 2008 New Revision: 57170 URL: http://llvm.org/viewvc/llvm-project?rev=57170&view=rev Log: Erase the ending block if it has not predecessors. 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=57170&r1=57169&r2=57170&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Oct 6 10:29:00 2008 @@ -855,10 +855,16 @@ } #endif - if (returnType != Type::VoidTy) - llvm::ReturnInst::Create(endNode, currentBlock); - else - llvm::ReturnInst::Create(currentBlock); + PI = pred_begin(currentBlock); + PE = pred_end(currentBlock); + if (PI == PE) { + currentBlock->eraseFromParent(); + } else { + if (returnType != Type::VoidTy) + llvm::ReturnInst::Create(endNode, currentBlock); + else + llvm::ReturnInst::Create(currentBlock); + } PI = pred_begin(endExceptionBlock); PE = pred_end(endExceptionBlock); From nicolas.geoffray at lip6.fr Mon Oct 6 08:30:00 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 06 Oct 2008 15:30:00 -0000 Subject: [vmkit-commits] [vmkit] r57171 - in /vmkit/trunk/lib/JnJVM: Classpath/Classpath.cpp Classpath/ClasspathVMClass.cpp.inc Classpath/ClasspathVMStackWalker.cpp.inc Classpath/ClasspathVMThrowable.cpp.inc VMCore/JavaArray.cpp VMCore/JavaArray.h VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/JavaThread.h VMCore/Jni.cpp VMCore/Jnjvm.cpp VMCore/NativeUtil.cpp VMCore/Reader.cpp Message-ID: <200810061530.m96FU1v3001449@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 6 10:30:00 2008 New Revision: 57171 URL: http://llvm.org/viewvc/llvm-project?rev=57171&view=rev Log: Remove the acons construct, and replace it with ClassArray::doNew. Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h 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/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Mon Oct 6 10:30:00 2008 @@ -29,11 +29,6 @@ #include "NativeUtil.h" -// Called by JnJVM to ensure the compiler will link the classpath methods -extern "C" int ClasspathBoot(int argc, char** argv, char** env) { - return 1; -} - using namespace jnjvm; extern "C" { @@ -161,29 +156,25 @@ Jnjvm* vm = JavaThread::get()->isolate; UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(target, true); JavaObject* res = cl->doNew(vm); - JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); + JavaField* field = vm->upcalls->constructorSlot; + JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); meth->invokeIntSpecial(vm, cl, res); return (jobject)res; } -JNIEXPORT jobject JNICALL -Java_java_lang_reflect_VMArray_createObjectArray - ( +JNIEXPORT jobject JNICALL Java_java_lang_reflect_VMArray_createObjectArray( #ifdef NATIVE_JNI - JNIEnv * env, - jclass thisClass __attribute__ ((__unused__)), +JNIEnv * env, +jclass thisClass, #endif - jclass arrayType, jint arrayLength) -{ +jclass arrayType, jint arrayLength) { Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* base = NativeUtil::resolvedImplClass(arrayType, true); JnjvmClassLoader* loader = base->classLoader; const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); UserClassArray* array = loader->constructArray(arrayName, base); - ArrayObject* res = ArrayObject::acons(arrayLength, array, &(vm->allocator)); - - return (jobject) res; + return (jobject)array->doNew(arrayLength, vm); } @@ -198,9 +189,9 @@ JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong( #ifdef NATIVE_JNI - JNIEnv *env, +JNIEnv *env, #endif - JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect, jlong update) { +JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect, jlong update) { jlong *ptr; jlong value; @@ -220,9 +211,9 @@ JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt( #ifdef NATIVE_JNI - JNIEnv *env, +JNIEnv *env, #endif - JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) { +JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) { jint *ptr; @@ -233,9 +224,10 @@ JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject( #ifdef NATIVE_JNI - JNIEnv *env, +JNIEnv *env, #endif - JavaObject* unsafe, JavaObject* obj, jlong offset, jobject expect, jobject update) { +JavaObject* unsafe, JavaObject* obj, jlong offset, jobject expect, +jobject update) { jobject *ptr; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Mon Oct 6 10:30:00 2008 @@ -81,12 +81,13 @@ Jnjvm* vm = JavaThread::get()->isolate; if (cl->isArray() || cl->isInterface()) { - return (jobject)ArrayObject::acons(0, vm->upcalls->constructorArrayClass, &(vm->allocator)); + return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm); } else { std::vector res; cl->getDeclaredConstructors(res, publicOnly); - ArrayObject* ret = ArrayObject::acons(res.size(), vm->upcalls->constructorArrayClass, &(vm->allocator)); + ArrayObject* ret = + (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(res.size(), vm); sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { @@ -114,12 +115,12 @@ UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); if (cl->isArray()) { - return (jobject)ArrayObject::acons(0, vm->upcalls->methodArrayClass, &(vm->allocator)); + return (jobject)vm->upcalls->methodArrayClass->doNew(0, vm); } else { std::vector res; cl->getDeclaredMethods(res, publicOnly); - ArrayObject* ret = ArrayObject::acons(res.size(), vm->upcalls->methodArrayClass, &(vm->allocator)); + ArrayObject* ret = (ArrayObject*)vm->upcalls->methodArrayClass->doNew(res.size(), vm); sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { @@ -274,13 +275,13 @@ UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); if (!cl) { - return (jobject)ArrayObject::acons(0, vm->upcalls->fieldArrayClass, &(vm->allocator)); + return (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm); } else { std::vector res; cl->getDeclaredFields(res, publicOnly); - ArrayObject* ret = ArrayObject::acons(res.size(), - vm->upcalls->fieldArrayClass, &(vm->allocator)); + ArrayObject* ret = + (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(res.size(), vm); sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { @@ -305,10 +306,11 @@ Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); std::vector * interfaces = cl->getInterfaces(); - ArrayObject* ret = ArrayObject::acons(interfaces->size(), vm->upcalls->classArrayClass, &(vm->allocator)); + ArrayObject* ret = + (ArrayObject*)vm->upcalls->classArrayClass->doNew(interfaces->size(), vm); sint32 index = 0; - for (std::vector::iterator i = interfaces->begin(), e = interfaces->end(); - i != e; ++i, ++index) { + for (std::vector::iterator i = interfaces->begin(), + e = interfaces->end(); i != e; ++i, ++index) { UserClass* klass = *i; ret->elements[index] = klass->getClassDelegatee(vm); } @@ -346,7 +348,8 @@ if (cl) { cl->resolveInnerOuterClasses(); std::vector* innerClasses = cl->getInnerClasses(); - ArrayObject* res = ArrayObject::acons(innerClasses->size(), vm->upcalls->constructorArrayClass, &(vm->allocator)); + ArrayObject* res = + (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(innerClasses->size(), vm); uint32 index = 0; for (std::vector::iterator i = innerClasses->begin(), e = innerClasses->end(); i!= e; i++) { @@ -377,7 +380,7 @@ jclass Cl) { // TODO implement me Jnjvm* vm = JavaThread::get()->isolate; - ArrayObject* res = ArrayObject::acons(0, vm->upcalls->constructorArrayAnnotation, &(vm->allocator)); + ArrayObject* res = (ArrayObject*)vm->upcalls->constructorArrayAnnotation->doNew(0, vm); return (jobjectArray)res; } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc Mon Oct 6 10:30:00 2008 @@ -69,7 +69,7 @@ return recGetClassContext(vm, stack, size, first + 1, rec, ctps, ctpIndex); } } else { - return ArrayObject::acons(rec, vm->upcalls->classArrayClass, &(vm->allocator)); + return (ArrayObject*)vm->upcalls->classArrayClass->doNew(rec, vm); } } #else @@ -84,7 +84,7 @@ return recGetClassContext(vm, stack, size, first + 1, rec); } } else { - return ArrayObject::acons(rec, vm->upcalls->classArrayClass, &(vm->allocator)); + return (ArrayObject*)vm->upcalls->classArrayClass->doNew(rec, vm); } } #endif Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc Mon Oct 6 10:30:00 2008 @@ -85,7 +85,7 @@ return recGetStackTrace(stack, first + 1, rec); } } else { - return ArrayObject::acons(rec, vm->upcalls->stackTraceArray, &(vm->allocator)); + return (ArrayObject*)vm->upcalls->stackTraceArray->doNew(rec, vm); } } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Mon Oct 6 10:30:00 2008 @@ -38,39 +38,6 @@ extern "C" void negativeArraySizeException(sint32 val); extern "C" void outOfMemoryError(sint32 val); -#define ACONS(name, elmt, primSize, VT) \ - name *name::acons(sint32 n, UserClassArray* atype, \ - JavaAllocator* allocator) { \ - if (n < 0) \ - negativeArraySizeException(n); \ - else if (n > JavaArray::MaxArraySize) \ - outOfMemoryError(n); \ - name* res = (name*) \ - (Object*) allocator->allocateObject(sizeof(name) + n * primSize, VT); \ - res->initialise(atype); \ - res->size = n; \ - return res; \ - } - -/// Each array class has its own element size for allocating arrays. -ACONS(ArrayUInt8, uint8, 1, JavaArray::VT) -ACONS(ArraySInt8, sint8, 1, JavaArray::VT) -ACONS(ArrayUInt16, uint16, 2, JavaArray::VT) -ACONS(ArraySInt16, sint16, 2, JavaArray::VT) -ACONS(ArrayUInt32, uint32, 4, JavaArray::VT) -ACONS(ArraySInt32, sint32, 4, JavaArray::VT) -ACONS(ArrayLong, sint64, 8, JavaArray::VT) -ACONS(ArrayFloat, float, 4, JavaArray::VT) -ACONS(ArrayDouble, double, 8, JavaArray::VT) - -/// ArrayObject differs wit arrays of primitive types because its -/// tracer method traces the objects in the array as well as the class of the -/// array. -ACONS(ArrayObject, JavaObject*, sizeof(JavaObject*), ArrayObject::VT) - -#undef ARRAYCLASS -#undef ACONS - void UTF8::print(mvm::PrintBuffer* buf) const { for (int i = 0; i < size; i++) buf->writeChar((char)elements[i]); @@ -155,8 +122,8 @@ const UTF8* UTF8::acons(sint32 n, UserClassArray* cl, JavaAllocator* allocator) { if (n < 0) - negativeArraySizeException(n); - else if (n > JavaArray::MaxArraySize) + negativeArraySizeException(n); + else if (n > JavaArray::MaxArraySize) outOfMemoryError(n); UTF8* res = new (n) UTF8(); res->initialise(cl); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Mon Oct 6 10:30:00 2008 @@ -79,8 +79,6 @@ /// Instantiation of the TJavaArray class for Java arrays of primitive types. #define ARRAYCLASS(name, elmt) \ class name : public TJavaArray { \ - public: \ - static name* acons(sint32 n, UserClassArray* cl, JavaAllocator* allocator);\ } ARRAYCLASS(ArrayUInt8, uint8); @@ -103,11 +101,6 @@ /// VT - The virtual table of arrays of objects. static VirtualTable *VT; - /// acons - Allocates a Java array of objects. The class given as argument is - /// the class of the array, not the class of its elements. - static ArrayObject* acons(sint32 n, UserClassArray* cl, - JavaAllocator* allocator); - /// tracer - The tracer method of Java arrays of objects. This method will /// trace all objects in the array. virtual void TRACER; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 6 10:30:00 2008 @@ -326,13 +326,17 @@ vm->negativeArraySizeException(n); else if (n > JavaArray::MaxArraySize) vm->outOfMemoryError(n); - + + return doNew(n, vm->allocator); +} + +JavaArray* UserClassArray::doNew(sint32 n, JavaAllocator& allocator) { UserCommonClass* cl = baseClass(); assert(cl && virtualVT && "array class not resolved"); uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize; - JavaArray* res = (JavaArray*)vm->allocator.allocateObject(size, virtualVT); + JavaArray* res = (JavaArray*)allocator.allocateObject(size, virtualVT); res->initialise(this); res->size = n; return res; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 6 10:30:00 2008 @@ -23,6 +23,7 @@ #include "mvm/Threads/Locks.h" #include "JavaAccess.h" +#include "JavaAllocator.h" #include "JnjvmClassLoader.h" namespace jnjvm { @@ -702,6 +703,14 @@ /// ClassArray - This class represents Java array classes. /// class ClassArray : public CommonClass { + + /// Reader is a friend because it allocates arrays without a vm. + friend class Reader; +private: + /// doNew - Allocate a new array with the given loader. + /// + JavaArray* doNew(sint32 n, JavaAllocator& allocator); + public: /// VT - The virtual table of array classes. @@ -720,8 +729,10 @@ } - /// funcs - Get the type of the base class/ Resolve the array if needed. + /// doNew - Allocate a new array in the given vm. + /// JavaArray* doNew(sint32 n, Jnjvm* vm); + /// ClassArray - Empty constructor for VT. /// Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Mon Oct 6 10:30:00 2008 @@ -62,7 +62,7 @@ } static JavaThread* get() { - return (JavaThread*)Thread::threadKey->get(); + return (JavaThread*)mvm::Thread::get(); } static JavaObject* currentThread() { JavaThread* result = get(); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Mon Oct 6 10:30:00 2008 @@ -1755,7 +1755,7 @@ const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); UserClassArray* array = loader->constructArray(arrayName); - ArrayObject* res = ArrayObject::acons(length, array, &(vm->allocator)); + ArrayObject* res = (ArrayObject*)array->doNew(length, vm); if (initialElement) { memset(res->elements, (int)initialElement, length * sizeof(JavaObject*)); @@ -1798,11 +1798,8 @@ BEGIN_EXCEPTION - ArrayUInt8* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArrayUInt8::acons(len, vm->bootstrapLoader->upcalls->ArrayOfBool, - &vm->allocator); - return (jbooleanArray)res; + return (jbooleanArray)vm->upcalls->ArrayOfByte->doNew(len, vm); END_EXCEPTION return 0; @@ -1813,11 +1810,8 @@ BEGIN_EXCEPTION - ArraySInt8* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArraySInt8::acons(len, vm->bootstrapLoader->upcalls->ArrayOfByte, - &vm->allocator); - return (jbyteArray) res; + return (jbyteArray)vm->upcalls->ArrayOfByte->doNew(len, vm); END_EXCEPTION return 0; @@ -1828,11 +1822,8 @@ BEGIN_EXCEPTION - ArrayUInt16* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArrayUInt16::acons(len, vm->bootstrapLoader->upcalls->ArrayOfChar, - &vm->allocator); - return (jcharArray) res; + return (jcharArray)vm->upcalls->ArrayOfChar->doNew(len, vm); END_EXCEPTION return 0; @@ -1843,11 +1834,8 @@ BEGIN_EXCEPTION - ArraySInt16* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArraySInt16::acons(len, vm->bootstrapLoader->upcalls->ArrayOfShort, - &vm->allocator); - return (jshortArray) res; + return (jshortArray)vm->upcalls->ArrayOfShort->doNew(len, vm); END_EXCEPTION return 0; @@ -1858,11 +1846,8 @@ BEGIN_EXCEPTION - ArraySInt32* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArraySInt32::acons(len, vm->bootstrapLoader->upcalls->ArrayOfInt, - &vm->allocator); - return (jintArray) res; + return (jintArray)vm->upcalls->ArrayOfInt->doNew(len, vm); END_EXCEPTION return 0; @@ -1873,11 +1858,8 @@ BEGIN_EXCEPTION - ArrayLong* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArrayLong::acons(len, vm->bootstrapLoader->upcalls->ArrayOfLong, - &vm->allocator); - return (jlongArray) res; + return (jlongArray)vm->upcalls->ArrayOfLong->doNew(len, vm); END_EXCEPTION return 0; @@ -1888,11 +1870,8 @@ BEGIN_EXCEPTION - ArrayFloat* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArrayFloat::acons(len, vm->bootstrapLoader->upcalls->ArrayOfFloat, - &vm->allocator); - return (jfloatArray) res; + return (jfloatArray)vm->upcalls->ArrayOfFloat->doNew(len, vm); END_EXCEPTION return 0; @@ -1903,11 +1882,8 @@ BEGIN_EXCEPTION - ArrayDouble* res = 0; Jnjvm* vm = NativeUtil::myVM(env); - res = ArrayDouble::acons(len, vm->bootstrapLoader->upcalls->ArrayOfDouble, - &vm->allocator); - return (jdoubleArray) res; + return (jdoubleArray)vm->upcalls->ArrayOfDouble->doNew(len, vm); END_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=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 6 10:30:00 2008 @@ -450,7 +450,7 @@ ZipFile* file = archive.getFile(PATH_MANIFEST); if (file) { UserClassArray* array = vm->bootstrapLoader->upcalls->ArrayOfByte; - ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, array, &vm->allocator); + ArrayUInt8* res = (ArrayUInt8*)array->doNew(file->ucsize, vm); int ok = archive.readFile(res, file); if (ok) { char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS); @@ -798,7 +798,7 @@ } UserClassArray* array = bootstrapLoader->upcalls->ArrayOfString; - ArrayObject* args = ArrayObject::acons(argc - 2, array, &allocator); + ArrayObject* args = (ArrayObject*)array->doNew(argc - 2, this); for (int i = 2; i < argc; ++i) { args->elements[i - 2] = (JavaObject*)asciizToStr(argv[i]); } Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Mon Oct 6 10:30:00 2008 @@ -386,11 +386,12 @@ return res->getClassDelegatee(vm); } -ArrayObject* NativeUtil::getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth) { +ArrayObject* NativeUtil::getParameterTypes(JnjvmClassLoader* loader, + JavaMethod* meth) { Jnjvm* vm = JavaThread::get()->isolate; std::vector& args = meth->getSignature()->args; - ArrayObject* res = ArrayObject::acons(args.size(), vm->upcalls->classArrayClass, - &(JavaThread::get()->isolate->allocator)); + ArrayObject* res = + (ArrayObject*)vm->upcalls->classArrayClass->doNew(args.size(), vm); sint32 index = 0; for (std::vector::iterator i = args.begin(), e = args.end(); @@ -406,14 +407,13 @@ Attribut* exceptionAtt = meth->lookupAttribut(Attribut::exceptionsAttribut); Jnjvm* vm = JavaThread::get()->isolate; if (exceptionAtt == 0) { - return ArrayObject::acons(0, vm->upcalls->classArrayClass, - &(JavaThread::get()->isolate->allocator)); + 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::acons(nbe, vm->upcalls->classArrayClass, - &(JavaThread::get()->isolate->allocator)); + ArrayObject* res = + (ArrayObject*)vm->upcalls->classArrayClass->doNew(nbe, vm); for (uint16 i = 0; i < nbe; ++i) { uint16 idx = reader.readU2(); Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp?rev=57171&r1=57170&r2=57171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Mon Oct 6 10:30:00 2008 @@ -33,7 +33,7 @@ long nbb = ftell(fp); fseek(fp, 0, SeekSet); UserClassArray* array = loader->upcalls->ArrayOfByte; - res = ArrayUInt8::acons(nbb, array, loader->allocator); + res = (ArrayUInt8*)array->doNew((sint32)nbb, *loader->allocator); fread(res->elements, nbb, 1, fp); fclose(fp); } @@ -46,7 +46,8 @@ ZipFile* file = archive->getFile(filename); if (file != 0) { UserClassArray* array = loader->upcalls->ArrayOfByte; - ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, array, loader->allocator); + ArrayUInt8* res = + (ArrayUInt8*)array->doNew((sint32)file->ucsize, *loader->allocator); if (archive->readFile(res, file) != 0) { ret = res; } From nicolas.geoffray at lip6.fr Mon Oct 6 08:32:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 06 Oct 2008 15:32:29 -0000 Subject: [vmkit-commits] [vmkit] r57172 - in /vmkit/trunk/lib/Mvm/Runtime: JIT.cpp LLVMRuntime.ll Message-ID: <200810061532.m96FWTt7001547@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 6 10:32:28 2008 New Revision: 57172 URL: http://llvm.org/viewvc/llvm-project?rev=57172&view=rev Log: New executionEnvironment variable for llvm, to store thread local data. Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=57172&r1=57171&r2=57172&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Mon Oct 6 10:32:28 2008 @@ -135,6 +135,14 @@ llvm_atomic_cmp_swap_i64 = (uint64 (*)(uint64*, uint64, uint64)) (uintptr_t)executionEngine->getPointerToFunction( module->getFunction("runtime.llvm.atomic.cmp.swap.i64")); + + executionEnvironment = module->getGlobalVariable("executionEnvironment"); + getExecutionEnvironment = (mvm::Thread* (*)()) + (uintptr_t)executionEngine->getPointerToFunction( + module->getFunction("getExecutionEnvironment")); + setExecutionEnvironment = (void (*)(mvm::Thread*)) + (uintptr_t)executionEngine->getPointerToFunction( + module->getFunction("setExecutionEnvironment")); // Type declaration ptrType = PointerType::getUnqual(Type::Int8Ty); @@ -300,6 +308,10 @@ uint64 val); +llvm::GlobalVariable* mvm::jit::executionEnvironment; +mvm::Thread* (*mvm::jit::getExecutionEnvironment)(); +void (*mvm::jit::setExecutionEnvironment)(mvm::Thread*); + uint64 mvm::jit::getTypeSize(const llvm::Type* type) { return executionEngine->getTargetData()->getABITypeSize(type); } Modified: vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll?rev=57172&r1=57171&r2=57172&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll (original) +++ vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Mon Oct 6 10:32:28 2008 @@ -1,4 +1,11 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Common types ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +;;; A virtual table is an array of function pointers. +%VT = type i32** + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Printing functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; @@ -93,3 +100,21 @@ %A = call i64 @llvm.atomic.cmp.swap.i64.p0i64( i64* %ptr, i64 %cmp, i64 %swap) ret i64 %A } + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;; TLS for the execution environment ;;;;;;;;;;;;;;;;;;;;;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +%Thread = type {%VT*, i32} + + at executionEnvironment = thread_local global %Thread* null + +define %Thread* @getExecutionEnvironment() nounwind readnone { + %E = load %Thread** @executionEnvironment + ret %Thread* %E +} + +define void @setExecutionEnvironment(%Thread* %E) nounwind { + store %Thread* %E, %Thread** @executionEnvironment + ret void +} From nicolas.geoffray at lip6.fr Mon Oct 6 08:43:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 06 Oct 2008 15:43:26 -0000 Subject: [vmkit-commits] [vmkit] r57173 - /vmkit/trunk/include/mvm/MvmMemoryManager.h Message-ID: <200810061543.m96FhQL1001905@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 6 10:43:25 2008 New Revision: 57173 URL: http://llvm.org/viewvc/llvm-project?rev=57173&view=rev Log: Implement new virtual functions of MemoryManager in LLVM. Modified: vmkit/trunk/include/mvm/MvmMemoryManager.h Modified: vmkit/trunk/include/mvm/MvmMemoryManager.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/MvmMemoryManager.h?rev=57173&r1=57172&r2=57173&view=diff ============================================================================== --- vmkit/trunk/include/mvm/MvmMemoryManager.h (original) +++ vmkit/trunk/include/mvm/MvmMemoryManager.h Mon Oct 6 10:43:25 2008 @@ -93,6 +93,15 @@ virtual void endExceptionTable(const Function *F, unsigned char *TableStart, unsigned char *TableEnd, unsigned char* FrameRegister); + + virtual void setMemoryWritable() { + realMemoryManager->setMemoryWritable(); + } + + virtual void setMemoryExecutable() { + realMemoryManager->setMemoryExecutable(); + } + }; } // End mvm namespace From nicolas.geoffray at lip6.fr Mon Oct 6 08:43:43 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 06 Oct 2008 15:43:43 -0000 Subject: [vmkit-commits] [vmkit] r57174 - /vmkit/trunk/include/mvm/Threads/Thread.h Message-ID: <200810061543.m96FhhH3001924@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 6 10:43:43 2008 New Revision: 57174 URL: http://llvm.org/viewvc/llvm-project?rev=57174&view=rev Log: Comment. 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=57174&r1=57173&r2=57174&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Mon Oct 6 10:43:43 2008 @@ -20,23 +20,70 @@ namespace mvm { +/// 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. class Thread : public gc { public: + + /// yield - Yield the processor to another thread. + /// static void yield(void); - static void yield(unsigned int *); + + /// yield - Yield the processor to another thread. If the thread has been + /// askink for yield already a number of times (n), then do a small sleep. + /// + static void yield(unsigned int* n); + + /// self - The thread id of the current thread, which is specific to the + /// underlying implementation. + /// static int self(void); + + /// initialise - Initialise the thread implementation. Used for pthread_key. + /// static void initialise(void); + + /// kill - Kill the thread with the given pid by sending it a signal. + /// static int kill(int tid, int signo); + + /// exit - Exit the current thread. + /// static void exit(int value); - static int start(int *tid, int (*fct)(void *), void *arg); + /// start - Start the execution of a thread, creating it and setting its + /// Thread instance. + /// + static int start(int *tid, int (*fct)(void *), void *arg); + + /// threadKey - the key for accessing the thread specific data. + /// static mvm::Key* threadKey; + + /// GC - The collector of this thread. + /// Collector* GC; + + /// baseSP - The base stack pointer. + /// void* baseSP; + + /// threadID - The virtual machine specific thread id. + /// uint32 threadID; + + /// get - Get the thread specific data of the current thread. + /// static Thread* get() { return (Thread*)Thread::threadKey->get(); } + + /// set - Set the thread specific data of the current thread. + /// + static void set(Thread* th) { + return Thread::threadKey->set(th); + } }; From nicolas.geoffray at lip6.fr Mon Oct 6 08:44:32 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 06 Oct 2008 15:44:32 -0000 Subject: [vmkit-commits] [vmkit] r57175 - /vmkit/trunk/include/mvm/JIT.h Message-ID: <200810061544.m96FiWMR001954@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 6 10:44:31 2008 New Revision: 57175 URL: http://llvm.org/viewvc/llvm-project?rev=57175&view=rev Log: Forgot this file for r57172. Modified: vmkit/trunk/include/mvm/JIT.h Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=57175&r1=57174&r2=57175&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Mon Oct 6 10:44:31 2008 @@ -27,6 +27,7 @@ #include "mvm/Method.h" #include "mvm/MvmMemoryManager.h" #include "mvm/Threads/Locks.h" +#include "mvm/Threads/Thread.h" namespace mvm { @@ -175,6 +176,10 @@ extern uint32 (*llvm_atomic_cmp_swap_i32) ( uint32* ptr, uint32 cmp, uint32 val ); extern uint64 (*llvm_atomic_cmp_swap_i64) ( uint64* ptr, uint64 cmp, uint64 val ); +extern llvm::GlobalVariable* executionEnvironment; +extern mvm::Thread* (*getExecutionEnvironment)(); +extern void (*setExecutionEnvironment)(mvm::Thread*); + // TODO: find what macro for gcc < 4.2 #if 1 #define __sync_bool_compare_and_swap(ptr, cmp, val) \ From nicolas.geoffray at lip6.fr Mon Oct 6 23:48:17 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 07 Oct 2008 06:48:17 -0000 Subject: [vmkit-commits] [vmkit] r57238 - in /vmkit/trunk: include/mvm/Threads/Thread.h lib/N3/VMCore/N3.cpp lib/N3/VMCore/N3Initialise.cpp lib/N3/VMCore/VMThread.cpp Message-ID: <200810070648.m976mI7b004219@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 7 01:48:16 2008 New Revision: 57238 URL: http://llvm.org/viewvc/llvm-project?rev=57238&view=rev Log: Make private the threadKey of the thread. Modified: vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/N3/VMCore/N3.cpp vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp vmkit/trunk/lib/N3/VMCore/VMThread.cpp Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=57238&r1=57237&r2=57238&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Oct 7 01:48:16 2008 @@ -56,11 +56,13 @@ /// Thread instance. /// static int start(int *tid, int (*fct)(void *), void *arg); - + +private: /// threadKey - the key for accessing the thread specific data. /// static mvm::Key* threadKey; +public: /// GC - The collector of this thread. /// Collector* GC; Modified: vmkit/trunk/lib/N3/VMCore/N3.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3.cpp?rev=57238&r1=57237&r2=57238&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3.cpp Tue Oct 7 01:48:16 2008 @@ -80,7 +80,7 @@ vm->bootstrapThread->GC = GC; mvm::jit::memoryManager->addGCForModule(vm->module, GC); #endif - VMThread::threadKey->set(vm->bootstrapThread); + VMThread::set(vm->bootstrapThread); vm->name = "bootstrapN3"; vm->hashUTF8 = UTF8Map::allocate(); @@ -114,7 +114,7 @@ vm->bootstrapThread->GC = GC; mvm::jit::memoryManager->addGCForModule(vm->module, GC); #endif - VMThread::threadKey->set(vm->bootstrapThread); + VMThread::set(vm->bootstrapThread); vm->threadSystem = ThreadSystem::allocateThreadSystem(); vm->name = name; Modified: vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp?rev=57238&r1=57237&r2=57238&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp Tue Oct 7 01:48:16 2008 @@ -335,7 +335,7 @@ } void VirtualMachine::runApplication(int argc, char** argv) { - mvm::Thread::threadKey->set(this->bootstrapThread); + mvm::Thread::set(this->bootstrapThread); ((N3*)this)->runMain(argc, argv); } Modified: vmkit/trunk/lib/N3/VMCore/VMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMThread.cpp?rev=57238&r1=57237&r2=57238&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMThread.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMThread.cpp Tue Oct 7 01:48:16 2008 @@ -43,7 +43,7 @@ } VMThread* VMThread::get() { - return (VMThread*)threadKey->get(); + return (VMThread*)mvm::Thread::get(); } extern void AddStandardCompilePasses(llvm::FunctionPassManager*); From nicolas.geoffray at lip6.fr Tue Oct 7 05:34:50 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 07 Oct 2008 12:34:50 -0000 Subject: [vmkit-commits] [vmkit] r57242 - in /vmkit/trunk: include/mvm/JIT.h include/mvm/Threads/Thread.h lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc lib/JnJVM/VMCore/JavaInitialise.cpp lib/JnJVM/VMCore/Jnjvm.cpp lib/Mvm/CommonThread/ctthread.cpp Message-ID: <200810071234.m97CYqbf025309@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 7 07:34:48 2008 New Revision: 57242 URL: http://llvm.org/viewvc/llvm-project?rev=57242&view=rev Log: Compilation fix after r57238. Modified: vmkit/trunk/include/mvm/JIT.h vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=57242&r1=57241&r2=57242&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Tue Oct 7 07:34:48 2008 @@ -27,10 +27,11 @@ #include "mvm/Method.h" #include "mvm/MvmMemoryManager.h" #include "mvm/Threads/Locks.h" -#include "mvm/Threads/Thread.h" namespace mvm { +class Thread; + /// JITInfo - This class can be derived from to hold private JIT-specific /// information. Objects of type are accessed/created with /// ::getInfo and destroyed when the object is destroyed. Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=57242&r1=57241&r2=57242&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Oct 7 07:34:48 2008 @@ -13,6 +13,7 @@ #include "types.h" #include "MvmGC.h" +#include "mvm/JIT.h" #include "mvm/Threads/Key.h" @@ -78,15 +79,22 @@ /// get - Get the thread specific data of the current thread. /// static Thread* get() { +#if 1//defined(__PPC__) || defined(__ppc__) return (Thread*)Thread::threadKey->get(); +#else + return (Thread*)mvm::jit::getExecutionEnvironment(); +#endif } /// set - Set the thread specific data of the current thread. /// static void set(Thread* th) { - return Thread::threadKey->set(th); +#if 1//defined(__PPC__) || defined(__ppc__) + Thread::threadKey->set(th); +#else + mvm::jit::setExecutionEnvironment(th); +#endif } - }; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=57242&r1=57241&r2=57242&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc Tue Oct 7 07:34:48 2008 @@ -50,7 +50,7 @@ JavaObject* vmThread = arg->vmThread; JavaThread* intern = arg->intern; free(arg); - mvm::Thread::threadKey->set(intern); + mvm::Thread::set(intern); #ifdef MULTIPLE_GC intern->GC->inject_my_thread(&argc); #else Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57242&r1=57241&r2=57242&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Tue Oct 7 07:34:48 2008 @@ -11,6 +11,7 @@ #include "mvm/VirtualMachine.h" #include "mvm/Threads/Locks.h" +#include "mvm/Threads/Thread.h" #include "JavaArray.h" #include "JavaCache.h" @@ -241,7 +242,7 @@ } void Jnjvm::runApplication(int argc, char** argv) { - mvm::Thread::threadKey->set(this->bootstrapThread); + mvm::Thread::set(this->bootstrapThread); this->runMain(argc, argv); } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57242&r1=57241&r2=57242&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Oct 7 07:34:48 2008 @@ -18,6 +18,7 @@ #include "debug.h" #include "mvm/JIT.h" +#include "mvm/Threads/Thread.h" #include "JavaArray.h" #include "JavaClass.h" @@ -830,7 +831,7 @@ isolate->bootstrapThread = allocator_new(&isolate->allocator, JavaThread)(); isolate->bootstrapThread->initialise(0, isolate); void* baseSP = sp ? sp : mvm::Thread::get()->baseSP; - JavaThread::threadKey->set(isolate->bootstrapThread); + JavaThread::set(isolate->bootstrapThread); #ifdef MULTIPLE_GC isolate->bootstrapThread->GC = isolate->GC; Modified: vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp?rev=57242&r1=57241&r2=57242&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp (original) +++ vmkit/trunk/lib/Mvm/CommonThread/ctthread.cpp Tue Oct 7 07:34:48 2008 @@ -68,7 +68,7 @@ void Thread::initialise() { Thread::threadKey = new mvm::Key(); Thread* th = new Thread(); - mvm::Thread::threadKey->set(th); + mvm::Thread::set(th); } int Thread::start(int *tid, int (*fct)(void *), void *arg) { From nicolas.geoffray at lip6.fr Wed Oct 8 05:42:34 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 08 Oct 2008 12:42:34 -0000 Subject: [vmkit-commits] [vmkit] r57293 - in /vmkit/trunk/lib/JnJVM: Classpath/ VMCore/ Message-ID: <200810081242.m98CgZLo025111@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 8 07:42:32 2008 New Revision: 57293 URL: http://llvm.org/viewvc/llvm-project?rev=57293&view=rev Log: Fix naming of macros to compile either a regular isolate environment or a sharing isolate environment. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h 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/JavaInitialise.cpp 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/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaString.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/Jnjvm.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc Wed Oct 8 07:42:32 2008 @@ -34,7 +34,7 @@ jobject cons) { Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING jclass Cl = (jclass)vm->upcalls->constructorClass->getInt32Field((JavaObject*)cons); UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); JnjvmClassLoader* loader = cl->classLoader; @@ -116,7 +116,7 @@ Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons); UserClass* cl = 0; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)cons); cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); #else Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc Wed Oct 8 07:42:32 2008 @@ -43,7 +43,7 @@ jobject Meth) { Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); JnjvmClassLoader* loader = cl->classLoader; @@ -62,7 +62,7 @@ jobject Meth) { Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); JnjvmClassLoader* loader = cl->classLoader; @@ -97,7 +97,7 @@ if (!(obj->classOf->isAssignableFrom(cl))) { vm->illegalArgumentExceptionForMethod(meth, cl, obj->classOf); } -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING if (isInterface(cl->classDef->access)) { cl = obj->classOf->lookupClassFromMethod(meth); } else { @@ -214,7 +214,7 @@ Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)_meth); UserClass* cl = 0; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)_meth); cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); #else Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc Wed Oct 8 07:42:32 2008 @@ -21,7 +21,7 @@ static UserClass* internalGetClass(Jnjvm* vm, JavaField* field, jobject Field) { -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING jclass Cl = (jclass)vm->upcalls->fieldClass->getInt32Field((JavaObject*)Field); UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); return cl; @@ -47,13 +47,8 @@ jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); -#ifdef MULTIPLE_VM - jclass Cl = (jclass)vm->upcalls->fieldClass->getInt32Field((JavaObject*)obj); - UserClass* fieldCl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); + UserClass* fieldCl = internalGetClass(vm, field, obj); JnjvmClassLoader* loader = fieldCl->classLoader; -#else - JnjvmClassLoader* loader = field->classDef->classLoader; -#endif UserCommonClass* cl = field->getSignature()->assocClass(loader); return (jclass)cl->getClassDelegatee(vm); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc Wed Oct 8 07:42:32 2008 @@ -125,10 +125,10 @@ jclass clazz, #endif jint par1) { -#ifndef MULTIPLE_VM +#if defined(ISOLATE) || defined(ISOLATE_SHARING) + // TODO: do a longjmp exit(par1); #else - // TODO: do a longjmp exit(par1); #endif } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc Wed Oct 8 07:42:32 2008 @@ -28,7 +28,7 @@ extern "C" { -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING uint32 getPools(UserConstantPool** pools, uint32 size) { unsigned int* top; register unsigned int **cur = ⊤ @@ -47,7 +47,7 @@ } #endif -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING JavaObject* getClassInContext(Jnjvm* vm, Class* cl, UserConstantPool** ctps, uint32& ctpIndex) { for (; ctpIndex < 100; ++ctpIndex) { UserClass* newCl = ctps[ctpIndex]->getClass(); @@ -98,7 +98,7 @@ Jnjvm* vm = JavaThread::get()->isolate; int* ips[100]; int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 100); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING UserConstantPool* pools[100]; getPools(pools, 100); #endif @@ -109,7 +109,7 @@ while (i < real_size) { JavaMethod* meth = JavaJIT::IPToJavaMethod(ips[i++]); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING if (meth && meth->classDef == cl->classDef) { #else if (meth && meth->classDef == cl) { @@ -119,7 +119,7 @@ } } -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING return (jobject)recGetClassContext(vm, ips, real_size, first, 0, pools, 0); #else return (jobject)recGetClassContext(vm, ips, real_size, first, 0); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc Wed Oct 8 07:42:32 2008 @@ -101,7 +101,7 @@ while (stack[i] != 0) { JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[i++]); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING if (meth) { #else if (meth && !meth->classDef->subclassOf(vm->upcalls->newThrowable)) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Wed Oct 8 07:42:32 2008 @@ -150,7 +150,7 @@ /// equals - Returns whether two UTF8s are equals. When the JnJVM executes /// in single mode, equality is just a pointer comparison. When executing /// in multiple mode, we compare the contents of the UTF8s. -#ifndef MULTIPLE_VM +#if defined(ISOLATE) || defined(ISOLATE_SHARING) bool equals(const UTF8* other) const { return this == other; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp Wed Oct 8 07:42:32 2008 @@ -61,7 +61,7 @@ -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING UserClass* JavaJIT::getCallingClass() { int* ips[10]; int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Wed Oct 8 07:42:32 2008 @@ -41,7 +41,7 @@ lastCible = 0; methPtr = 0; next = 0; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING definingCtp = 0; #endif enveloppe = E; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Wed Oct 8 07:42:32 2008 @@ -51,7 +51,7 @@ /// enveloppe - The container to which this class belongs to. Enveloppe* enveloppe; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING ///definingClass - The class that defined the method being called. /// UserConstantPool* definingCtp; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Wed Oct 8 07:42:32 2008 @@ -264,7 +264,7 @@ this->array = isArray; this->primitive = false; this->JInfo = 0; -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) && !defined(ISOLATE_SHARING) this->delegatee = 0; #endif } @@ -286,7 +286,7 @@ bytes = B; super = 0; ctpInfo = 0; -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) && !defined(ISOLATE_SHARING) _staticInstance = 0; #endif } @@ -757,7 +757,7 @@ readAttributs(reader, attributs); } -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING void CommonClass::resolveClass() { if (status < resolved) { acquire(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Wed Oct 8 07:42:32 2008 @@ -122,7 +122,7 @@ /// class loader finalizer method will be defined. /// class CommonClass : public mvm::Object { -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING friend class UserCommonClass; #endif private: @@ -305,7 +305,7 @@ /// JnjvmClassLoader* classLoader; -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) && !defined(ISOLATE_SHARING) /// delegatee - The java/lang/Class object representing this class /// JavaObject* delegatee; @@ -566,7 +566,7 @@ /// std::vector attributs; -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) && !defined(ISOLATE_SHARING) /// innerClasses - The inner classes of this class. /// std::vector innerClasses; @@ -605,7 +605,7 @@ } -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING /// doNew - Allocates a Java object whose class is this class. /// JavaObject* doNew(Jnjvm* vm); @@ -634,7 +634,7 @@ /// is inlined when the vm is in a single environment. In a multiple /// environment, the static instance is in a hashtable. /// -#ifndef MULTIPLE_VM +#if !defined(ISOLATE_SHARING) && !defined(ISOLATE) JavaObject* _staticInstance; JavaObject* getStaticInstance() { @@ -687,7 +687,7 @@ void resolveInnerOuterClasses(); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING Class* getOuterClass() { return outerClass; } @@ -1034,7 +1034,7 @@ } // end namespace jnjvm -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING #include "IsolateCommonClass.h" #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Wed Oct 8 07:42:32 2008 @@ -267,7 +267,7 @@ CommonClass* JavaConstantPool::loadClass(uint32 index) { CommonClass* temp = isClassLoaded(index); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING if (!temp) { JnjvmClassLoader* loader = classDef->classLoader; const UTF8* name = UTF8At(ctpDef[index]); @@ -286,7 +286,7 @@ CommonClass* JavaConstantPool::getMethodClassIfLoaded(uint32 index) { CommonClass* temp = isClassLoaded(index); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING if (!temp) { JnjvmClassLoader* loader = classDef->classLoader; assert(loader && "Class has no loader?"); @@ -467,7 +467,7 @@ if (!stat) { ctpRes[index] = (void*)field->ptrOffset; } -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING else if (cl->isReady()) { JavaObject* S = field->classDef->getStaticInstance(); ctpRes[index] = (void*)((uint64)S + field->ptrOffset); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Wed Oct 8 07:42:32 2008 @@ -33,7 +33,7 @@ #include "ServiceDomain.h" #endif -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING #include "SharedMaps.h" #include "IsolateSharedLoader.h" #endif @@ -53,16 +53,16 @@ INIT(ClassMap); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); -#ifdef SERVICE_VM - INIT(ServiceDomain); -#endif -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING INIT(JnjvmSharedLoader); INIT(SharedClassByteMap); INIT(UserClass); INIT(UserClassArray); INIT(UserConstantPool); #endif +#ifdef SERVICE_VM + INIT(ServiceDomain); +#endif #undef INIT #define INIT(X) { \ @@ -80,7 +80,7 @@ void Jnjvm::initialiseStatics() { -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING if (!JnjvmSharedLoader::sharedLoader) { JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); } @@ -123,7 +123,7 @@ JCL->loadName(JCL->asciizConstructUTF8("java/lang/Object"), false, false); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING if (!ClassArray::SuperArray) { ClassArray::SuperArray = JCL->SuperArray->classDef; ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[0]->classDef); @@ -230,7 +230,7 @@ } void mvm::VirtualMachine::initialiseJVM() { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING if (!JnjvmClassLoader::bootstrapLoader) { initialiseVT(); Jnjvm::initialiseStatics(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Oct 8 07:42:32 2008 @@ -77,14 +77,14 @@ Value* VT = CallInst::Create(JnjvmModule::GetVTFunction, args[0], "", currentBlock); std::vector indexes2; //[3]; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING std::vector indexesCtp; //[3]; #endif if (meth) { LLVMMethodInfo* LMI = module->getMethodInfo(meth); ConstantInt* Offset = LMI->getOffset(); indexes2.push_back(Offset); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING indexesCtp.push_back(ConstantInt::get(Type::Int32Ty, Offset->getZExtValue() * -1)); #endif @@ -93,7 +93,7 @@ Value* val = getConstantPoolAt(index, JnjvmModule::VirtualLookupFunction, Type::Int32Ty, args[0], true); indexes2.push_back(val); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* mul = BinaryOperator::createMul(val, mvm::jit::constantMinusOne, "", currentBlock); indexesCtp.push_back(mul); @@ -106,7 +106,7 @@ Value* Func = new LoadInst(FuncPtr, "", currentBlock); Func = new BitCastInst(Func, LSI->getVirtualPtrType(), "", currentBlock); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* CTP = GetElementPtrInst::Create(VT, indexesCtp.begin(), indexesCtp.end(), "", currentBlock); @@ -157,7 +157,7 @@ endBlock = createBasicBlock("end block"); returnType = funcType->getReturnType(); -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Value* lastArg = 0; for (Function::arg_iterator i = func->arg_begin(), e = func->arg_end(); i != e; ++i) { @@ -224,7 +224,7 @@ uint32 index = 0; if (stat) { -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* val = getClassCtp(); Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, val, "", currentBlock); @@ -417,7 +417,7 @@ currentBlock = EndUnlock; } -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* JavaJIT::getStaticInstanceCtp() { Value* cl = getClassCtp(); std::vector indexes; //[3]; @@ -446,7 +446,7 @@ if (isVirtual(compilingMethod->access)) { obj = llvmFunction->arg_begin(); } else { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); obj = LCI->getStaticVar(this); @@ -472,7 +472,7 @@ if (isVirtual(compilingMethod->access)) { obj = llvmFunction->arg_begin(); } else { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); obj = LCI->getStaticVar(this); @@ -547,7 +547,7 @@ uint32 index = 0; uint32 count = 0; -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) uint32 max = args.size() - 2; #else uint32 max = args.size(); @@ -590,7 +590,7 @@ } } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) #if !defined(SERVICE_VM) isolateLocal = args[args.size() - 2]; ctpCache = args[args.size() - 1]; @@ -715,7 +715,7 @@ uint32 index = 0; uint32 count = 0; -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) uint32 max = func->arg_size() - 2; #else uint32 max = func->arg_size(); @@ -757,7 +757,7 @@ } } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) #if !defined(SERVICE_VM) isolateLocal = i; i++; @@ -923,7 +923,7 @@ if (isVirtual(compilingMethod->access)) { argsSync.push_back(llvmFunction->arg_begin()); } else { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); Value* arg = LCI->getStaticVar(this); #else @@ -973,7 +973,7 @@ ex->catche = reader.readU2(); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING if (ex->catche) { JavaObject* exc = 0; UserClass* cl = 0; @@ -1086,7 +1086,7 @@ Value* cl = 0; currentBlock = cur->realTest; -#ifdef MULTIPLE_VM +#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); @@ -1156,7 +1156,7 @@ uint8 type = ctpInfo->typeAt(index); if (type == JavaConstantPool::ConstantString) { -#ifdef MULTIPLE_VM +#if defined(ISOLATE) || defined(ISOLATE_SHARING) // Lookup the constant pool cache Value* val = getConstantPoolAt(index, JnjvmModule::StringLookupFunction, JnjvmModule::JavaObjectType, 0, false); @@ -1182,7 +1182,7 @@ push(ConstantFP::get(Type::FloatTy, ctpInfo->FloatAt(index)), false); } else if (type == JavaConstantPool::ConstantClass) { -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) if (ctpInfo->ctpRes[index]) { CommonClass* cl = (CommonClass*)(ctpInfo->ctpRes[index]); LLVMCommonClassInfo* LCI = module->getClassInfo(cl); @@ -1193,7 +1193,7 @@ Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, val, "", currentBlock); push(res, false); -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) } #endif } else { @@ -1364,12 +1364,12 @@ void JavaJIT::makeArgs(FunctionType::param_iterator it, uint32 index, std::vector& Args, uint32 nb) { -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) nb += 1; #endif Args.reserve(nb + 2); Value** args = (Value**)alloca(nb*sizeof(Value*)); -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) args[nb - 1] = isolateLocal; sint32 start = nb - 2; it--; @@ -1546,7 +1546,7 @@ if (!val) { -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) const Type* Ty = JnjvmModule::ConstantPoolType; Constant* Nil = Constant::getNullValue(Ty); GlobalVariable* GV = new GlobalVariable(Ty, false, @@ -1619,7 +1619,7 @@ ctpInfo->infoOfStaticOrSpecialMethod(index, ACC_STATIC, signature, meth); -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Value* newCtpCache = getConstantPoolAt(index, JnjvmModule::StaticCtpLookupFunction, JnjvmModule::ConstantPoolType, 0, @@ -1651,9 +1651,8 @@ // This makes unswitch loop very unhappy time-wise, but makes GVN happy // number-wise. IMO, it's better to have this than Unswitch. -#if 1 std::vector Args; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* CTP = ctpCache; Args.push_back(mvm::jit::constantOne); Value* Cl = GetElementPtrInst::Create(CTP, Args.begin(), Args.end(), "", @@ -1693,73 +1692,6 @@ } return res; -#else - -#ifdef MULTIPLE_VM - Value* CTP = ctpCache; -#else - JavaConstantPool* ctp = compilingClass->ctpInfo; - LLVMConstantPoolInfo* LCPI = module->getConstantPoolInfo(ctp); - Value* CTP = LCPI->getDelegatee(this); -#endif - std::vector indexes; //[3]; -#ifndef MULTIPLE_VM - indexes.push_back(ConstantInt::get(Type::Int32Ty, index)); -#else - // Add one to the index because of the VT - indexes.push_back(ConstantInt::get(Type::Int32Ty, index + 1)); -#endif - Value* arg1 = GetElementPtrInst::Create(CTP, indexes.begin(), - indexes.end(), - "", currentBlock); - arg1 = new LoadInst(arg1, "", false, currentBlock); - Value* test = new ICmpInst(ICmpInst::ICMP_EQ, arg1, mvm::jit::constantPtrNull, - "", currentBlock); - - BasicBlock* trueCl = createBasicBlock("Ctp OK"); - BasicBlock* falseCl = createBasicBlock("Ctp Not OK"); - PHINode* node = llvm::PHINode::Create(mvm::jit::ptrType, "", trueCl); - node->addIncoming(arg1, currentBlock); - llvm::BranchInst::Create(falseCl, trueCl, test, currentBlock); - - currentBlock = falseCl; - std::vector Args; -#ifdef MULTIPLE_VM - std::vector Args; - Args.push_back(mvm::jit::constantOne); - Value* v = GetElementPtrInst::Create(ctpCache, Args.begin(), Args.end(), "", - currentBlock); - v = new LoadInst(v, "", currentBlock); - v = new BitCastInst(v, JnjvmModule::JavaClassType, "", currentBlock); -#else - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); - Value* v = LCI->getVar(this); -#endif - Args.push_back(v); - ConstantInt* CI = ConstantInt::get(Type::Int32Ty, index); - Args.push_back(CI); - - if (additionalArg) - Args.push_back(additionalArg); - - Value* res = 0; - if (doThrow) { - res = invoke(resolver, Args, "", currentBlock); - } else { - res = CallInst::Create(resolver, Args.begin(), Args.end(), "", - currentBlock); - } - node->addIncoming(res, currentBlock); - - llvm::BranchInst::Create(trueCl, currentBlock); - currentBlock = trueCl; - - if (returnType == Type::Int32Ty) { - return new PtrToIntInst(node, Type::Int32Ty, "", currentBlock); - } else { - return new BitCastInst(node, returnType, "", currentBlock); - } -#endif } Value* JavaJIT::getResolvedClass(uint16 index, bool clinit, bool doThrow) { @@ -1790,7 +1722,7 @@ } else { LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(cl); Size = LCI->getVirtualSize(this); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING VT = LCI->getVirtualTable(this); Cl = LCI->getVar(this); if (!cl->isReady()) { @@ -1862,7 +1794,7 @@ const Type* type = 0; if (stat) { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING if (field->classDef->isReady()) { object = LCI->getStaticVar(this); type = LCI->getStaticType(); @@ -2096,7 +2028,7 @@ Value* zero = mvm::jit::constantZero; Value* one = mvm::jit::constantOne; -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING // ok now the cache Enveloppe* enveloppe = new Enveloppe(compilingClass->ctpInfo, index); compilingMethod->caches.push_back(enveloppe); @@ -2139,7 +2071,7 @@ "", ifFalse); Value* meth = new BitCastInst(_meth, virtualPtrType, "", currentBlock); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* cache2 = new LoadInst(cachePtr, "", currentBlock); Value* newCtpCache = CallInst::Create(JnjvmModule::GetCtpCacheNodeFunction, cache2, "", currentBlock); @@ -2159,7 +2091,7 @@ _meth = new LoadInst(methPtr, "", currentBlock); meth = new BitCastInst(_meth, virtualPtrType, "", currentBlock); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING args.pop_back(); cache = new LoadInst(cachePtr, "", currentBlock); newCtpCache = CallInst::Create(JnjvmModule::GetCtpCacheNodeFunction, Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Wed Oct 8 07:42:32 2008 @@ -249,15 +249,14 @@ uint16 maxLocals; uint32 codeLen; -#if defined(MULTIPLE_VM) || defined(MULTIPLE_GC) +#if defined(ISOLATE) || defined(MULTIPLE_GC) llvm::Value* isolateLocal; -#endif - -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) llvm::Value* ctpCache; llvm::Value* getStaticInstanceCtp(); llvm::Value* getClassCtp(); #endif +#endif static const char* OpcodeNames[256]; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Wed Oct 8 07:42:32 2008 @@ -1828,7 +1828,7 @@ case NEWARRAY : case ANEWARRAY : { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING UserClassArray* dcl = 0; #endif ConstantInt* sizeElement = 0; @@ -1838,7 +1838,7 @@ if (bytecodes[i] == NEWARRAY) { uint8 id = bytecodes[++i]; uint8 charId = arrayType(id); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING dcl = JavaThread::get()->isolate->arrayClasses[id - 4]; #else std::vector args; @@ -1853,7 +1853,7 @@ sizeElement = LAI.sizeInBytesConstant; } else { uint16 index = readU2(bytecodes, i); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING const UTF8* className = compilingClass->ctpInfo->resolveClassName(index); @@ -1870,7 +1870,7 @@ TheVT = JnjvmModule::ArrayObjectVirtualTableGV; sizeElement = mvm::jit::constantPtrSize; } -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); valCl = LCI->getVar(this); #endif @@ -1983,7 +1983,7 @@ case CHECKCAST : { uint16 index = readU2(bytecodes, i); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING CommonClass* dcl = compilingClass->ctpInfo->getMethodClassIfLoaded(index); #endif @@ -2000,7 +2000,7 @@ BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); currentBlock = ifFalse; Value* clVar = 0; -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING if (dcl) { LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); clVar = LCI->getVar(this); @@ -2038,7 +2038,7 @@ case INSTANCEOF : { uint16 index = readU2(bytecodes, i); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING CommonClass* dcl = compilingClass->ctpInfo->getMethodClassIfLoaded(index); @@ -2100,7 +2100,7 @@ uint8 dim = readU1(bytecodes, i); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING Value* valCl = getResolvedClass(index, true); #else JnjvmClassLoader* JCL = compilingClass->classLoader; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Wed Oct 8 07:42:32 2008 @@ -61,7 +61,7 @@ UserClass* methodCl = 0; JavaMethod* dmeth = ocl->lookupMethod(utf8, sign->keyName, false, true, methodCl); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING assert(dmeth->classDef->isReady() && "Class not ready in a virtual lookup."); #endif @@ -73,7 +73,7 @@ rcache->methPtr = dmeth->compiledPtr(); rcache->lastCible = (UserClass*)ocl; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING rcache->definingCtp = methodCl->getConstantPool(); #endif @@ -135,15 +135,18 @@ return ptr; } -#ifdef MULTIPLE_VM +#ifdef ISOLATE extern "C" void* stringLookup(UserClass* cl, uint32 index) { UserConstantPool* ctpInfo = cl->getConstantPool(); const UTF8* utf8 = ctpInfo->UTF8AtForString(index); JavaString* str = JavaThread::get()->isolate->UTF8ToStr(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(); Enveloppe* enveloppe = new Enveloppe(ctpInfo, index); @@ -199,6 +202,8 @@ #endif +#endif + #ifndef WITHOUT_VTABLE extern "C" void* vtableLookup(UserClass* caller, uint32 index, ...) { UserCommonClass* cl = 0; @@ -223,7 +228,7 @@ caller->getConstantPool()->ctpRes[index] = (void*)dmeth->offset; } -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING assert(dmeth->classDef->isReady() && "Class not ready in a virtual lookup."); #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Wed Oct 8 07:42:32 2008 @@ -19,7 +19,7 @@ JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) { UserClass* cl = vm->upcalls->newString; JavaString* res = (JavaString*)malloc(cl->getVirtualSize()); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING /// Do this for now, but we will have to change it to duplicate the UTF8. /// UTF8 that dont have a class are shared UTF8. if (!utf8->classOf) ((UTF8*)utf8)->classOf = vm->upcalls->ArrayOfChar; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Wed Oct 8 07:42:32 2008 @@ -36,7 +36,7 @@ using namespace jnjvm; -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING Class* Classpath::newThread; Class* Classpath::newVMThread; JavaField* Classpath::assocThread; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Wed Oct 8 07:42:32 2008 @@ -22,6 +22,23 @@ using namespace jnjvm; + +static UserClass* getClassFromStaticMethod(JavaMethod* meth, jclass clazz) { +#ifdef ISOLATE_SHARING + return (UserClass*)NativeUtil::resolvedImplClass(clazz, true); +#else + return meth->classDef; +#endif +} + +static UserClass* getClassFromVirtualMethod(JavaMethod* meth, + UserCommonClass* cl) { +#ifdef ISOLATE_SHARING + return cl->lookupClassFromMethod(this); +#else + return meth->classDef; +#endif +} extern "C" const struct JNIInvokeInterface_ JNI_JavaVMTable; extern "C" struct JNINativeInterface_ JNI_JNIEnvTable; @@ -330,12 +347,7 @@ JavaObject* self = (JavaObject*)obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = self->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, self->classOf); JavaObject* res = meth->invokeJavaObjectVirtualAP(vm, cl, self, ap); va_end(ap); return (jobject)res; @@ -368,12 +380,7 @@ JavaObject* self = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = self->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, self->classOf); uint32 res = meth->invokeIntVirtualAP(vm, cl, self, ap); va_end(ap); return res; @@ -466,12 +473,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); uint32 res = meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -526,12 +528,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); jfloat res = meth->invokeFloatVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -565,12 +562,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); jdouble res = meth->invokeDoubleVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -588,12 +580,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); return meth->invokeDoubleVirtualAP(vm, cl, obj, args); END_EXCEPTION @@ -619,12 +606,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); @@ -640,12 +622,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); meth->invokeIntVirtualAP(vm, cl, obj, args); END_EXCEPTION @@ -866,12 +843,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = obj->classOf->lookupClassFromMethod(meth); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); meth->invokeIntSpecialAP(vm, cl, obj, ap); va_end(ap); @@ -1186,12 +1158,7 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromStaticMethod(meth, clazz); uint32 res = meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); return res; @@ -1367,12 +1334,7 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromStaticMethod(meth, clazz); meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); @@ -1387,12 +1349,7 @@ JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = 0; -#ifdef MULTIPLE_VM - cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); -#else - cl = meth->classDef; -#endif + UserClass* cl = getClassFromStaticMethod(meth, clazz); meth->invokeIntStaticAP(vm, cl, args); END_EXCEPTION Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Wed Oct 8 07:42:32 2008 @@ -81,7 +81,7 @@ const char* Jnjvm::envSeparator = ":"; const unsigned int Jnjvm::Magic = 0xcafebabe; -#ifndef MULTIPLE_VM +#ifndef ISOLATE /// If we're not in a multi-vm environment, this can be made static. std::vector Jnjvm::nativeLibs; JnjvmBootstrapLoader* Jnjvm::bootstrapLoader; @@ -852,13 +852,13 @@ isolate->hashStr = new StringMap(); isolate->globalRefsLock = mvm::Lock::allocNormal(); -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING isolate->initialiseStatics(); #endif isolate->upcalls = isolate->bootstrapLoader->upcalls; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING isolate->throwable = isolate->upcalls->newThrowable; #endif isolate->arrayClasses[JavaArray::T_BOOLEAN - 4] = Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Wed Oct 8 07:42:32 2008 @@ -96,7 +96,7 @@ Collector* GC; #endif -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING UserClass* throwable; #endif std::map arrayClasses; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Wed Oct 8 07:42:32 2008 @@ -27,7 +27,7 @@ using namespace jnjvm; -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0; UserClass* JnjvmBootstrapLoader::SuperArray = 0; std::vector JnjvmBootstrapLoader::InterfacesArray; @@ -84,7 +84,7 @@ javaLoader = loader; isolate = I; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING JavaMethod* meth = bootstrapLoader->upcalls->loadInClassLoader; loader->classOf->lookupMethodDontThrow(meth->name, meth->type, false, true, loadClass); @@ -146,7 +146,7 @@ JavaString* str = isolate->UTF8ToStr(javaName); Classpath* upcalls = bootstrapLoader->upcalls; UserClass* forCtp = 0; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING forCtp = loadClass; #else forCtp = upcalls->loadInClassLoader->classDef; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Wed Oct 8 07:42:32 2008 @@ -206,7 +206,7 @@ isolate = 0; } -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING UserClass* loadClass; #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmConfig.h Wed Oct 8 07:42:32 2008 @@ -11,7 +11,7 @@ #ifndef JNJVM_CONFIG_H #define JNJVM_CONFIG_H -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING #define ISOLATE_STATIC #else Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Oct 8 07:42:32 2008 @@ -108,8 +108,10 @@ llvm::Function* JnjvmModule::MultiCallNewFunction = 0; llvm::Function* JnjvmModule::GetConstantPoolAtFunction = 0; -#ifdef MULTIPLE_VM +#ifdef ISOLATE llvm::Function* JnjvmModule::StringLookupFunction = 0; + +#ifdef ISOLATE_SHARING llvm::Function* JnjvmModule::GetCtpCacheNodeFunction = 0; llvm::Function* JnjvmModule::GetCtpClassFunction = 0; llvm::Function* JnjvmModule::EnveloppeLookupFunction = 0; @@ -119,6 +121,9 @@ llvm::Function* JnjvmModule::GetArrayClassFunction = 0; llvm::Function* JnjvmModule::SpecialCtpLookupFunction = 0; #endif + +#endif + llvm::Function* JnjvmModule::GetClassDelegateeFunction = 0; llvm::Function* JnjvmModule::ArrayLengthFunction = 0; llvm::Function* JnjvmModule::GetVTFunction = 0; @@ -174,7 +179,7 @@ } Value* LLVMCommonClassInfo::getDelegatee(JavaJIT* jit) { -#ifndef MULTIPLE_VM +#ifndef ISOLATE if (!delegateeGV) { JavaObject* obj = classDef->getClassDelegatee(JavaThread::get()->isolate); Constant* cons = @@ -214,7 +219,7 @@ VirtualTable* VT = 0; if (meth->name->equals(Jnjvm::finalize)) { VT = allocateVT(cl, ++meths); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING meth->offset = 0; Function* func = cl->classLoader->TheModuleProvider->parseFunction(meth); if (!cl->super) meth->canBeInlined = true; @@ -461,7 +466,7 @@ return staticType; } -#ifndef MULTIPLE_VM +#ifndef ISOLATE Value* LLVMClassInfo::getStaticVar(JavaJIT* jit) { if (!staticVarGV) { getStaticType(); @@ -579,7 +584,7 @@ llvmArgs.push_back(LAI.llvmType); } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) llvmArgs.push_back(JnjvmModule::JnjvmType); // vm llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif @@ -603,7 +608,7 @@ llvmArgs.push_back(LAI.llvmType); } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) llvmArgs.push_back(JnjvmModule::JnjvmType); // vm llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif @@ -630,7 +635,7 @@ llvmArgs.push_back(LAI.llvmType); } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) llvmArgs.push_back(JnjvmModule::JnjvmType); // vm llvmArgs.push_back(JnjvmModule::ConstantPoolType); // cached constant pool #endif @@ -656,11 +661,11 @@ BasicBlock* currentBlock = BasicBlock::Create("enter", res); Function::arg_iterator i = res->arg_begin(); Value *obj, *ptr, *func; -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Value* vm = i; #endif ++i; -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Value* ctp = i; #endif ++i; @@ -689,7 +694,7 @@ } } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Args.push_back(vm); Args.push_back(ctp); #endif @@ -716,11 +721,11 @@ BasicBlock* currentBlock = BasicBlock::Create("enter", res); Function::arg_iterator i = res->arg_begin(); Value *obj, *ap, *func; -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Value* vm = i; #endif ++i; -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Value* ctp = i; #endif ++i; @@ -739,7 +744,7 @@ Args.push_back(new VAArgInst(ap, LAI.llvmType, "", currentBlock)); } -#if defined(MULTIPLE_VM) +#if defined(ISOLATE_SHARING) Args.push_back(vm); Args.push_back(ctp); #endif @@ -1021,8 +1026,9 @@ ClearExceptionFunction = module->getFunction("JavaThreadClearException"); -#ifdef MULTIPLE_VM +#ifdef ISOLATE StringLookupFunction = module->getFunction("stringLookup"); +#ifdef ISOLATE_SHARING EnveloppeLookupFunction = module->getFunction("enveloppeLookup"); GetCtpCacheNodeFunction = module->getFunction("getCtpCacheNode"); GetCtpClassFunction = module->getFunction("getCtpClass"); @@ -1033,6 +1039,7 @@ SpecialCtpLookupFunction = module->getFunction("specialCtpLookup"); GetArrayClassFunction = module->getFunction("getArrayClass"); #endif +#endif #ifdef SERVICE_VM AquireObjectInSharedDomainFunction = Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Wed Oct 8 07:42:32 2008 @@ -345,8 +345,9 @@ #endif static llvm::Function* MultiCallNewFunction; -#ifdef MULTIPLE_VM +#ifdef ISOLATE static llvm::Function* StringLookupFunction; +#ifdef ISOLATE_SHARING static llvm::Function* GetCtpCacheNodeFunction; static llvm::Function* GetCtpClassFunction; static llvm::Function* EnveloppeLookupFunction; @@ -356,6 +357,7 @@ static llvm::Function* SpecialCtpLookupFunction; static llvm::Function* GetArrayClassFunction; #endif +#endif static llvm::Function* GetClassDelegateeFunction; static llvm::Function* ArrayLengthFunction; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Wed Oct 8 07:42:32 2008 @@ -40,7 +40,7 @@ JavaMethod* meth = cl->lookupMethod(utf8, sign->keyName, isStatic, true, methodCl); -#ifndef MULTIPLE_VM +#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. @@ -97,7 +97,7 @@ LLVMMethodInfo* LMI = ((JnjvmModule*)TheModule)->getMethodInfo(meth); uint64_t offset = LMI->getOffset()->getZExtValue(); assert(meth->classDef->isResolved() && "Class not resolved"); -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING assert(meth->classDef->isReady() && "Class not ready"); #endif assert(meth->classDef->virtualVT && "Class has no VT"); @@ -105,7 +105,7 @@ "The method's offset is greater than the virtual table size"); ((void**)meth->classDef->virtualVT)[offset] = val; } else { -#ifndef MULTIPLE_VM +#ifndef ISOLATE_SHARING meth->classDef->initialiseClass(JavaThread::get()->isolate); #endif } Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Wed Oct 8 07:42:32 2008 @@ -247,7 +247,7 @@ } std::vector indexes; //[3]; -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING ConstantInt* Cons = dyn_cast(Index); assert(CI && "Wrong use of GetConstantPoolAt"); uint64 val = Cons->getZExtValue(); @@ -318,7 +318,7 @@ } #endif -#ifdef MULTIPLE_VM +#ifdef ISOLATE_SHARING else if (V == jnjvm::JnjvmModule::GetCtpClassFunction) { Changed = true; Value* val = Call.getArgument(0); Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57293&r1=57292&r2=57293&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Wed Oct 8 07:42:32 2008 @@ -21,7 +21,7 @@ #ifdef SERVICE_VM #include "ServiceDomain.h" #endif -#ifdef MULTIPLE_VM +#ifdef CODE_SHARING #include "SharedMaps.h" #include "IsolateSharedLoader.h" #endif @@ -40,7 +40,7 @@ INIT(ClassMap); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); -#ifdef MULTIPLE_VM +#if defined(ISOLATE_SHARING) INIT(JnjvmSharedLoader); INIT(SharedClassByteMap); INIT(UserClass); @@ -69,7 +69,7 @@ void CommonClass::TRACER { classLoader->MARK_AND_TRACE; -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) delegatee->MARK_AND_TRACE; #endif } @@ -77,7 +77,7 @@ void Class::TRACER { CommonClass::PARENT_TRACER; bytes->MARK_AND_TRACE; -#ifndef MULTIPLE_VM +#if !defined(ISOLATE) _staticInstance->MARK_AND_TRACE; #endif } @@ -111,7 +111,7 @@ TRACE_VECTOR(JavaObject*, gc_allocator, globalRefs); bootstrapThread->MARK_AND_TRACE; bootstrapLoader->MARK_AND_TRACE; -#ifdef MULTIPLE_VM +#if defined(ISOLATE_SHARING) JnjvmSharedLoader::sharedLoader->MARK_AND_TRACE; #endif } @@ -150,7 +150,7 @@ #undef TRACE_DELEGATEE } -#ifdef MULTIPLE_VM +#if defined(ISOLATE_SHARING) void UserClass::TRACER { classLoader->MARK_AND_TRACE; delegatee->MARK_AND_TRACE; From nicolas.geoffray at lip6.fr Wed Oct 8 06:01:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 08 Oct 2008 13:01:26 -0000 Subject: [vmkit-commits] [vmkit] r57294 - /vmkit/trunk/lib/JnJVM/Classpath/ Message-ID: <200810081301.m98D1RUt025700@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 8 08:01:20 2008 New Revision: 57294 URL: http://llvm.org/viewvc/llvm-project?rev=57294&view=rev Log: Rename. LLVM Makefile style links the files even if they are not used statically. Added: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp - copied, changed from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp - copied unchanged from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc 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=57294&r1=57293&r2=57294&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Wed Oct 8 08:01:20 2008 @@ -10,21 +10,9 @@ #include "Classpath.h" - -#include "ClasspathConstructor.cpp.inc" -#include "ClasspathMethod.cpp.inc" -#include "ClasspathVMClass.cpp.inc" -#include "ClasspathVMClassLoader.cpp.inc" -#include "ClasspathVMField.cpp.inc" -#include "ClasspathVMObject.cpp.inc" -#include "ClasspathVMRuntime.cpp.inc" -#include "ClasspathVMStackWalker.cpp.inc" -#include "ClasspathVMSystem.cpp.inc" -#include "ClasspathVMSystemProperties.cpp.inc" -#include "ClasspathVMThread.cpp.inc" -#include "ClasspathVMThrowable.cpp.inc" - #include "JavaClass.h" +#include "JavaThread.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" #include "NativeUtil.h" Copied: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (from r57293, vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc) URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?p2=vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp&p1=vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc&r1=57293&r2=57294&rev=57294&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Wed Oct 8 08:01:20 2008 @@ -26,7 +26,6 @@ extern "C" { - JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getParameterTypes( #ifdef NATIVE_JNI JNIEnv *env, Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (removed) @@ -1,129 +0,0 @@ -//===- ClasspathConstructor.cpp -------------------------------------------===// -//===----------- GNU classpath java/lang/reflect/Constructor --------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.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; - -extern "C" { - - -JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getParameterTypes( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject cons) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->constructorClass->getInt32Field((JavaObject*)cons); - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - JnjvmClassLoader* loader = cl->classLoader; -#else - JnjvmClassLoader* loader = meth->classDef->classLoader; -#endif - - return (jobject)(NativeUtil::getParameterTypes(loader, meth)); -} - -JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject cons) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); - return meth->access; -} - -JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_constructNative( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif - jobject _cons, - jobject _args, - jclass Clazz, - jint _meth) { - JavaMethod* meth = (JavaMethod*)_meth; - JavaArray* args = (JavaArray*)_args; - sint32 nbArgs = args ? args->size : 0; - sint32 size = meth->getSignature()->args.size(); - Jnjvm* vm = JavaThread::get()->isolate; - - void** buf = (void**)alloca(size * sizeof(uint64)); - void* _buf = (void*)buf; - sint32 index = 0; - if (nbArgs == size) { - UserCommonClass* _cl = NativeUtil::resolvedImplClass(Clazz, false); - if (!_cl->isArray()) { - UserClass* cl = (UserClass*)_cl; - cl->initialiseClass(vm); - - JavaObject* res = cl->doNew(vm); - JavaObject** ptr = (JavaObject**)(void*)(args->elements); - for (std::vector::iterator i = meth->getSignature()->args.begin(), - e = meth->getSignature()->args.end(); i != e; ++i, ++index) { - NativeUtil::decapsulePrimitive(vm, buf, ptr[index], *i); - } - - JavaObject* excp = 0; - try { - meth->invokeIntSpecialBuf(vm, cl, res, _buf); - }catch(...) { - excp = JavaThread::getJavaException(); - JavaThread::clearException(); - } - if (excp) { - if (excp->classOf->isAssignableFrom(vm->upcalls->newException)) { - vm->invocationTargetException(excp); - } else { - JavaThread::throwException(excp); - } - } - - return (jobject)res; - } - } - vm->illegalArgumentExceptionForMethod(meth, 0, 0); - return 0; -} - -JNIEXPORT jobjectArray JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject cons) { - verifyNull(cons); - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons); - UserClass* cl = 0; -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)cons); - cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); -#else - cl = meth->classDef; -#endif - - return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc (removed) @@ -1,226 +0,0 @@ -//===- ClasspathMethod.cpp ------------------------------------------------===// -//===------------- GNU classpath java/lang/reflect/Method -----------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.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; - -extern "C" { - -JNIEXPORT jint JNICALL Java_java_lang_reflect_Method_getModifiersInternal( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif - jobject Meth) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); - return meth->access; -} - -JNIEXPORT jclass JNICALL Java_java_lang_reflect_Method_getReturnType( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif - jobject Meth) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - JnjvmClassLoader* loader = cl->classLoader; -#else - JnjvmClassLoader* loader = meth->classDef->classLoader; -#endif - return (jclass)NativeUtil::getClassType(loader, meth->getSignature()->ret); -} - - -JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_getParameterTypes( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif - - jobject Meth) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - JnjvmClassLoader* loader = cl->classLoader; -#else - JnjvmClassLoader* loader = meth->classDef->classLoader; -#endif - return (jobject)(NativeUtil::getParameterTypes(loader, meth)); -} - -JNIEXPORT jobject JNICALL Java_java_lang_reflect_Method_invokeNative( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif - jobject Meth, jobject _obj, jobject _args, jclass Cl, jint _meth) { - - JavaMethod* meth = (JavaMethod*)_meth; - JavaArray* args = (JavaArray*)_args; - sint32 nbArgs = args ? args->size : 0; - sint32 size = meth->getSignature()->args.size(); - Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* obj = (JavaObject*)_obj; - - void** buf = (void**)alloca(size * sizeof(uint64)); - void* _buf = (void*)buf; - sint32 index = 0; - if (nbArgs == size) { - UserCommonClass* _cl = NativeUtil::resolvedImplClass(Cl, false); - UserClass* cl = (UserClass*)_cl; - - if (isVirtual(meth->access)) { - verifyNull(obj); - if (!(obj->classOf->isAssignableFrom(cl))) { - vm->illegalArgumentExceptionForMethod(meth, cl, obj->classOf); - } -#ifdef ISOLATE_SHARING - if (isInterface(cl->classDef->access)) { - cl = obj->classOf->lookupClassFromMethod(meth); - } else { - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); - cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); - } -#endif - - } else { - cl->initialiseClass(vm); - } - - JavaObject** ptr = (JavaObject**)(void*)(args->elements); - for (std::vector::iterator i = meth->getSignature()->args.begin(), - e = meth->getSignature()->args.end(); i != e; ++i, ++index) { - NativeUtil::decapsulePrimitive(vm, buf, ptr[index], *i); - } - - JavaObject* exc = 0; - -#define RUN_METH(TYPE) \ - try{ \ - if (isVirtual(meth->access)) { \ - if (isPublic(meth->access) && !isFinal(meth->access) && !isFinal(meth->classDef->access)) { \ - val = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, _buf); \ - } else { \ - val = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, _buf); \ - } \ - } else { \ - val = meth->invoke##TYPE##StaticBuf(vm, cl, _buf); \ - } \ - }catch(...) { \ - exc = JavaThread::getJavaException(); \ - assert(exc && "no exception?"); \ - JavaThread::clearException(); \ - } \ - \ - if (exc) { \ - if (exc->classOf->isAssignableFrom(vm->upcalls->newException)) { \ - JavaThread::get()->isolate->invocationTargetException(exc); \ - } else { \ - JavaThread::throwException(exc); \ - } \ - } \ - - JavaObject* res = 0; - Typedef* retType = meth->getSignature()->ret; - if (retType->isPrimitive()) { - PrimitiveTypedef* prim = (PrimitiveTypedef*)retType; - if (prim->isVoid()) { - res = 0; - uint32 val = 0; - RUN_METH(Int); - } else if (prim->isBool()) { - uint32 val = 0; - RUN_METH(Int); - res = vm->upcalls->boolClass->doNew(vm); - vm->upcalls->boolValue->setInt8Field(res, val); - } else if (prim->isByte()) { - uint32 val = 0; - RUN_METH(Int); - res = vm->upcalls->byteClass->doNew(vm); - vm->upcalls->byteValue->setInt8Field(res, val); - } else if (prim->isChar()) { - uint32 val = 0; - RUN_METH(Int); - res = vm->upcalls->charClass->doNew(vm); - vm->upcalls->charValue->setInt16Field(res, val); - } else if (prim->isShort()) { - uint32 val = 0; - RUN_METH(Int); - res = vm->upcalls->shortClass->doNew(vm); - vm->upcalls->shortValue->setInt16Field(res, val); - } else if (prim->isInt()) { - uint32 val = 0; - RUN_METH(Int); - res = vm->upcalls->intClass->doNew(vm); - vm->upcalls->intValue->setInt32Field(res, val); - } else if (prim->isLong()) { - sint64 val = 0; - RUN_METH(Long); - res = vm->upcalls->longClass->doNew(vm); - vm->upcalls->longValue->setLongField(res, val); - } else if (prim->isFloat()) { - float val = 0; - RUN_METH(Float); - res = vm->upcalls->floatClass->doNew(vm); - vm->upcalls->floatValue->setFloatField(res, val); - } else if (prim->isDouble()) { - double val = 0; - RUN_METH(Double); - res = vm->upcalls->doubleClass->doNew(vm); - vm->upcalls->doubleValue->setDoubleField(res, val); - } - } else { - JavaObject* val = 0; - RUN_METH(JavaObject); - res = val; - } - return (jobject)res; - } - vm->illegalArgumentExceptionForMethod(meth, 0, 0); - return 0; -} - -#undef RUN_METH - -JNIEXPORT jobjectArray JNICALL Java_java_lang_reflect_Method_getExceptionTypes( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif - jobject _meth) { - verifyNull(_meth); - Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)_meth); - UserClass* cl = 0; -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)_meth); - cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); -#else - cl = meth->classDef; -#endif - return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (removed) @@ -1,386 +0,0 @@ -//===---- ClasspathVMClass.cpp - GNU classpath java/lang/VMClass ----------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.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; - -extern "C" { - -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jobject klass) { - - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)klass); - - return cl->isArray(); - -} - -JNIEXPORT jclass JNICALL Java_java_lang_VMClass_forName( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - - jobject str, - jboolean clinit, - jobject loader) { - - Jnjvm* vm = JavaThread::get()->isolate; - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); - UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, - true, false); - if (cl != 0) { - if (clinit) { - cl->initialiseClass(vm); - } - return (jclass)(cl->getClassDelegatee(vm)); - } else { - vm->classNotFoundException((JavaString*)str); - return 0; - } -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredConstructors( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - - jclass Cl, - jboolean publicOnly) { - - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - Jnjvm* vm = JavaThread::get()->isolate; - - if (cl->isArray() || cl->isInterface()) { - return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm); - } else { - std::vector res; - cl->getDeclaredConstructors(res, publicOnly); - - ArrayObject* ret = - (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(res.size(), vm); - sint32 index = 0; - for (std::vector::iterator i = res.begin(), e = res.end(); - i != e; ++i, ++index) { - JavaMethod* meth = *i; - // TODO: check parameter types - UserClass* Cons = vm->upcalls->newConstructor; - JavaObject* tmp = Cons->doNew(vm); - vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, Cl, meth); - ret->elements[index] = tmp; - } - return (jobject)ret; - } -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredMethods( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - - jclass Cl, - jboolean publicOnly) { - - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - - if (cl->isArray()) { - return (jobject)vm->upcalls->methodArrayClass->doNew(0, vm); - } else { - std::vector res; - cl->getDeclaredMethods(res, publicOnly); - - ArrayObject* ret = (ArrayObject*)vm->upcalls->methodArrayClass->doNew(res.size(), vm); - sint32 index = 0; - for (std::vector::iterator i = res.begin(), e = res.end(); - i != e; ++i, ++index) { - JavaMethod* meth = *i; - // TODO: check parameter types - UserClass* Meth = vm->upcalls->newMethod; - JavaObject* tmp = Meth->doNew(vm); - vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, - vm->UTF8ToStr(meth->name), meth); - ret->elements[index] = tmp; - } - return (jobject)ret; - } -} - -JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jclass Cl, - jboolean ignore) { - - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - return cl->getAccess(); -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jobject Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - - const UTF8* iname = cl->getName(); - const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, iname->size); - - return (jobject)(vm->UTF8ToStr(res)); -} - -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - - return cl->isPrimitive(); -} - -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jclass Cl) { - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - - return cl->isInterface(); -} - -JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - - if (cl->isArray()) { - UserCommonClass* bc = ((UserClassArray*)cl)->baseClass(); - return (jclass)(bc->getClassDelegatee(vm)); - } else { - return 0; - } -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getClassLoader( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - return (jobject)cl->classLoader->getJavaClassLoader(); -} - -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl1, jclass Cl2) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl1 = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl1); - UserCommonClass* cl2 = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl2); - - cl2->resolveClass(); - return cl2->isAssignableFrom(cl1); - -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getSuperclass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - if (cl->isInterface()) - return 0; - else { - cl->resolveClass(); - if (cl->getSuper()) return (jobject)cl->getSuper()->getClassDelegatee(vm); - else return 0; - } -} - -JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); - return ((JavaObject*)obj)->instanceOf(cl); -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredFields( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl, jboolean publicOnly) { - Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); - - if (!cl) { - return (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm); - } else { - std::vector res; - cl->getDeclaredFields(res, publicOnly); - - ArrayObject* ret = - (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(res.size(), vm); - sint32 index = 0; - for (std::vector::iterator i = res.begin(), e = res.end(); - i != e; ++i, ++index) { - JavaField* field = *i; - // TODO: check parameter types - UserClass* Field = vm->upcalls->newField; - JavaObject* tmp = Field->doNew(vm); - vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, - vm->UTF8ToStr(field->name), field); - ret->elements[index] = tmp; - } - return (jobject)ret; - } -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getInterfaces( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); - std::vector * interfaces = cl->getInterfaces(); - ArrayObject* ret = - (ArrayObject*)vm->upcalls->classArrayClass->doNew(interfaces->size(), vm); - sint32 index = 0; - for (std::vector::iterator i = interfaces->begin(), - e = interfaces->end(); i != e; ++i, ++index) { - UserClass* klass = *i; - ret->elements[index] = klass->getClassDelegatee(vm); - } - return (jobject)ret; -} - - -JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getDeclaringClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); - if (cl) { - cl->resolveInnerOuterClasses(); - UserClass* outer = cl->getOuterClass(); - if (outer) { - return (jclass)outer->getClassDelegatee(vm); - } - } - - return 0; -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredClasses( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl, bool publicOnly) { - Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); - if (cl) { - cl->resolveInnerOuterClasses(); - std::vector* innerClasses = cl->getInnerClasses(); - ArrayObject* res = - (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(innerClasses->size(), vm); - uint32 index = 0; - for (std::vector::iterator i = innerClasses->begin(), - e = innerClasses->end(); i!= e; i++) { - res->elements[index++] = (*i)->getClassDelegatee(vm); - } - return (jobject)res; - } - - return 0; - -} - - -JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jobject throwable) { - JavaThread::throwException((JavaObject*)throwable); -} - -JNIEXPORT jobjectArray Java_java_lang_VMClass_getDeclaredAnnotations( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass Cl) { - // TODO implement me - Jnjvm* vm = JavaThread::get()->isolate; - ArrayObject* res = (ArrayObject*)vm->upcalls->constructorArrayAnnotation->doNew(0, vm); - return (jobjectArray)res; -} -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc (removed) @@ -1,113 +0,0 @@ -//===- ClasspathVMClassLoader.cpp - GNU classpath java/lang/VMClassLoader -===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.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; - -extern "C" { - -JNIEXPORT jobject JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jchar byteId) { - - Jnjvm* vm = JavaThread::get()->isolate; - UserClassPrimitive* prim = - UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls); - if (!prim) - vm->unknownError("unknown byte primitive %c", byteId); - - return (jobject)prim->getClassDelegatee(vm); - -} - -JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_findLoadedClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject loader, - jobject _name) { - - Jnjvm* vm = JavaThread::get()->isolate; - JavaString* name = (JavaString*)_name; - const UTF8* utf8 = name->strToUTF8(vm); - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); - UserCommonClass* cl = JCL->lookupClass(utf8); - - if (cl) return (jclass)(cl->getClassDelegatee(vm)); - else return 0; -} - -JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_loadClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject _str, - jboolean doResolve) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaString* str = (JavaString*)_str; - - JnjvmClassLoader* JCL = vm->bootstrapLoader; - UserCommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false); - - if (cl != 0) { - return (jclass)cl->getClassDelegatee(vm); - } else { - return 0; - } -} - -JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_defineClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject loader, - jobject _str, - jobject bytes, - jint off, - jint len, - jobject pd) { - Jnjvm* vm = JavaThread::get()->isolate; - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); - JavaString* str = (JavaString*)_str; - const UTF8* name = str->value->javaToInternal(JCL->hashUTF8, str->offset, str->count); - UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes); - - return (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd)); -} - -JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jclass Cl) { - verifyNull(Cl); - NativeUtil::resolvedImplClass(Cl, false); -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (removed) @@ -1,668 +0,0 @@ -//===- ClasspathVMField.cpp - GNU classpath java/lang/reflect/Field -------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - - -#include "JavaClass.h" -#include "JavaThread.h" -#include "JavaTypes.h" -#include "JavaUpcalls.h" -#include "Jnjvm.h" -#include "NativeUtil.h" - -using namespace jnjvm; - -extern "C" { - - -static UserClass* internalGetClass(Jnjvm* vm, JavaField* field, jobject Field) { -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->fieldClass->getInt32Field((JavaObject*)Field); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); - return cl; -#else - return field->classDef; -#endif -} - -JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); - return field->access; -} - -JNIEXPORT jclass JNICALL Java_java_lang_reflect_Field_getType( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); - UserClass* fieldCl = internalGetClass(vm, field, obj); - JnjvmClassLoader* loader = fieldCl->classLoader; - UserCommonClass* cl = field->getSignature()->assocClass(loader); - return (jclass)cl->getClassDelegatee(vm); -} - -JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - const Typedef* type = field->getSignature(); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - if (type->isPrimitive()) { - 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); - } - - JavaThread::get()->isolate->illegalArgumentException(""); - return 0; - -} - -JNIEXPORT jlong JNICALL Java_java_lang_reflect_Field_getLong( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - 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); - } - - JavaThread::get()->isolate->illegalArgumentException(""); - return 0; -} - -JNIEXPORT jboolean JNICALL Java_java_lang_reflect_Field_getBoolean( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isBool()) - return (uint8)field->getInt8Field(Obj); - } - - JavaThread::get()->isolate->illegalArgumentException(""); - - return 0; - -} - -JNIEXPORT jfloat JNICALL Java_java_lang_reflect_Field_getFloat( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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()) - return (jfloat)(uint32)field->getInt16Field((JavaObject*)obj); - if (prim->isFloat()) - return (jfloat)field->getFloatField((JavaObject*)obj); - } - JavaThread::get()->isolate->illegalArgumentException(""); - return 0.0; -} - -JNIEXPORT jbyte JNICALL Java_java_lang_reflect_Field_getByte( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isByte()) - return (sint8)field->getInt8Field(Obj); - } - JavaThread::get()->isolate->illegalArgumentException(""); - - return 0; -} - -JNIEXPORT jchar JNICALL Java_java_lang_reflect_Field_getChar( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isChar()) - return (uint16)field->getInt16Field((JavaObject*)obj); - } - JavaThread::get()->isolate->illegalArgumentException(""); - - return 0; - -} - -JNIEXPORT jshort JNICALL Java_java_lang_reflect_Field_getShort( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isShort()) - return (sint16)field->getInt16Field(Obj); - if (prim->isByte()) - return (sint16)field->getInt8Field(Obj); - } - JavaThread::get()->isolate->illegalArgumentException(""); - - return 0; -} - -JNIEXPORT jdouble JNICALL Java_java_lang_reflect_Field_getDouble( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); - return 0.0; -} - -JNIEXPORT jobject JNICALL Java_java_lang_reflect_Field_get( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject _obj) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)_obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - JavaObject* res = 0; - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isBool()) { - uint8 val = field->getInt8Field(Obj); - res = vm->upcalls->boolClass->doNew(vm); - vm->upcalls->boolValue->setInt8Field(res, val); - } - else if (prim->isByte()) { - sint8 val = field->getInt8Field(Obj); - res = vm->upcalls->byteClass->doNew(vm); - vm->upcalls->byteValue->setInt8Field(res, val); - } - else if (prim->isChar()) { - uint16 val = field->getInt16Field(Obj); - res = vm->upcalls->charClass->doNew(vm); - vm->upcalls->charValue->setInt16Field(res, val); - } - else if (prim->isShort()) { - sint16 val = field->getInt16Field(Obj); - res = vm->upcalls->shortClass->doNew(vm); - vm->upcalls->shortValue->setInt16Field(res, val); - } - else if (prim->isInt()) { - sint32 val = field->getInt32Field(Obj); - res = vm->upcalls->intClass->doNew(vm); - vm->upcalls->intValue->setInt32Field(res, val); - } - else if (prim->isLong()) { - sint64 val = field->getLongField(Obj); - res = vm->upcalls->longClass->doNew(vm); - vm->upcalls->longValue->setLongField(res, val); - } - else if (prim->isFloat()) { - float val = field->getFloatField(Obj); - res = vm->upcalls->floatClass->doNew(vm); - vm->upcalls->floatValue->setFloatField(res, val); - } - else if (prim->isDouble()) { - double val = field->getDoubleField(Obj); - res = vm->upcalls->doubleClass->doNew(vm); - vm->upcalls->doubleValue->setDoubleField(res, val); - } - } else { - res = field->getObjectField(Obj); - } - return (jobject)res; -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_set( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jobject val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - void** buf = (void**)alloca(sizeof(uint64)); - void* _buf = (void*)buf; - NativeUtil::decapsulePrimitive(JavaThread::get()->isolate, buf, (JavaObject*)val, field->getSignature()); - - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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]); - } else { - return field->setObjectField(Obj, ((JavaObject**)_buf)[0]); - } -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jboolean val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isBool()) - return field->setInt8Field(Obj, (uint8)val); - } - JavaThread::get()->isolate->illegalArgumentException(""); - -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setByte( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jbyte val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jchar val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jshort val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jint val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jlong val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jfloat val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - 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); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject Field, jobject obj, jdouble val) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - JavaObject* Obj = (JavaObject*)obj; - - if (isStatic(field->access)) { - UserClass* cl = internalGetClass(vm, field, Field); - cl->initialiseClass(vm); - Obj = cl->getStaticInstance(); - } - - const Typedef* type = field->getSignature(); - if (type->isPrimitive()) { - const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isDouble()) - return field->setDoubleField(Obj, (double)val); - } - JavaThread::get()->isolate->illegalArgumentException(""); -} - -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -JavaObject* Unsafe, -JavaObject* Field) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); - return (jlong)field->ptrOffset; -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc (removed) @@ -1,101 +0,0 @@ -//===------ ClasspathVMObject.cpp - GNU classpath java/lang/VMObject ------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.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; - -extern "C" { - -JNIEXPORT jobject JNICALL Java_java_lang_VMObject_clone( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject _src) { - - JavaObject* src = (JavaObject*)_src; - UserCommonClass* cl = src->classOf; - uint64 size = 0; - if (cl->isArray()) { - size = sizeof(JavaArray) + ((JavaArray*)src)->size * - ((UserClassArray*)cl)->baseClass()->getVirtualSize(); - } else { - size = cl->getVirtualSize(); - } - JavaObject* res = (JavaObject*) - JavaThread::get()->isolate->allocator.allocateObject(size, src->getVirtualTable()); - memcpy(res, src, size); - res->lock = 0; - return (jobject)res; -} - -JNIEXPORT jobject JNICALL Java_java_lang_VMObject_getClass( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject _obj) { - - JavaObject* obj = (JavaObject*)_obj; - Jnjvm* vm = JavaThread::get()->isolate; - return (jobject)(obj->classOf->getClassDelegatee(vm)); -} - -JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - - jobject _obj) { - JavaObject* obj = (JavaObject*)_obj; - obj->notifyAll(); -} - - -JNIEXPORT void JNICALL Java_java_lang_VMObject_wait( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jobject _object, jlong ms, jint ns) { - uint32 sec = (uint32) (ms / 1000); - uint32 usec = (ns / 1000) + 1000 * (ms % 1000); - JavaObject* obj = (JavaObject*)_object; - if (sec || usec) { - struct timeval t; - t.tv_sec = sec; - t.tv_usec = usec; - obj->timedWait(t); - } else { - obj->wait(); - } -} - -JNIEXPORT void JNICALL Java_java_lang_VMObject_notify( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jobject obj) { - ((JavaObject*)obj)->notify(); -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp.inc (removed) @@ -1,183 +0,0 @@ -//===------ ClasspathVMRuntime.cpp - GNU classpath java/lang/VMRuntime ----===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include -#include - -#include "MvmGC.h" - -#include "types.h" - -#include "JavaArray.h" -#include "JavaClass.h" -#include "JavaObject.h" -#include "JavaString.h" -#include "JavaTypes.h" -#include "JavaThread.h" -#include "Jnjvm.h" -#include "NativeUtil.h" - - -using namespace jnjvm; - -extern "C" { - - -JNIEXPORT jobject JNICALL Java_java_lang_VMRuntime_mapLibraryName( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jobject _strLib) { - JavaString* strLib = (JavaString*)_strLib; - Jnjvm* vm = JavaThread::get()->isolate; - - const UTF8* utf8Lib = strLib->value; - uint32 stLib = strLib->offset; - sint32 lgLib = strLib->count; - sint32 lgPre = vm->prelib->size; - sint32 lgPost = vm->postlib->size; - - uint32 size = (uint32)(lgPre + lgLib + lgPost); - uint16* elements = (uint16*)alloca(size * sizeof(uint16)); - - memmove(elements, vm->prelib->elements, lgPre * sizeof(uint16)); - memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]), lgLib * sizeof(uint16)); - memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, lgPost * sizeof(uint16)); - - // TODO: find a better place to store the UTF8 - const UTF8* res = vm->bootstrapLoader->readerConstructUTF8(elements, size); - - return (jobject)(vm->UTF8ToStr(res)); - -} - -typedef int (*onLoad_t)(const void**, void*); - -JNIEXPORT jint JNICALL Java_java_lang_VMRuntime_nativeLoad( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject _str, - jobject _loader) { - JavaString* str = (JavaString*)_str; -#ifndef SERVICE_VM - Jnjvm* vm = JavaThread::get()->isolate; -#else - Jnjvm* vm = Jnjvm::bootstrapVM; -#endif - - char* buf = str->strToAsciiz(); - - void* res = dlopen(buf, RTLD_LAZY | RTLD_LOCAL); - if (res != 0) { - vm->nativeLibs.push_back(res); - onLoad_t onLoad = (onLoad_t)(intptr_t)dlsym(res, "JNI_OnLoad"); - if (onLoad) onLoad(&vm->javavmEnv, 0); - return 1; - } else { - return 0; - } -} - - -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_gc( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { -#ifdef MULTIPLE_GC - mvm::Thread::get()->GC->collect(); -#else - Collector::collect(); -#endif -} - -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { - return; -} - -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizationForExit( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { - return; -} - -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_exit( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jint par1) { -#if defined(ISOLATE) || defined(ISOLATE_SHARING) - // TODO: do a longjmp - exit(par1); -#else - exit(par1); -#endif -} - -JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { -#ifdef MULTIPLE_GC - return (jlong)mvm::Thread::get()->GC->getFreeMemory(); -#else - return (jlong)Collector::getFreeMemory(); -#endif -} - -JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { -#ifdef MULTIPLE_GC - return (jlong)mvm::Thread::get()->GC->getTotalMemory(); -#else - return (jlong)Collector::getTotalMemory(); -#endif -} - -JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { -#ifdef MULTIPLE_GC - return (jlong)mvm::Thread::get()->GC->getMaxMemory(); -#else - return (jlong)Collector::getMaxMemory(); -#endif -} - -JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){ -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - return 1; -} -} - Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (removed) @@ -1,151 +0,0 @@ -//===- ClasspathVMStackWalker.cpp -----------------------------------------===// -//===------------ GNU classpath gnu/classpath/VMStackWalker ---------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.h" - -#include "mvm/JIT.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; - -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; -} -#endif - -#ifdef ISOLATE_SHARING -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()->isolate; - int* ips[100]; - int real_size = mvm::jit::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; - } - } - -#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 -} - -JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jclass _Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* Cl = (JavaObject*)_Cl; - UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl); - return (jobject)cl->classLoader->getJavaClassLoader(); -} - -extern "C" JavaObject* getCallingClass() { - UserClass* cl = JavaJIT::getCallingClass(); - if (cl) return cl->getClassDelegatee(JavaThread::get()->isolate); - return 0; -} - -extern "C" JavaObject* getCallingClassLoader() { - return JavaJIT::getCallingClassLoader(); -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc (removed) @@ -1,109 +0,0 @@ -//===-- ClasspathVMSystem.cpp - GNU classpath java/lang/VMSystem ----------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.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; - -extern "C" { - -JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass _cl, -#endif - jobject _src, - jint sstart, - jobject _dst, - jint dstart, - jint len) { - jnjvm::Jnjvm *vm = JavaThread::get()->isolate; - JavaArray* src = (JavaArray*)_src; - JavaArray* dst = (JavaArray*)_dst; - - verifyNull(src); - verifyNull(dst); - - if (!(src->classOf->isArray() && dst->classOf->isArray())) { - vm->arrayStoreException(); - } - - UserClassArray* ts = (UserClassArray*)src->classOf; - UserClassArray* td = (UserClassArray*)dst->classOf; - UserCommonClass* dstType = td->baseClass(); - UserCommonClass* srcType = ts->baseClass(); - - if (len > src->size) { - vm->indexOutOfBounds(src, len); - } else if (len > dst->size) { - vm->indexOutOfBounds(dst, len); - } else if (len + sstart > src->size) { - vm->indexOutOfBounds(src, len + sstart); - } else if (len + dstart > dst->size) { - vm->indexOutOfBounds(dst, len + dstart); - } else if (dstart < 0) { - vm->indexOutOfBounds(dst, dstart); - } else if (sstart < 0) { - vm->indexOutOfBounds(src, sstart); - } else if (len < 0) { - vm->indexOutOfBounds(src, len); - } else if ((dstType->isPrimitive() || srcType->isPrimitive()) && - srcType != dstType) { - vm->arrayStoreException(); - } - - jint i = sstart; - bool doThrow = false; - if (!(dstType->isPrimitive())) { - while (i < sstart + len && !doThrow) { - JavaObject* cur = ((ArrayObject*)src)->elements[i]; - if (cur) { - if (!(cur->classOf->isAssignableFrom(dstType))) { - doThrow = true; - len = i; - } - } - ++i; - } - } - - uint32 size = dstType->isPrimitive() ? - dstType->virtualSize : sizeof(JavaObject*); - - assert(size && "Size zero in a arraycopy"); - void* ptrDst = (void*)((int64_t)(dst->elements) + size * dstart); - void* ptrSrc = (void*)((int64_t)(src->elements) + size * sstart); - memmove(ptrDst, ptrSrc, size * len); - - if (doThrow) - vm->arrayStoreException(); - - -} - -JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode( -#ifdef NATIVE_JNI -JNIEnv *env, - jclass clazz, -#endif - jobject obj) { - return (jint)(intptr_t)obj; -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc (removed) @@ -1,131 +0,0 @@ -//===- ClasspathVMSystem/Properties.cpp -----------------------------------===// -//===--------------------- GNU classpath gnu/classpath/VMSystemProperties -===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include -#include - -#include "types.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; - -extern "C" { - -static void setProperty(Jnjvm* vm, JavaObject* prop, const char* key, - const char* val) { - vm->upcalls->setProperty->invokeIntSpecial(vm, (UserClass*)prop->classOf, - prop, - vm->asciizToStr(key), - vm->asciizToStr(val)); -} - -static void setUnameProp(Jnjvm* vm, JavaObject* prop) { - struct utsname infos; - uname(&infos); - setProperty(vm, prop, "os.name", infos.sysname); - setProperty(vm, prop, "os.arch", infos.machine); - setProperty(vm, prop, "os.version", infos.release); - if (!strcmp(infos.machine, "ppc")) { - setProperty(vm, prop, "gnu.cpu.endian","big"); - } else { - setProperty(vm, prop, "gnu.cpu.endian","little"); - } -} - -JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit( - -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -jobject _prop) { - - JavaObject* prop = (JavaObject*)_prop; - Jnjvm* vm = JavaThread::get()->isolate; - const char* tmp; - setProperty(vm, prop, "java.vm.specification.version", "1.0"); - setProperty(vm, prop, "java.vm.specification.vendor", "Sun Microsystems, Inc"); - setProperty(vm, prop, "java.vm.specification.name", "Java Virtual Machine Specification"); - setProperty(vm, prop, "java.specification.version", "1.5"); - setProperty(vm, prop, "java.specification.vendor", "Sun Microsystems, Inc"); - setProperty(vm, prop, "java.specification.name", "Java Platform API Specification"); - setProperty(vm, prop, "java.version", "1.5"); - setProperty(vm, prop, "java.runtime.version", "1.5"); - setProperty(vm, prop, "java.vendor", "VVM Project"); - setProperty(vm, prop, "java.vendor.url", "http://vvm.lip6.fr"); - - tmp = getenv("JAVA_HOME"); - if (!tmp) tmp = ""; - setProperty(vm, prop, "java.home", tmp); - - JnjvmBootstrapLoader* JCL = vm->bootstrapLoader; - setProperty(vm, prop, "java.class.version", "49.0"); - setProperty(vm, prop, "java.class.path", vm->classpath); - setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv); - setProperty(vm, prop, "sun.boot.class.path", JCL->bootClasspathEnv); - setProperty(vm, prop, "java.vm.version", "2.0"); - 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"); - if (!tmp) tmp = "gcj"; - setProperty(vm, prop, "java.compiler", tmp); - - setProperty(vm, prop, "build.compiler", "gcj"); - setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv); - - setUnameProp(vm, prop); - - setProperty(vm, prop, "file.separator", vm->dirSeparator); - setProperty(vm, prop, "path.separator", vm->envSeparator); - setProperty(vm, prop, "line.separator", "\n"); - - tmp = getenv("USERNAME"); - if (!tmp) tmp = getenv("LOGNAME"); - else if (!tmp) tmp = getenv("NAME"); - else if (!tmp) tmp = ""; - setProperty(vm, prop, "user.name", tmp); - - tmp = getenv("HOME"); - if (!tmp) tmp = ""; - setProperty(vm, prop, "user.home", tmp); - - tmp = getenv("PWD"); - if (!tmp) tmp = ""; - setProperty(vm, prop, "user.dir", tmp); - - //setProperty(vm, prop, "gnu.classpath.nio.charset.provider.iconv", "true") - - setProperty(vm, prop, "file.encoding", "ISO8859_1"); - setProperty(vm, prop, "gnu.java.util.zoneinfo.dir", "/usr/share/zoneinfo"); - - -} - -extern "C" void propertiesPostInit(JavaObject* prop) { - Jnjvm* vm = JavaThread::get()->isolate; - for (std::vector >::iterator i = vm->postProperties.begin(), - e = vm->postProperties.end(); i!= e; i++) { - setProperty(vm, prop, i->first, i->second); - } -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (removed) @@ -1,200 +0,0 @@ -//===- ClasspathVMThread.cpp - GNU classpath java/lang/VMThread -----------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.h" - -#include "mvm/Threads/Thread.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" - -#ifdef SERVICE_VM -#include "ServiceDomain.h" -#endif - -using namespace jnjvm; - -extern "C" { - -JNIEXPORT jobject JNICALL Java_java_lang_VMThread_currentThread( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz -#endif -) { - return (jobject)(JavaThread::currentThread()); -} - -typedef struct arg_thread_t { - JavaObject* vmThread; - JavaThread* intern; -}arg_thread_t; - -static void start(arg_thread_t* arg) { - int argc; - JavaObject* vmThread = arg->vmThread; - JavaThread* intern = arg->intern; - free(arg); - mvm::Thread::set(intern); -#ifdef MULTIPLE_GC - intern->GC->inject_my_thread(&argc); -#else - Collector::inject_my_thread(&argc); -#endif - UserClass* vmthClass = (UserClass*)vmThread->classOf; - Jnjvm* isolate = intern->isolate; - JavaObject* thread = isolate->upcalls->assocThread->getObjectField(vmThread); - ThreadSystem* ts = isolate->threadSystem; - bool isDaemon = isolate->upcalls->daemon->getInt8Field(thread); - intern->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; - - - if (!isDaemon) { - ts->nonDaemonLock->lock(); - ts->nonDaemonThreads++; - ts->nonDaemonLock->unlock(); - } - -#ifdef SERVICE_VM - ServiceDomain* vm = (ServiceDomain*)isolate; - vm->startExecution(); - vm->lock->lock(); - vm->numThreads++; - vm->lock->unlock(); -#endif - - isolate->upcalls->runVMThread->invokeIntSpecial(isolate, vmthClass, vmThread); - - if (!isDaemon) { - ts->nonDaemonLock->lock(); - ts->nonDaemonThreads--; - if (ts->nonDaemonThreads == 0) - ts->nonDaemonVar->signal(); - ts->nonDaemonLock->unlock(); - } - -#ifdef SERVICE_VM - vm->lock->lock(); - vm->numThreads--; - vm->lock->unlock(); -#endif - -#ifdef MULTIPLE_GC - intern->GC->remove_my_thread(); -#else - Collector::remove_my_thread(); -#endif -} - -JNIEXPORT void JNICALL Java_java_lang_VMThread_start( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject _vmThread, sint64 stackSize) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* vmThread = (JavaObject*)_vmThread; - JavaObject* javaThread = vm->upcalls->assocThread->getObjectField(vmThread); - assert(javaThread); - - JavaThread* th = allocator_new(vm->allocator, JavaThread)(); - th->initialise(javaThread, vm); - vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)th); - int tid = 0; - arg_thread_t* arg = (arg_thread_t*)malloc(sizeof(arg_thread_t)); - arg->intern = th; - arg->vmThread = vmThread; -#ifdef MULTIPLE_GC - th->GC = mvm::Thread::get()->GC; -#endif - - mvm::Thread::start(&tid, (int (*)(void *))start, (void*)arg); -} - -JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject _vmthread) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* vmthread = (JavaObject*)_vmthread; - - while (vm->upcalls->vmdataVMThread->getObjectField(vmthread) == 0) - mvm::Thread::yield(); - - JavaThread* th = (JavaThread*)vm->upcalls->vmdataVMThread->getObjectField(vmthread); - 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(); -} - -JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { - JavaThread* th = JavaThread::get(); - uint32 interrupt = th->interruptFlag; - th->interruptFlag = 0; - return (jboolean)interrupt; -} - -JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject _vmthread) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* vmthread = (JavaObject*)_vmthread; - JavaThread* th = (JavaThread*)vm->upcalls->vmdataVMThread->getObjectField(vmthread); - return (jboolean)th->interruptFlag; -} - -JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject vmthread, jint prio) { - // Currently not implemented -} - -JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop( -#ifdef NATIVE_JNI -JNIEnv *env, -#endif -jobject vmthread, jobject exc) { - // Currently not implemented -} - -JNIEXPORT void JNICALL Java_java_lang_VMThread_yield( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif -) { - mvm::Thread::yield(); -} - -} Removed: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc?rev=57293&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (removed) @@ -1,119 +0,0 @@ -//===- ClasspathVMClassLoader.cpp - GNU classpath java/lang/VMClassLoader -===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include - -#include "types.h" - -#include "mvm/JIT.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; - -extern "C" { - -JNIEXPORT jobject JNICALL Java_java_lang_VMThrowable_fillInStackTrace( -#ifdef NATIVE_JNI -JNIEnv *env, -jclass clazz, -#endif - jobject throwable) { - Jnjvm* vm = JavaThread::get()->isolate; - int** stack = (int**)malloc(sizeof(int*) * 100); - int real_size = mvm::jit::getBacktrace((void**)stack, 100); - stack[real_size] = 0; - JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); - ((JavaObject**)((uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset))[0] = (JavaObject*)stack; - return (jobject)vmThrowable; -} - - -JavaObject* consStackElement(JavaMethod* meth, int* ip) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* methodName = vm->UTF8ToStr(meth->name); - Class* cl = meth->classDef; - JavaObject* className = vm->UTF8ToStr(cl->name->internalToJava(cl->classLoader->hashUTF8, 0, cl->name->size)); - JavaObject* sourceName = 0; - - Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut); - - if (sourceAtt) { - Reader reader(sourceAtt, cl->getBytes()); - uint16 index = reader.readU2(); - sourceName = vm->UTF8ToStr(cl->getConstantPool()->UTF8At(index)); - } - - bool native = isNative(meth->access); - - UserClass* newS = vm->upcalls->newStackTraceElement; - JavaObject* res = newS->doNew(vm); - vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res, - sourceName, - (uint32)ip, className, - methodName, native); - return res; -} - -ArrayObject* recGetStackTrace(int** stack, uint32 first, uint32 rec) { - Jnjvm* vm = JavaThread::get()->isolate; - 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) { - Jnjvm* vm = JavaThread::get()->isolate; - int** stack = (int**)vm->upcalls->vmDataVMThrowable->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; - } - } - jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0); - free(stack); - return res; -} - -} - From nicolas.geoffray at lip6.fr Wed Oct 8 12:45:34 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 08 Oct 2008 19:45:34 -0000 Subject: [vmkit-commits] [vmkit] r57306 - in /vmkit/trunk/lib/JnJVM: Classpath/ VMCore/ Message-ID: <200810081945.m98JjYho012559@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 8 14:45:31 2008 New Revision: 57306 URL: http://llvm.org/viewvc/llvm-project?rev=57306&view=rev Log: Code cleanup. Modified: 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/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/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Wed Oct 8 14:45:31 2008 @@ -20,30 +20,40 @@ using namespace jnjvm; extern "C" { + +// Define hasClassInitializer because of a buggy implementation in Classpath. JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer( #ifdef NATIVE_JNI JNIEnv *env, jclass clazz, #endif jclass Cl) { - - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, true); + + verifyNull(Cl); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); UserClass* methodCl = 0; if (cl->lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, false, methodCl)) return true; - else - return false; + + return false; } + +// Redefine some VMObjectStreamClass functions because of a slow implementation +// in Classpath. + JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative( #ifdef NATIVE_JNI JNIEnv *env, jclass clazz, #endif jobject Field, jobject obj, jboolean val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt8Field((JavaObject*)obj, (uint8)val); } @@ -53,8 +63,10 @@ jclass clazz, #endif jobject Field, jobject obj, jbyte val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt8Field((JavaObject*)obj, (uint8)val); } @@ -64,8 +76,10 @@ jclass clazz, #endif jobject Field, jobject obj, jchar val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt16Field((JavaObject*)obj, (uint16)val); } @@ -75,8 +89,10 @@ jclass clazz, #endif jobject Field, jobject obj, jshort val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt16Field((JavaObject*)obj, (sint16)val); } @@ -86,8 +102,10 @@ jclass clazz, #endif jobject Field, jobject obj, jint val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setInt32Field((JavaObject*)obj, (sint32)val); } @@ -97,8 +115,10 @@ jclass clazz, #endif jobject Field, jobject obj, jlong val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setLongField((JavaObject*)obj, (sint64)val); } @@ -108,8 +128,10 @@ jclass clazz, #endif jobject Field, jobject obj, jfloat val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setFloatField((JavaObject*)obj, (float)val); } @@ -119,8 +141,10 @@ jclass clazz, #endif jobject Field, jobject obj, jdouble val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setDoubleField((JavaObject*)obj, (double)val); } @@ -130,8 +154,10 @@ jclass clazz, #endif jobject Field, jobject obj, jobject val) { + verifyNull(obj); Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); field->setObjectField((JavaObject*)obj, (JavaObject*)val); } @@ -142,7 +168,7 @@ #endif jclass target, jclass constr, jobject cons) { Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(target, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, target, true); JavaObject* res = cl->doNew(vm); JavaField* field = vm->upcalls->constructorSlot; JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); @@ -157,7 +183,7 @@ #endif jclass arrayType, jint arrayLength) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* base = NativeUtil::resolvedImplClass(arrayType, true); + UserCommonClass* base = NativeUtil::resolvedImplClass(vm, arrayType, true); JnjvmClassLoader* loader = base->classLoader; const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); @@ -166,7 +192,8 @@ } -JNIEXPORT bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8( +JNIEXPORT +bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8( #ifdef NATIVE_JNI JNIEnv *env, jclass clazz, Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathConstructor.cpp Wed Oct 8 14:45:31 2008 @@ -26,20 +26,31 @@ extern "C" { +// internalGetClass selects the class of a method depending on the isolate +// environment. In a sharing environment, the class is located in the +// Java object. In regular environment, it is the classDef of the method. +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); + return cl; +#else + return meth->classDef; +#endif +} + JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getParameterTypes( #ifdef NATIVE_JNI JNIEnv *env, #endif jobject cons) { + verifyNull(cons); Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->constructorClass->getInt32Field((JavaObject*)cons); - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + JavaField* field = vm->upcalls->constructorSlot; + JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); + UserClass* cl = internalGetClass(vm, meth, cons); JnjvmClassLoader* loader = cl->classLoader; -#else - JnjvmClassLoader* loader = meth->classDef->classLoader; -#endif return (jobject)(NativeUtil::getParameterTypes(loader, meth)); } @@ -49,8 +60,10 @@ JNIEnv *env, #endif jobject cons) { + verifyNull(cons); Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons)); + JavaField* field = vm->upcalls->constructorSlot; + JavaMethod* meth = (JavaMethod*)(field->getInt32Field((JavaObject*)cons)); return meth->access; } @@ -58,43 +71,52 @@ #ifdef NATIVE_JNI JNIEnv *env, #endif - jobject _cons, - jobject _args, - jclass Clazz, - jint _meth) { +jobject _cons, +jobject _args, +jclass Clazz, +jint _meth) { + + Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)_meth; JavaArray* args = (JavaArray*)_args; sint32 nbArgs = args ? args->size : 0; sint32 size = meth->getSignature()->args.size(); - Jnjvm* vm = JavaThread::get()->isolate; + // Allocate a buffer to store the arguments. void** buf = (void**)alloca(size * sizeof(uint64)); - void* _buf = (void*)buf; + // Record the beginning of the buffer. + void* startBuf = (void*)buf; + sint32 index = 0; if (nbArgs == size) { - UserCommonClass* _cl = NativeUtil::resolvedImplClass(Clazz, false); - if (!_cl->isArray()) { - UserClass* cl = (UserClass*)_cl; + UserCommonClass* _cl = NativeUtil::resolvedImplClass(vm, Clazz, false); + UserClass* cl = _cl->asClass(); + if (cl) { cl->initialiseClass(vm); - JavaObject* res = cl->doNew(vm); JavaObject** ptr = (JavaObject**)(void*)(args->elements); - for (std::vector::iterator i = meth->getSignature()->args.begin(), - e = meth->getSignature()->args.end(); i != e; ++i, ++index) { + Signdef* sign = meth->getSignature(); + + // 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); } JavaObject* excp = 0; try { - meth->invokeIntSpecialBuf(vm, cl, res, _buf); + meth->invokeIntSpecialBuf(vm, cl, res, startBuf); }catch(...) { excp = JavaThread::getJavaException(); JavaThread::clearException(); } if (excp) { if (excp->classOf->isAssignableFrom(vm->upcalls->newException)) { + // If it's an exception, we encapsule it in an + // invocationTargetException vm->invocationTargetException(excp); } else { + // If it's an error, throw it again. JavaThread::throwException(excp); } } @@ -106,21 +128,17 @@ return 0; } -JNIEXPORT jobjectArray JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes( +JNIEXPORT +jobjectArray JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes( #ifdef NATIVE_JNI JNIEnv *env, #endif jobject cons) { verifyNull(cons); Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons); - UserClass* cl = 0; -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)cons); - cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); -#else - cl = meth->classDef; -#endif + JavaField* field = vm->upcalls->constructorSlot; + JavaMethod* meth = (JavaMethod*)field->getInt32Field((JavaObject*)cons); + UserClass* cl = internalGetClass(vm, meth, cons); return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathField.cpp Wed Oct 8 14:45:31 2008 @@ -22,8 +22,9 @@ static UserClass* internalGetClass(Jnjvm* vm, JavaField* field, jobject Field) { #ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->fieldClass->getInt32Field((JavaObject*)Field); - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); + JavaField* slot = vm->upcalls->fieldClass; + jclass Cl = (jclass)slot->getInt32Field((JavaObject*)Field); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, Cl, false); return cl; #else return field->classDef; @@ -36,7 +37,8 @@ #endif jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)obj); return field->access; } @@ -46,7 +48,8 @@ #endif jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)obj); + 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); @@ -59,7 +62,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); const Typedef* type = field->getSignature(); JavaObject* Obj = (JavaObject*)obj; @@ -68,6 +72,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } if (type->isPrimitive()) { @@ -83,7 +89,7 @@ return (sint32)field->getInt16Field(Obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + vm->illegalArgumentException(""); return 0; } @@ -94,7 +100,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -102,6 +109,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -120,7 +129,7 @@ return (sint64)field->getLongField(Obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + vm->illegalArgumentException(""); return 0; } @@ -130,7 +139,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -138,6 +148,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -147,7 +159,7 @@ return (uint8)field->getInt8Field(Obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + vm->illegalArgumentException(""); return 0; @@ -159,7 +171,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -167,6 +180,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -181,11 +196,13 @@ if (prim->isLong()) return (jfloat)field->getLongField((JavaObject*)obj); 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); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); return 0.0; } @@ -195,7 +212,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -203,6 +221,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -211,7 +231,8 @@ if (prim->isByte()) return (sint8)field->getInt8Field(Obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); return 0; } @@ -222,7 +243,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -230,6 +252,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -238,7 +262,8 @@ if (prim->isChar()) return (uint16)field->getInt16Field((JavaObject*)obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); return 0; @@ -250,7 +275,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -258,6 +284,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -268,7 +296,8 @@ if (prim->isByte()) return (sint16)field->getInt8Field(Obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); return 0; } @@ -279,7 +308,8 @@ #endif jobject Field, jobject obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -287,6 +317,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -307,7 +339,8 @@ if (prim->isDouble()) return (jdouble)field->getDoubleField(Obj); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); return 0.0; } @@ -317,7 +350,8 @@ #endif jobject Field, jobject _obj) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)_obj; @@ -325,6 +359,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } JavaObject* res = 0; @@ -374,6 +410,7 @@ } else { res = field->getObjectField(Obj); } + return (jobject)res; } @@ -383,10 +420,12 @@ #endif jobject Field, jobject obj, jobject val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); void** buf = (void**)alloca(sizeof(uint64)); void* _buf = (void*)buf; - NativeUtil::decapsulePrimitive(JavaThread::get()->isolate, buf, (JavaObject*)val, field->getSignature()); + const Typedef* type = field->getSignature(); + NativeUtil::decapsulePrimitive(vm, buf, (JavaObject*)val, type); JavaObject* Obj = (JavaObject*)obj; @@ -395,9 +434,11 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } - const Typedef* type = field->getSignature(); + if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; if (prim->isBool()) @@ -419,6 +460,9 @@ } else { return field->setObjectField(Obj, ((JavaObject**)_buf)[0]); } + + // Unreachable code + return; } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean( @@ -427,13 +471,16 @@ #endif jobject Field, jobject obj, jboolean val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; if (isStatic(field->access)) { UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -442,7 +489,8 @@ if (prim->isBool()) return field->setInt8Field(Obj, (uint8)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } @@ -452,15 +500,18 @@ #endif jobject Field, jobject obj, jbyte val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; if (isStatic(field->access)) { UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } - + const Typedef* type = field->getSignature(); if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; @@ -477,7 +528,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar( @@ -486,7 +538,8 @@ #endif jobject Field, jobject obj, jchar val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -494,8 +547,9 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } - const Typedef* type = field->getSignature(); if (type->isPrimitive()) { const PrimitiveTypedef* prim = (PrimitiveTypedef*)type; @@ -510,7 +564,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)(uint64)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort( @@ -519,7 +574,8 @@ #endif jobject Field, jobject obj, jshort val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; @@ -527,6 +583,8 @@ UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -543,7 +601,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt( @@ -552,13 +611,16 @@ #endif jobject Field, jobject obj, jint val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; if (isStatic(field->access)) { UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -573,7 +635,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong( @@ -582,13 +645,16 @@ #endif jobject Field, jobject obj, jlong val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; if (isStatic(field->access)) { UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -601,7 +667,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat( @@ -610,13 +677,16 @@ #endif jobject Field, jobject obj, jfloat val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; if (isStatic(field->access)) { UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -627,7 +697,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble( @@ -636,13 +707,16 @@ #endif jobject Field, jobject obj, jdouble val) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); JavaObject* Obj = (JavaObject*)obj; if (isStatic(field->access)) { UserClass* cl = internalGetClass(vm, field, Field); cl->initialiseClass(vm); Obj = cl->getStaticInstance(); + } else { + verifyNull(Obj); } const Typedef* type = field->getSignature(); @@ -651,7 +725,8 @@ if (prim->isDouble()) return field->setDoubleField(Obj, (double)val); } - JavaThread::get()->isolate->illegalArgumentException(""); + + vm->illegalArgumentException(""); } JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset( @@ -661,7 +736,8 @@ JavaObject* Unsafe, JavaObject* Field) { Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field); + JavaField* slot = vm->upcalls->fieldSlot; + JavaField* field = (JavaField*)slot->getInt32Field((JavaObject*)Field); return (jlong)field->ptrOffset; } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathMethod.cpp Wed Oct 8 14:45:31 2008 @@ -26,13 +26,29 @@ extern "C" { +// internalGetClass selects the class of a method depending on the isolate +// environment. In a sharing environment, the class is located in the +// Java object. In regular environment, it is the classDef of the method. +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); + return cl; +#else + return meth->classDef; +#endif +} + + JNIEXPORT jint JNICALL Java_java_lang_reflect_Method_getModifiersInternal( #ifdef NATIVE_JNI JNIEnv *env, #endif jobject Meth) { Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); + JavaField* slot = vm->upcalls->methodSlot; + JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); return meth->access; } @@ -42,14 +58,10 @@ #endif jobject Meth) { Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + JavaField* slot = vm->upcalls->methodSlot; + JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); + UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; -#else - JnjvmClassLoader* loader = meth->classDef->classLoader; -#endif return (jclass)NativeUtil::getClassType(loader, meth->getSignature()->ret); } @@ -58,17 +70,12 @@ #ifdef NATIVE_JNI JNIEnv *env, #endif - - jobject Meth) { +jobject Meth) { Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)Meth); -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + JavaField* slot = vm->upcalls->methodSlot; + JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)Meth); + UserClass* cl = internalGetClass(vm, meth, Meth); JnjvmClassLoader* loader = cl->classLoader; -#else - JnjvmClassLoader* loader = meth->classDef->classLoader; -#endif return (jobject)(NativeUtil::getParameterTypes(loader, meth)); } @@ -76,20 +83,20 @@ #ifdef NATIVE_JNI JNIEnv *env, #endif - jobject Meth, jobject _obj, jobject _args, jclass Cl, jint _meth) { +jobject Meth, jobject _obj, jobject _args, jclass Cl, jint _meth) { + Jnjvm* vm = JavaThread::get()->isolate; JavaMethod* meth = (JavaMethod*)_meth; JavaArray* args = (JavaArray*)_args; sint32 nbArgs = args ? args->size : 0; sint32 size = meth->getSignature()->args.size(); - Jnjvm* vm = JavaThread::get()->isolate; JavaObject* obj = (JavaObject*)_obj; void** buf = (void**)alloca(size * sizeof(uint64)); void* _buf = (void*)buf; sint32 index = 0; if (nbArgs == size) { - UserCommonClass* _cl = NativeUtil::resolvedImplClass(Cl, false); + UserCommonClass* _cl = NativeUtil::resolvedImplClass(vm, Cl, false); UserClass* cl = (UserClass*)_cl; if (isVirtual(meth->access)) { @@ -101,18 +108,18 @@ if (isInterface(cl->classDef->access)) { cl = obj->classOf->lookupClassFromMethod(meth); } else { - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth); - cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); + cl = internalGetClass(vm, meth, Meth); } #endif } else { cl->initialiseClass(vm); } - + + Signdef* sign = meth->getSignature(); JavaObject** ptr = (JavaObject**)(void*)(args->elements); - for (std::vector::iterator i = meth->getSignature()->args.begin(), - e = meth->getSignature()->args.end(); i != e; ++i, ++index) { + for (std::vector::iterator i = sign->args.begin(), + e = sign->args.end(); i != e; ++i, ++index) { NativeUtil::decapsulePrimitive(vm, buf, ptr[index], *i); } @@ -121,7 +128,8 @@ #define RUN_METH(TYPE) \ try{ \ if (isVirtual(meth->access)) { \ - if (isPublic(meth->access) && !isFinal(meth->access) && !isFinal(meth->classDef->access)) { \ + if (isPublic(meth->access) && !isFinal(meth->access) && \ + !isFinal(meth->classDef->access)) { \ val = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, _buf); \ } else { \ val = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, _buf); \ @@ -144,7 +152,7 @@ } \ JavaObject* res = 0; - Typedef* retType = meth->getSignature()->ret; + Typedef* retType = sign->ret; if (retType->isPrimitive()) { PrimitiveTypedef* prim = (PrimitiveTypedef*)retType; if (prim->isVoid()) { @@ -209,17 +217,12 @@ #ifdef NATIVE_JNI JNIEnv *env, #endif - jobject _meth) { +jobject _meth) { verifyNull(_meth); Jnjvm* vm = JavaThread::get()->isolate; - JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)_meth); - UserClass* cl = 0; -#ifdef ISOLATE_SHARING - jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)_meth); - cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false); -#else - cl = meth->classDef; -#endif + JavaField* slot = vm->upcalls->methodSlot; + JavaMethod* meth = (JavaMethod*)slot->getInt32Field((JavaObject*)_meth); + UserClass* cl = internalGetClass(vm, meth, _meth); return (jobjectArray)NativeUtil::getExceptionTypes(cl, meth); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Wed Oct 8 14:45:31 2008 @@ -36,8 +36,9 @@ jobject klass) { Jnjvm* vm = JavaThread::get()->isolate; + JavaField* field = vm->upcalls->vmdataClass; UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)klass); + (UserCommonClass*)field->getObjectField((JavaObject*)klass); return cl->isArray(); @@ -48,13 +49,13 @@ JNIEnv *env, jclass clazz, #endif - - jobject str, - jboolean clinit, - jobject loader) { +jobject str, +jboolean clinit, +jobject loader) { Jnjvm* vm = JavaThread::get()->isolate; - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); + JnjvmClassLoader* JCL = + JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, true, false); if (cl != 0) { @@ -71,16 +72,15 @@ JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredConstructors( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif +jclass Cl, +jboolean publicOnly) { - jclass Cl, - jboolean publicOnly) { - - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); - if (cl->isArray() || cl->isInterface()) { + if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) { return (jobject)vm->upcalls->constructorArrayClass->doNew(0, vm); } else { std::vector res; @@ -105,22 +105,24 @@ JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getDeclaredMethods( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - - jclass Cl, - jboolean publicOnly) { +jclass Cl, +jboolean publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); + Classpath* upcalls = vm->upcalls; if (cl->isArray()) { - return (jobject)vm->upcalls->methodArrayClass->doNew(0, vm); + return (jobject)upcalls->methodArrayClass->doNew(0, vm); } else { std::vector res; cl->getDeclaredMethods(res, publicOnly); - ArrayObject* ret = (ArrayObject*)vm->upcalls->methodArrayClass->doNew(res.size(), vm); + ArrayObject* ret = + (ArrayObject*)upcalls->methodArrayClass->doNew(res.size(), vm); + sint32 index = 0; for (std::vector::iterator i = res.begin(), e = res.end(); i != e; ++i, ++index) { @@ -128,8 +130,8 @@ // TODO: check parameter types UserClass* Meth = vm->upcalls->newMethod; JavaObject* tmp = Meth->doNew(vm); - vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, - vm->UTF8ToStr(meth->name), meth); + JavaString* str = vm->UTF8ToStr(meth->name); + upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, str, meth); ret->elements[index] = tmp; } return (jobject)ret; @@ -139,27 +141,29 @@ JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jclass Cl, - jboolean ignore) { +jclass Cl, +jboolean ignore) { - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); return cl->getAccess(); } JNIEXPORT jobject JNICALL Java_java_lang_VMClass_getName( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jobject Cl) { +jobject Cl) { Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); const UTF8* iname = cl->getName(); - const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, iname->size); + const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, + iname->size); return (jobject)(vm->UTF8ToStr(res)); } @@ -167,9 +171,9 @@ JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jclass Cl) { +jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); @@ -180,10 +184,11 @@ JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jclass Cl) { - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); +jclass Cl) { + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); return cl->isInterface(); } @@ -191,9 +196,9 @@ JNIEXPORT jclass JNICALL Java_java_lang_VMClass_getComponentType( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jclass Cl) { +jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); @@ -272,7 +277,7 @@ #endif jclass Cl, jboolean publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (!cl) { return (jobject)vm->upcalls->fieldArrayClass->doNew(0, vm); @@ -304,7 +309,7 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false); + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); std::vector * interfaces = cl->getInterfaces(); ArrayObject* ret = (ArrayObject*)vm->upcalls->classArrayClass->doNew(interfaces->size(), vm); @@ -325,7 +330,7 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (cl) { cl->resolveInnerOuterClasses(); UserClass* outer = cl->getOuterClass(); @@ -344,12 +349,12 @@ #endif jclass Cl, bool publicOnly) { Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = NativeUtil::resolvedImplClass(Cl, false)->asClass(); + UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (cl) { cl->resolveInnerOuterClasses(); std::vector* innerClasses = cl->getInnerClasses(); - ArrayObject* res = - (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(innerClasses->size(), vm); + UserClassArray* array = vm->upcalls->constructorArrayClass; + ArrayObject* res = (ArrayObject*)array->doNew(innerClasses->size(), vm); uint32 index = 0; for (std::vector::iterator i = innerClasses->begin(), e = innerClasses->end(); i!= e; i++) { @@ -380,7 +385,7 @@ jclass Cl) { // TODO implement me Jnjvm* vm = JavaThread::get()->isolate; - ArrayObject* res = (ArrayObject*)vm->upcalls->constructorArrayAnnotation->doNew(0, vm); - return (jobjectArray)res; + UserClassArray* array = vm->upcalls->constructorArrayAnnotation; + return (jobjectArray)array->doNew(0, vm); } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Wed Oct 8 14:45:31 2008 @@ -25,7 +25,7 @@ extern "C" { -JNIEXPORT jobject JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass( +JNIEXPORT jobject JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass( #ifdef NATIVE_JNI JNIEnv *env, jclass clazz, @@ -47,17 +47,19 @@ JNIEnv *env, jclass clazz, #endif - jobject loader, - jobject _name) { +jobject loader, +jobject _name) { Jnjvm* vm = JavaThread::get()->isolate; JavaString* name = (JavaString*)_name; const UTF8* utf8 = name->strToUTF8(vm); - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); + JnjvmClassLoader* JCL = + JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); UserCommonClass* cl = JCL->lookupClass(utf8); if (cl) return (jclass)(cl->getClassDelegatee(vm)); - else return 0; + + return 0; } JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_loadClass( @@ -65,19 +67,18 @@ JNIEnv *env, jclass clazz, #endif - jobject _str, - jboolean doResolve) { +jobject _str, +jboolean doResolve) { Jnjvm* vm = JavaThread::get()->isolate; JavaString* str = (JavaString*)_str; JnjvmClassLoader* JCL = vm->bootstrapLoader; UserCommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false); - if (cl != 0) { + if (cl != 0) return (jclass)cl->getClassDelegatee(vm); - } else { - return 0; - } + + return 0; } JNIEXPORT jclass JNICALL Java_java_lang_VMClassLoader_defineClass( @@ -85,16 +86,20 @@ JNIEnv *env, jclass clazz, #endif - jobject loader, - jobject _str, - jobject bytes, - jint off, - jint len, - jobject pd) { +jobject loader, +jobject _str, +jobject bytes, +jint off, +jint len, +jobject pd) { Jnjvm* vm = JavaThread::get()->isolate; - JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); + + JnjvmClassLoader* JCL = + JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); + JavaString* str = (JavaString*)_str; - const UTF8* name = str->value->javaToInternal(JCL->hashUTF8, str->offset, str->count); + const UTF8* name = str->value->javaToInternal(JCL->hashUTF8, str->offset, + str->count); UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes); return (jclass)(cl->getClassDelegatee(vm, (JavaObject*)pd)); @@ -105,9 +110,10 @@ JNIEnv *env, jclass clazz, #endif - jclass Cl) { +jclass Cl) { verifyNull(Cl); - NativeUtil::resolvedImplClass(Cl, false); + Jnjvm* vm = JavaThread::get()->isolate; + NativeUtil::resolvedImplClass(vm, Cl, false); } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Wed Oct 8 14:45:31 2008 @@ -28,10 +28,11 @@ JNIEnv *env, jclass clazz, #endif - jobject _src) { +jobject _src) { JavaObject* src = (JavaObject*)_src; UserCommonClass* cl = src->classOf; + Jnjvm* vm = JavaThread::get()->isolate; uint64 size = 0; if (cl->isArray()) { size = sizeof(JavaArray) + ((JavaArray*)src)->size * @@ -40,7 +41,7 @@ size = cl->getVirtualSize(); } JavaObject* res = (JavaObject*) - JavaThread::get()->isolate->allocator.allocateObject(size, src->getVirtualTable()); + vm->allocator.allocateObject(size, src->getVirtualTable()); memcpy(res, src, size); res->lock = 0; return (jobject)res; @@ -51,7 +52,7 @@ JNIEnv *env, jclass clazz, #endif - jobject _obj) { +jobject _obj) { JavaObject* obj = (JavaObject*)_obj; Jnjvm* vm = JavaThread::get()->isolate; @@ -63,8 +64,7 @@ JNIEnv *env, jclass clazz, #endif - - jobject _obj) { +jobject _obj) { JavaObject* obj = (JavaObject*)_obj; obj->notifyAll(); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Wed Oct 8 14:45:31 2008 @@ -32,9 +32,10 @@ JNIEXPORT jobject JNICALL Java_java_lang_VMRuntime_mapLibraryName( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jobject _strLib) { +jobject _strLib) { + JavaString* strLib = (JavaString*)_strLib; Jnjvm* vm = JavaThread::get()->isolate; @@ -48,8 +49,10 @@ uint16* elements = (uint16*)alloca(size * sizeof(uint16)); memmove(elements, vm->prelib->elements, lgPre * sizeof(uint16)); - memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]), lgLib * sizeof(uint16)); - memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, lgPost * sizeof(uint16)); + memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]), + lgLib * sizeof(uint16)); + memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, + lgPost * sizeof(uint16)); // TODO: find a better place to store the UTF8 const UTF8* res = vm->bootstrapLoader->readerConstructUTF8(elements, size); @@ -65,14 +68,10 @@ JNIEnv *env, jclass clazz, #endif - jobject _str, - jobject _loader) { +jobject _str, +jobject _loader) { JavaString* str = (JavaString*)_str; -#ifndef SERVICE_VM Jnjvm* vm = JavaThread::get()->isolate; -#else - Jnjvm* vm = Jnjvm::bootstrapVM; -#endif char* buf = str->strToAsciiz(); @@ -140,7 +139,7 @@ #endif ) { #ifdef MULTIPLE_GC - return (jlong)mvm::Thread::get()->GC->getFreeMemory(); + return (jlong)JavaThread::get()->GC->getFreeMemory(); #else return (jlong)Collector::getFreeMemory(); #endif Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Wed Oct 8 14:45:31 2008 @@ -45,10 +45,9 @@ } return i; } -#endif -#ifdef ISOLATE_SHARING -JavaObject* getClassInContext(Jnjvm* vm, Class* cl, UserConstantPool** ctps, uint32& ctpIndex) { +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); @@ -56,28 +55,35 @@ return 0; } -ArrayObject* recGetClassContext(Jnjvm* vm, int** stack, uint32 size, uint32 first, uint32 rec, UserConstantPool** ctps, uint32 ctpIndex) { +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); + 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); + 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) { +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); + ArrayObject* res = recGetClassContext(vm, stack, size, first + 1, + rec + 1); res->elements[rec] = meth->classDef->getClassDelegatee(vm); return res; } else { @@ -134,7 +140,8 @@ jclass _Cl) { Jnjvm* vm = JavaThread::get()->isolate; JavaObject* Cl = (JavaObject*)_Cl; - UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl); + JavaField* field = vm->upcalls->vmdataClass; + UserCommonClass* cl = (UserCommonClass*)field->getObjectField(Cl); return (jobject)cl->classLoader->getJavaClassLoader(); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystem.cpp Wed Oct 8 14:45:31 2008 @@ -26,13 +26,14 @@ JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy( #ifdef NATIVE_JNI JNIEnv *env, - jclass _cl, +jclass _cl, #endif - jobject _src, - jint sstart, - jobject _dst, - jint dstart, - jint len) { +jobject _src, +jint sstart, +jobject _dst, +jint dstart, +jint len) { + jnjvm::Jnjvm *vm = JavaThread::get()->isolate; JavaArray* src = (JavaArray*)_src; JavaArray* dst = (JavaArray*)_dst; @@ -100,9 +101,9 @@ JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode( #ifdef NATIVE_JNI JNIEnv *env, - jclass clazz, +jclass clazz, #endif - jobject obj) { +jobject obj) { return (jint)(intptr_t)obj; } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp Wed Oct 8 14:45:31 2008 @@ -47,8 +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, @@ -59,15 +58,18 @@ Jnjvm* vm = JavaThread::get()->isolate; const char* tmp; setProperty(vm, prop, "java.vm.specification.version", "1.0"); - setProperty(vm, prop, "java.vm.specification.vendor", "Sun Microsystems, Inc"); - setProperty(vm, prop, "java.vm.specification.name", "Java Virtual Machine Specification"); + setProperty(vm, prop, "java.vm.specification.vendor", + "Sun Microsystems, Inc"); + setProperty(vm, prop, "java.vm.specification.name", + "Java Virtual Machine Specification"); setProperty(vm, prop, "java.specification.version", "1.5"); setProperty(vm, prop, "java.specification.vendor", "Sun Microsystems, Inc"); - setProperty(vm, prop, "java.specification.name", "Java Platform API Specification"); + setProperty(vm, prop, "java.specification.name", + "Java Platform API Specification"); setProperty(vm, prop, "java.version", "1.5"); setProperty(vm, prop, "java.runtime.version", "1.5"); - setProperty(vm, prop, "java.vendor", "VVM Project"); - setProperty(vm, prop, "java.vendor.url", "http://vvm.lip6.fr"); + setProperty(vm, prop, "java.vendor", "The VMKit Project"); + setProperty(vm, prop, "java.vendor.url", "http://vmkit.llvm.org"); tmp = getenv("JAVA_HOME"); if (!tmp) tmp = ""; @@ -122,8 +124,8 @@ extern "C" void propertiesPostInit(JavaObject* prop) { Jnjvm* vm = JavaThread::get()->isolate; - for (std::vector >::iterator i = vm->postProperties.begin(), - e = vm->postProperties.end(); i!= e; i++) { + for (std::vector >::iterator i = + vm->postProperties.begin(), e = vm->postProperties.end(); i!= e; i++) { setProperty(vm, prop, i->first, i->second); } } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Wed Oct 8 14:45:31 2008 @@ -43,7 +43,7 @@ typedef struct arg_thread_t { JavaObject* vmThread; JavaThread* intern; -}arg_thread_t; +} arg_thread_t; static void start(arg_thread_t* arg) { int argc; @@ -135,8 +135,9 @@ while (vm->upcalls->vmdataVMThread->getObjectField(vmthread) == 0) mvm::Thread::yield(); - - JavaThread* th = (JavaThread*)vm->upcalls->vmdataVMThread->getObjectField(vmthread); + + JavaField* field = vm->upcalls->vmdataVMThread; + JavaThread* th = (JavaThread*)field->getObjectField(vmthread); th->lock->lock(); th->interruptFlag = 1; @@ -168,7 +169,8 @@ jobject _vmthread) { Jnjvm* vm = JavaThread::get()->isolate; JavaObject* vmthread = (JavaObject*)_vmthread; - JavaThread* th = (JavaThread*)vm->upcalls->vmdataVMThread->getObjectField(vmthread); + JavaField* field = vm->upcalls->vmdataVMThread; + JavaThread* th = (JavaThread*)field->getObjectField(vmthread); return (jboolean)th->interruptFlag; } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Wed Oct 8 14:45:31 2008 @@ -36,13 +36,14 @@ JNIEnv *env, jclass clazz, #endif - jobject throwable) { +jobject throwable) { Jnjvm* vm = JavaThread::get()->isolate; int** stack = (int**)malloc(sizeof(int*) * 100); int real_size = mvm::jit::getBacktrace((void**)stack, 100); stack[real_size] = 0; JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); - ((JavaObject**)((uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset))[0] = (JavaObject*)stack; + uint64 ptr = (uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset; + ((JavaObject**)ptr)[0] = (JavaObject*)stack; return (jobject)vmThrowable; } @@ -51,7 +52,9 @@ Jnjvm* vm = JavaThread::get()->isolate; JavaObject* methodName = vm->UTF8ToStr(meth->name); Class* cl = meth->classDef; - JavaObject* className = vm->UTF8ToStr(cl->name->internalToJava(cl->classLoader->hashUTF8, 0, cl->name->size)); + const UTF8* internal = cl->name->internalToJava(cl->classLoader->hashUTF8, 0, + cl->name->size); + JavaObject* className = vm->UTF8ToStr(internal); JavaObject* sourceName = 0; Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut); @@ -95,7 +98,8 @@ #endif jobject vmthrow, jobject throwable) { Jnjvm* vm = JavaThread::get()->isolate; - int** stack = (int**)vm->upcalls->vmDataVMThrowable->getObjectField((JavaObject*)vmthrow); + JavaField* field = vm->upcalls->vmDataVMThrowable; + int** stack = (int**)field->getObjectField((JavaObject*)vmthrow); uint32 first = 0; sint32 i = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Wed Oct 8 14:45:31 2008 @@ -23,15 +23,17 @@ using namespace jnjvm; -static UserClass* getClassFromStaticMethod(JavaMethod* meth, jclass clazz) { +static UserClass* getClassFromStaticMethod(Jnjvm* vm, JavaMethod* meth, + jclass clazz) { #ifdef ISOLATE_SHARING - return (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + return (UserClass*)NativeUtil::resolvedImplClass(vm, vm, clazz, true); #else return meth->classDef; #endif } -static UserClass* getClassFromVirtualMethod(JavaMethod* meth, +static UserClass* getClassFromVirtualMethod(Jnjvm* vm, + JavaMethod* meth, UserCommonClass* cl) { #ifdef ISOLATE_SHARING return cl->lookupClassFromMethod(this); @@ -131,8 +133,9 @@ BEGIN_EXCEPTION - UserCommonClass* cl2 = NativeUtil::resolvedImplClass(sup, false); - UserCommonClass* cl1 = NativeUtil::resolvedImplClass(sub, false); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl2 = NativeUtil::resolvedImplClass(vm, sup, false); + UserCommonClass* cl1 = NativeUtil::resolvedImplClass(vm, sub, false); return cl1->isAssignableFrom(cl2); @@ -154,7 +157,7 @@ JavaThread* th = JavaThread::get(); Jnjvm* vm = th->isolate; - UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); if (cl->isArray()) assert(0 && "implement me"); JavaObject* res = ((UserClass*)cl)->doNew(vm); UserClass* methodCl = 0; @@ -229,7 +232,8 @@ BEGIN_EXCEPTION - UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); if (cl->isArray()) JavaThread::get()->isolate->unknownError("implement me"); return (jobject)((UserClass*)cl)->doNew(JavaThread::get()->isolate); @@ -244,8 +248,8 @@ va_list ap; va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); Jnjvm* vm = JavaThread::get()->isolate; + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* res = cl->doNew(vm); meth->invokeIntSpecialAP(vm, cl, res, ap); va_end(ap); @@ -266,12 +270,14 @@ jobject NewObjectA(JNIEnv* env, jclass clazz, jmethodID methodID, const jvalue *args) { BEGIN_EXCEPTION - JavaMethod* meth = (JavaMethod*)methodID; - Class* cl = (Class*)NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + JavaMethod* meth = (JavaMethod*)methodID; + Class* cl = (Class*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* res = cl->doNew(vm); meth->invokeIntSpecialBuf(vm, cl, res, (void*)args); return (jobject)res; + END_EXCEPTION return 0; } @@ -322,7 +328,8 @@ BEGIN_EXCEPTION // TODO: find a better place for creating UTF8 - UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); UserClass* methodCl = 0; @@ -347,7 +354,7 @@ JavaObject* self = (JavaObject*)obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, self->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, self->classOf); JavaObject* res = meth->invokeJavaObjectVirtualAP(vm, cl, self, ap); va_end(ap); return (jobject)res; @@ -380,7 +387,7 @@ JavaObject* self = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, self->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, self->classOf); uint32 res = meth->invokeIntVirtualAP(vm, cl, self, ap); va_end(ap); return res; @@ -473,7 +480,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); uint32 res = meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -528,7 +535,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); jfloat res = meth->invokeFloatVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -562,7 +569,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); jdouble res = meth->invokeDoubleVirtualAP(vm, cl, obj, ap); va_end(ap); return res; @@ -580,7 +587,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); return meth->invokeDoubleVirtualAP(vm, cl, obj, args); END_EXCEPTION @@ -606,7 +613,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); meth->invokeIntVirtualAP(vm, cl, obj, ap); va_end(ap); @@ -622,7 +629,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); meth->invokeIntVirtualAP(vm, cl, obj, args); END_EXCEPTION @@ -843,7 +850,7 @@ JavaObject* obj = (JavaObject*)_obj; JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromVirtualMethod(meth, obj->classOf); + UserClass* cl = getClassFromVirtualMethod(vm, meth, obj->classOf); meth->invokeIntSpecialAP(vm, cl, obj, ap); va_end(ap); @@ -869,7 +876,8 @@ BEGIN_EXCEPTION // TODO: find a better place to store the UTF8 - UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); UserCommonClass* realCl = 0; return (jfieldID) cl->lookupField(cl->classLoader->asciizConstructUTF8(name), @@ -1113,7 +1121,8 @@ BEGIN_EXCEPTION // TODO: find a better place to store the UTF8 - UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); UserClass* methodCl = 0; @@ -1158,7 +1167,7 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromStaticMethod(meth, clazz); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); uint32 res = meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); return res; @@ -1334,7 +1343,7 @@ va_start(ap, methodID); JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromStaticMethod(meth, clazz); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); meth->invokeIntStaticAP(vm, cl, ap); va_end(ap); @@ -1349,7 +1358,7 @@ JavaMethod* meth = (JavaMethod*)methodID; Jnjvm* vm = JavaThread::get()->isolate; - UserClass* cl = getClassFromStaticMethod(meth, clazz); + UserClass* cl = getClassFromStaticMethod(vm, meth, clazz); meth->invokeIntStaticAP(vm, cl, args); END_EXCEPTION @@ -1368,7 +1377,8 @@ BEGIN_EXCEPTION // TODO: find a better place to store the UTF8 - UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true); + Jnjvm* vm = JavaThread::get()->isolate; + UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); UserCommonClass* realCl = 0; return (jfieldID) cl->lookupField(cl->classLoader->asciizConstructUTF8(name), @@ -1384,8 +1394,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jobject)field->getObjectField(Stat); @@ -1398,8 +1409,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jboolean)field->getInt8Field(Stat); @@ -1412,8 +1424,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jbyte)field->getInt8Field(Stat); @@ -1426,8 +1439,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jchar)field->getInt16Field(Stat); @@ -1440,8 +1454,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jshort)field->getInt16Field(Stat); @@ -1454,8 +1469,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jint)field->getInt32Field(Stat); @@ -1468,8 +1484,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jlong)field->getLongField(Stat); @@ -1482,8 +1499,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jfloat)field->getFloatField(Stat); @@ -1496,8 +1514,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); return (jdouble)field->getDoubleField(Stat); @@ -1511,8 +1530,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setObjectField(Stat, (JavaObject*)value); @@ -1525,8 +1545,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setInt8Field(Stat, (uint8)value); @@ -1539,8 +1560,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setInt8Field(Stat, (sint8)value); @@ -1553,8 +1575,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setInt16Field(Stat, (uint16)value); @@ -1567,8 +1590,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setInt16Field(Stat, (sint16)value); @@ -1581,8 +1605,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setInt32Field(Stat, (sint32)value); @@ -1595,8 +1620,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setLongField(Stat, (sint64)value); @@ -1609,8 +1635,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setFloatField(Stat, (float)value); @@ -1623,8 +1650,9 @@ BEGIN_EXCEPTION + Jnjvm* vm = JavaThread::get()->isolate; JavaField* field = (JavaField*)fieldID; - UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(clazz, true); + UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(vm, clazz, true); JavaObject* Stat = cl->getStaticInstance(); field->setDoubleField(Stat, (double)value); @@ -1707,7 +1735,7 @@ Jnjvm* vm = NativeUtil::myVM(env); if (length < 0) vm->negativeArraySizeException(length); - UserCommonClass* base = NativeUtil::resolvedImplClass(elementClass, true); + UserCommonClass* base = NativeUtil::resolvedImplClass(vm, elementClass, true); JnjvmClassLoader* loader = base->classLoader; const UTF8* name = base->getName(); const UTF8* arrayName = loader->constructArrayName(1, name); Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Wed Oct 8 14:45:31 2008 @@ -226,8 +226,7 @@ #undef PRE_LEN -UserCommonClass* NativeUtil::resolvedImplClass(jclass clazz, bool doClinit) { - Jnjvm* vm = JavaThread::get()->isolate; +UserCommonClass* NativeUtil::resolvedImplClass(Jnjvm* vm, jclass clazz, bool doClinit) { JavaObject *Cl = (JavaObject*)clazz; UserCommonClass* cl = (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl); @@ -238,7 +237,7 @@ void NativeUtil::decapsulePrimitive(Jnjvm *vm, void** &buf, JavaObject* obj, - Typedef* signature) { + const Typedef* signature) { if (!signature->isPrimitive()) { if (obj && !(obj->classOf->isOfTypeName(signature->getName()))) { Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h?rev=57306&r1=57305&r2=57306&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.h Wed Oct 8 14:45:31 2008 @@ -29,9 +29,9 @@ static Jnjvm* myVM(JNIEnv* env); static void* nativeLookup(CommonClass* cl, JavaMethod* meth, bool& jnjvm); - static UserCommonClass* resolvedImplClass(jclass clazz, bool doClinit); + static UserCommonClass* resolvedImplClass(Jnjvm* vm, jclass clazz, bool doClinit); static void decapsulePrimitive(Jnjvm *vm, void**&buf, JavaObject* obj, - Typedef* signature); + const Typedef* signature); static JavaObject* getClassType(JnjvmClassLoader* loader, Typedef* type); static ArrayObject* getParameterTypes(JnjvmClassLoader* loader, JavaMethod* meth); From nicolas.geoffray at lip6.fr Wed Oct 8 13:48:09 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 08 Oct 2008 20:48:09 -0000 Subject: [vmkit-commits] [vmkit] r57308 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMClass.cpp Classpath/ClasspathVMClassLoader.cpp Classpath/ClasspathVMThrowable.cpp VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/JavaObject.h VMCore/JavaString.cpp VMCore/Jni.cpp VMCore/Jnjvm.cpp VMCore/Jnjvm.h VMCore/NativeUtil.cpp Message-ID: <200810082048.m98KmAnG015727@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 8 15:48:07 2008 New Revision: 57308 URL: http://llvm.org/viewvc/llvm-project?rev=57308&view=rev Log: Add an UTF8 map to vms. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.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/JavaObject.h vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp 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/NativeUtil.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Wed Oct 8 15:48:07 2008 @@ -162,8 +162,7 @@ (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); const UTF8* iname = cl->getName(); - const UTF8* res = iname->internalToJava(cl->classLoader->hashUTF8, 0, - iname->size); + const UTF8* res = iname->internalToJava(vm->hashUTF8, 0, iname->size); return (jobject)(vm->UTF8ToStr(res)); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Wed Oct 8 15:48:07 2008 @@ -98,7 +98,7 @@ JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); JavaString* str = (JavaString*)_str; - const UTF8* name = str->value->javaToInternal(JCL->hashUTF8, str->offset, + const UTF8* name = str->value->javaToInternal(vm->hashUTF8, str->offset, str->count); UserClass* cl = JCL->constructClass(name, (ArrayUInt8*)bytes); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Wed Oct 8 15:48:07 2008 @@ -52,7 +52,7 @@ Jnjvm* vm = JavaThread::get()->isolate; JavaObject* methodName = vm->UTF8ToStr(meth->name); Class* cl = meth->classDef; - const UTF8* internal = cl->name->internalToJava(cl->classLoader->hashUTF8, 0, + const UTF8* internal = cl->name->internalToJava(vm->hashUTF8, 0, cl->name->size); JavaObject* className = vm->UTF8ToStr(internal); JavaObject* sourceName = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Wed Oct 8 15:48:07 2008 @@ -497,7 +497,7 @@ return false; } -bool UserCommonClass::isOfTypeName(const UTF8* Tname) { +bool UserCommonClass::isOfTypeName(Jnjvm* vm, const UTF8* Tname) { if (inheritName(Tname)) { return true; } else if (isArray()) { @@ -515,7 +515,7 @@ } return (Tname->elements[prof] == I_REF) && - (res && curS->inheritName(Tname->extract(classLoader->hashUTF8, prof + 1, + (res && curS->inheritName(Tname->extract(vm->hashUTF8, prof + 1, len - 1))); } else { 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=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Wed Oct 8 15:48:07 2008 @@ -431,7 +431,7 @@ /// isOfTypeName - Does this class inherits the given name? Equality is on /// the name. This function takes into account array classes. /// - bool isOfTypeName(const UTF8* Tname); + bool isOfTypeName(Jnjvm* vm, const UTF8* Tname); /// implements - Does this class implement the given class? Returns true if /// the class is in the interface class hierarchy. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Wed Oct 8 15:48:07 2008 @@ -161,13 +161,6 @@ this->lock = 0; } - /// instanceOfString - Is this object's class of type the given name? - /// - bool instanceOfString(const UTF8* name) { - if (!this) return false; - else return this->classOf->isOfTypeName(name); - } - /// instanceOf - Is this object's class of type the given class? /// bool instanceOf(UserCommonClass* cl) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Wed Oct 8 15:48:07 2008 @@ -48,9 +48,7 @@ const UTF8* JavaString::strToUTF8(Jnjvm* vm) { const UTF8* utf8 = this->value; if (offset || (offset + count <= utf8->size)) { - // TODO find a way to get a relevant hashUTF8 - UTF8Map* map = vm->bootstrapLoader->hashUTF8; - return utf8->extract(map, offset, offset + count); + return utf8->extract(vm->hashUTF8, offset, offset + count); } else { return utf8; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Wed Oct 8 15:48:07 2008 @@ -90,7 +90,7 @@ const UTF8* utf8 = loader->asciizConstructUTF8(asciiz); sint32 len = utf8->size; - const UTF8* internal = utf8->javaToInternal(loader->hashUTF8, 0, len); + const UTF8* internal = utf8->javaToInternal(vm->hashUTF8, 0, len); UserCommonClass* cl = loader->lookupClassFromUTF8(internal, true, true); cl->initialiseClass(vm); return (jclass)(cl->getClassDelegatee(vm)); @@ -327,15 +327,14 @@ BEGIN_EXCEPTION - // TODO: find a better place for creating UTF8 Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); UserClass* methodCl = 0; JavaMethod* meth = cl->lookupMethod( - name->javaToInternal(cl->classLoader->hashUTF8, 0, name->size), - type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), false, + name->javaToInternal(vm->hashUTF8, 0, name->size), + type->javaToInternal(vm->hashUTF8, 0, type->size), false, true, methodCl); return (jmethodID)meth; @@ -1120,15 +1119,14 @@ BEGIN_EXCEPTION - // TODO: find a better place to store the UTF8 Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); UserClass* methodCl = 0; JavaMethod* meth = cl->lookupMethod( - name->javaToInternal(cl->classLoader->hashUTF8, 0, name->size), - type->javaToInternal(cl->classLoader->hashUTF8, 0, type->size), true, + name->javaToInternal(vm->hashUTF8, 0, name->size), + type->javaToInternal(vm->hashUTF8, 0, type->size), true, true, methodCl); return (jmethodID)meth; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Wed Oct 8 15:48:07 2008 @@ -889,5 +889,12 @@ isolate->primitiveMap[I_DOUBLE] = isolate->upcalls->OfDouble; isolate->upcalls->initialiseClasspath(bootstrapLoader); + +#if defined(ISOLATE) || defined(ISOLATE_SHARING) + isolate->hashUTF8 = new UTF8Map(&isolate->allocator, + isolate->upcalls->ArrayOfChar); +#else + isolate->hashUTF8 = isolate->bootstrapLoader->hashUTF8; +#endif return isolate; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Wed Oct 8 15:48:07 2008 @@ -272,6 +272,11 @@ /// hashStr - Hash map of java/lang/String objects allocated by this JVM. /// StringMap * hashStr; + + /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared + /// by all class loaders in a no isolation configuration. + /// + UTF8Map* hashUTF8; public: /// Exceptions - These are the only exceptions VMKit will make. Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=57308&r1=57307&r2=57308&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Wed Oct 8 15:48:07 2008 @@ -240,7 +240,7 @@ const Typedef* signature) { if (!signature->isPrimitive()) { - if (obj && !(obj->classOf->isOfTypeName(signature->getName()))) { + if (obj && !(obj->classOf->isOfTypeName(vm, signature->getName()))) { vm->illegalArgumentException("wrong type argument"); } ((JavaObject**)buf)[0] = obj; From nicolas.geoffray at lip6.fr Thu Oct 9 02:50:41 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 09 Oct 2008 09:50:41 -0000 Subject: [vmkit-commits] [vmkit] r57323 - /vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Message-ID: <200810090950.m999ofQG021048@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 9 04:50:39 2008 New Revision: 57323 URL: http://llvm.org/viewvc/llvm-project?rev=57323&view=rev Log: Equality of UTF8 can only be made by looking at the contents. Class loaders may define UTF8s on their own. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57323&r1=57322&r2=57323&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Thu Oct 9 04:50:39 2008 @@ -147,20 +147,9 @@ /// of this. const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const; - /// equals - Returns whether two UTF8s are equals. When the JnJVM executes - /// in single mode, equality is just a pointer comparison. When executing - /// in multiple mode, we compare the contents of the UTF8s. -#if defined(ISOLATE) || defined(ISOLATE_SHARING) bool equals(const UTF8* other) const { - return this == other; - } - - bool lessThan(const UTF8* other) const { - return this < other; - } -#else - bool equals(const UTF8* other) const { - if (size != other->size) return false; + if (other == this) return true; + else if (size != other->size) return false; else return !memcmp(elements, other->elements, size * sizeof(uint16)); } @@ -170,7 +159,6 @@ else return memcmp((const char*)elements, (const char*)other->elements, size * sizeof(uint16)) < 0; } -#endif /// print - Prints the UTF8 for debugging purposes. virtual void print(mvm::PrintBuffer* buf) const; From nicolas.geoffray at lip6.fr Fri Oct 10 05:51:55 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 10 Oct 2008 12:51:55 -0000 Subject: [vmkit-commits] [vmkit] r57349 - in /vmkit/trunk: include/mvm/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/ lib/Mvm/GCMmap2/ lib/Mvm/Runtime/ lib/N3/Mono/ lib/N3/PNetLib/ lib/N3/VMCore/ tools/jnjvm/ tools/n3-mono/ tools/n3-pnetlib/ tools/vmkit/ Message-ID: <200810101251.m9ACpvvs021031@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 10 07:51:51 2008 New Revision: 57349 URL: http://llvm.org/viewvc/llvm-project?rev=57349&view=rev Log: On the way to isolate llvm::Modules in jnjvm... And when isolation works, we'll be able to call the Verifier. Yay! Modified: vmkit/trunk/include/mvm/JIT.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp 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/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h vmkit/trunk/lib/Mvm/Runtime/Disassembler.cpp vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp vmkit/trunk/lib/Mvm/Runtime/JIT.cpp vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp vmkit/trunk/lib/N3/Mono/MonoMSCorlib.cpp vmkit/trunk/lib/N3/Mono/MonoString.cpp vmkit/trunk/lib/N3/PNetLib/PNetMSCorlib.cpp vmkit/trunk/lib/N3/PNetLib/PNetString.cpp vmkit/trunk/lib/N3/VMCore/BackTrace.cpp vmkit/trunk/lib/N3/VMCore/CLIJit.cpp vmkit/trunk/lib/N3/VMCore/CLIJit.h vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp vmkit/trunk/lib/N3/VMCore/LowerArrayLength.cpp vmkit/trunk/lib/N3/VMCore/N3.cpp vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp vmkit/trunk/lib/N3/VMCore/Opcodes.cpp vmkit/trunk/lib/N3/VMCore/VMCache.cpp vmkit/trunk/lib/N3/VMCore/VMClass.cpp vmkit/trunk/lib/N3/VMCore/VirtualMachine.h vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp vmkit/trunk/tools/jnjvm/Main.cpp vmkit/trunk/tools/n3-mono/Main.cpp vmkit/trunk/tools/n3-pnetlib/Main.cpp vmkit/trunk/tools/vmkit/Launcher.cpp Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Fri Oct 10 07:51:51 2008 @@ -39,9 +39,6 @@ virtual ~JITInfo() {} }; - -namespace jit { - const double MaxDouble = +INFINITY; //1.0 / 0.0; const double MinDouble = -INFINITY;//-1.0 / 0.0; const double MaxLongDouble = 9223372036854775807.0; @@ -61,134 +58,139 @@ const float NaNFloat = NAN; //(float)(((float)0.0) / (float)0.0); const double NaNDouble = NAN; //0.0 / 0.0; -extern llvm::Function* exceptionEndCatch; -extern llvm::Function* exceptionBeginCatch; -extern llvm::Function* unwindResume; -extern llvm::Function* exceptionSelector; -extern llvm::Function* personality; -extern llvm::Function* llvmGetException; - -extern llvm::Function* printFloatLLVM; -extern llvm::Function* printDoubleLLVM; -extern llvm::Function* printLongLLVM; -extern llvm::Function* printIntLLVM; -extern llvm::Function* printObjectLLVM; - -extern llvm::Function* setjmpLLVM; - -extern llvm::Function* func_llvm_fabs_f32; -extern llvm::Function* func_llvm_fabs_f64; -extern llvm::Function* func_llvm_sqrt_f64; -extern llvm::Function* func_llvm_sin_f64; -extern llvm::Function* func_llvm_cos_f64; -extern llvm::Function* func_llvm_tan_f64; -extern llvm::Function* func_llvm_asin_f64; -extern llvm::Function* func_llvm_acos_f64; -extern llvm::Function* func_llvm_atan_f64; -extern llvm::Function* func_llvm_atan2_f64; -extern llvm::Function* func_llvm_exp_f64; -extern llvm::Function* func_llvm_log_f64; -extern llvm::Function* func_llvm_pow_f64; -extern llvm::Function* func_llvm_ceil_f64; -extern llvm::Function* func_llvm_floor_f64; -extern llvm::Function* func_llvm_rint_f64; -extern llvm::Function* func_llvm_cbrt_f64; -extern llvm::Function* func_llvm_cosh_f64; -extern llvm::Function* func_llvm_expm1_f64; -extern llvm::Function* func_llvm_hypot_f64; -extern llvm::Function* func_llvm_log10_f64; -extern llvm::Function* func_llvm_log1p_f64; -extern llvm::Function* func_llvm_sinh_f64; -extern llvm::Function* func_llvm_tanh_f64; - -extern llvm::Function* llvm_memcpy_i32; -extern llvm::Function* llvm_memset_i32; -extern llvm::Function* llvm_atomic_lcs_i8; -extern llvm::Function* llvm_atomic_lcs_i16; -extern llvm::Function* llvm_atomic_lcs_i32; -extern llvm::Function* llvm_atomic_lcs_i64; - -extern llvm::ExecutionEngine* executionEngine; - -extern uint64 getTypeSize(const llvm::Type* type); -extern void AddStandardCompilePasses(llvm::FunctionPassManager*); -extern void runPasses(llvm::Function* func, llvm::FunctionPassManager*); -extern void initialise(); - - -extern mvm::Lock* protectEngine; -extern llvm::ConstantInt* constantInt8Zero; -extern llvm::ConstantInt* constantZero; -extern llvm::ConstantInt* constantOne; -extern llvm::ConstantInt* constantTwo; -extern llvm::ConstantInt* constantThree; -extern llvm::ConstantInt* constantFour; -extern llvm::ConstantInt* constantFive; -extern llvm::ConstantInt* constantSix; -extern llvm::ConstantInt* constantSeven; -extern llvm::ConstantInt* constantEight; -extern llvm::ConstantInt* constantMinusOne; -extern llvm::ConstantInt* constantLongMinusOne; -extern llvm::ConstantInt* constantLongZero; -extern llvm::ConstantInt* constantLongOne; -extern llvm::ConstantInt* constantMinInt; -extern llvm::ConstantInt* constantMaxInt; -extern llvm::ConstantInt* constantMinLong; -extern llvm::ConstantInt* constantMaxLong; -extern llvm::ConstantFP* constantFloatZero; -extern llvm::ConstantFP* constantFloatOne; -extern llvm::ConstantFP* constantFloatTwo; -extern llvm::ConstantFP* constantDoubleZero; -extern llvm::ConstantFP* constantDoubleOne; -extern llvm::ConstantFP* constantMaxIntFloat; -extern llvm::ConstantFP* constantMinIntFloat; -extern llvm::ConstantFP* constantMinLongFloat; -extern llvm::ConstantFP* constantMinLongDouble; -extern llvm::ConstantFP* constantMaxLongFloat; -extern llvm::ConstantFP* constantMaxIntDouble; -extern llvm::ConstantFP* constantMinIntDouble; -extern llvm::ConstantFP* constantMaxLongDouble; -extern llvm::ConstantFP* constantDoubleInfinity; -extern llvm::ConstantFP* constantDoubleMinusInfinity; -extern llvm::ConstantFP* constantFloatInfinity; -extern llvm::ConstantFP* constantFloatMinusInfinity; -extern llvm::ConstantFP* constantFloatMinusZero; -extern llvm::ConstantFP* constantDoubleMinusZero; -extern llvm::Constant* constantPtrNull; -extern llvm::ConstantInt* constantPtrSize; -extern const llvm::PointerType* ptrType; -extern const llvm::PointerType* ptr32Type; -extern const llvm::PointerType* ptrPtrType; -extern const llvm::Type* arrayPtrType; - - -extern llvm::Module *globalModule; -extern llvm::ExistingModuleProvider *globalModuleProvider; -extern mvm::MvmMemoryManager *memoryManager; - -extern int disassemble(unsigned int* addr); - -extern int getBacktrace(void** stack, int size); -extern Code* getCodeFromPointer(void* addr); -extern void addMethodInfo(void* end, Code* c); - -extern uint8 (*llvm_atomic_cmp_swap_i8) ( uint8* ptr, uint8 cmp, uint8 val ); -extern uint16 (*llvm_atomic_cmp_swap_i16) ( uint16* ptr, uint16 cmp, uint16 val ); -extern uint32 (*llvm_atomic_cmp_swap_i32) ( uint32* ptr, uint32 cmp, uint32 val ); -extern uint64 (*llvm_atomic_cmp_swap_i64) ( uint64* ptr, uint64 cmp, uint64 val ); - -extern llvm::GlobalVariable* executionEnvironment; -extern mvm::Thread* (*getExecutionEnvironment)(); -extern void (*setExecutionEnvironment)(mvm::Thread*); +class MvmModule : public llvm::Module { +public: + + MvmModule(const std::string& ModuleID); + + llvm::Function* exceptionEndCatch; + llvm::Function* exceptionBeginCatch; + llvm::Function* unwindResume; + llvm::Function* exceptionSelector; + llvm::Function* personality; + llvm::Function* llvmGetException; + + llvm::Function* printFloatLLVM; + llvm::Function* printDoubleLLVM; + llvm::Function* printLongLLVM; + llvm::Function* printIntLLVM; + llvm::Function* printObjectLLVM; + + llvm::Function* setjmpLLVM; + + llvm::Function* func_llvm_fabs_f32; + llvm::Function* func_llvm_fabs_f64; + llvm::Function* func_llvm_sqrt_f64; + llvm::Function* func_llvm_sin_f64; + llvm::Function* func_llvm_cos_f64; + llvm::Function* func_llvm_tan_f64; + llvm::Function* func_llvm_asin_f64; + llvm::Function* func_llvm_acos_f64; + llvm::Function* func_llvm_atan_f64; + llvm::Function* func_llvm_atan2_f64; + llvm::Function* func_llvm_exp_f64; + llvm::Function* func_llvm_log_f64; + llvm::Function* func_llvm_pow_f64; + llvm::Function* func_llvm_ceil_f64; + llvm::Function* func_llvm_floor_f64; + llvm::Function* func_llvm_rint_f64; + llvm::Function* func_llvm_cbrt_f64; + llvm::Function* func_llvm_cosh_f64; + llvm::Function* func_llvm_expm1_f64; + llvm::Function* func_llvm_hypot_f64; + llvm::Function* func_llvm_log10_f64; + llvm::Function* func_llvm_log1p_f64; + llvm::Function* func_llvm_sinh_f64; + llvm::Function* func_llvm_tanh_f64; + + llvm::Function* llvm_memcpy_i32; + llvm::Function* llvm_memset_i32; + llvm::Function* llvm_atomic_lcs_i8; + llvm::Function* llvm_atomic_lcs_i16; + llvm::Function* llvm_atomic_lcs_i32; + llvm::Function* llvm_atomic_lcs_i64; + + static llvm::ExecutionEngine* executionEngine; + static mvm::Lock* protectEngine; + + static uint64 getTypeSize(const llvm::Type* type); + static void AddStandardCompilePasses(llvm::FunctionPassManager*); + static void runPasses(llvm::Function* func, llvm::FunctionPassManager*); + static void initialise(); + + static llvm::ConstantInt* constantInt8Zero; + static llvm::ConstantInt* constantZero; + static llvm::ConstantInt* constantOne; + static llvm::ConstantInt* constantTwo; + static llvm::ConstantInt* constantThree; + static llvm::ConstantInt* constantFour; + static llvm::ConstantInt* constantFive; + static llvm::ConstantInt* constantSix; + static llvm::ConstantInt* constantSeven; + static llvm::ConstantInt* constantEight; + static llvm::ConstantInt* constantMinusOne; + static llvm::ConstantInt* constantLongMinusOne; + static llvm::ConstantInt* constantLongZero; + static llvm::ConstantInt* constantLongOne; + static llvm::ConstantInt* constantMinInt; + static llvm::ConstantInt* constantMaxInt; + static llvm::ConstantInt* constantMinLong; + static llvm::ConstantInt* constantMaxLong; + static llvm::ConstantFP* constantFloatZero; + static llvm::ConstantFP* constantFloatOne; + static llvm::ConstantFP* constantFloatTwo; + static llvm::ConstantFP* constantDoubleZero; + static llvm::ConstantFP* constantDoubleOne; + static llvm::ConstantFP* constantMaxIntFloat; + static llvm::ConstantFP* constantMinIntFloat; + static llvm::ConstantFP* constantMinLongFloat; + static llvm::ConstantFP* constantMinLongDouble; + static llvm::ConstantFP* constantMaxLongFloat; + static llvm::ConstantFP* constantMaxIntDouble; + static llvm::ConstantFP* constantMinIntDouble; + static llvm::ConstantFP* constantMaxLongDouble; + static llvm::ConstantFP* constantDoubleInfinity; + static llvm::ConstantFP* constantDoubleMinusInfinity; + static llvm::ConstantFP* constantFloatInfinity; + static llvm::ConstantFP* constantFloatMinusInfinity; + static llvm::ConstantFP* constantFloatMinusZero; + static llvm::ConstantFP* constantDoubleMinusZero; + static llvm::Constant* constantPtrNull; + static llvm::ConstantInt* constantPtrSize; + static const llvm::PointerType* ptrType; + static const llvm::PointerType* ptr32Type; + static const llvm::PointerType* ptrPtrType; + static const llvm::Type* arrayPtrType; + + + static llvm::Module *globalModule; + static llvm::ExistingModuleProvider *globalModuleProvider; + static mvm::MvmMemoryManager *memoryManager; + + static int disassemble(unsigned int* addr); + + static int getBacktrace(void** stack, int size); + static Code* getCodeFromPointer(void* addr); + static void addMethodInfo(void* end, Code* c); + + static uint8 (*llvm_atomic_cmp_swap_i8) ( uint8* ptr, uint8 cmp, uint8 val ); + static uint16 (*llvm_atomic_cmp_swap_i16) ( uint16* ptr, uint16 cmp, uint16 val ); + static uint32 (*llvm_atomic_cmp_swap_i32) ( uint32* ptr, uint32 cmp, uint32 val ); + static uint64 (*llvm_atomic_cmp_swap_i64) ( uint64* ptr, uint64 cmp, uint64 val ); + + static llvm::GlobalVariable* executionEnvironment; + static mvm::Thread* (*getExecutionEnvironment)(); + static void (*setExecutionEnvironment)(mvm::Thread*); + +}; // TODO: find what macro for gcc < 4.2 #if 1 #define __sync_bool_compare_and_swap(ptr, cmp, val) \ - (mvm::jit::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), (uint32)(val)) == (uint32)(cmp)) + (mvm::MvmModule::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), (uint32)(val)) == (uint32)(cmp)) #define __sync_val_compare_and_swap(ptr, cmp,val) \ - mvm::jit::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), (uint32)(val)) + mvm::MvmModule::llvm_atomic_cmp_swap_i32((uint32*)(ptr), (uint32)(cmp), (uint32)(val)) #endif -} // end namespace jit } // end namespace mvm Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Fri Oct 10 07:51:51 2008 @@ -103,7 +103,7 @@ ) { Jnjvm* vm = JavaThread::get()->isolate; int* ips[100]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 100); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100); #ifdef ISOLATE_SHARING UserConstantPool* pools[100]; getPools(pools, 100); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Fri Oct 10 07:51:51 2008 @@ -39,7 +39,7 @@ jobject throwable) { Jnjvm* vm = JavaThread::get()->isolate; int** stack = (int**)malloc(sizeof(int*) * 100); - int real_size = mvm::jit::getBacktrace((void**)stack, 100); + int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100); stack[real_size] = 0; JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); uint64 ptr = (uint64)vmThrowable + vm->upcalls->vmDataVMThrowable->ptrOffset; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaBacktrace.cpp Fri Oct 10 07:51:51 2008 @@ -23,7 +23,7 @@ using namespace jnjvm; JavaMethod* JavaJIT::IPToJavaMethod(void* begIp) { - mvm::Code* code = mvm::jit::getCodeFromPointer(begIp); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(begIp); if (code) { JavaMethod* meth = (JavaMethod*)code->getMetaInfo(); if (meth) { @@ -35,10 +35,10 @@ void JavaJIT::printBacktrace() { int* ips[100]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 100); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100); int n = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { JavaMethod* meth = (JavaMethod*)code->getMetaInfo(); if (meth) { @@ -64,11 +64,11 @@ #ifndef ISOLATE_SHARING UserClass* JavaJIT::getCallingClass() { int* ips[10]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 10); int n = 0; int i = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { JavaMethod* meth = (JavaMethod*)code->getMetaInfo(); if (meth) { @@ -85,11 +85,11 @@ UserClass* JavaJIT::getCallingClassWalker() { int* ips[10]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 10); int n = 0; int i = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { JavaMethod* meth = (JavaMethod*)code->getMetaInfo(); if (meth) { @@ -109,11 +109,11 @@ Class* res = 0; int* ips[10]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 10); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 10); int n = 0; int i = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { JavaMethod* meth = (JavaMethod*)code->getMetaInfo(); if (meth) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Oct 10 07:51:51 2008 @@ -101,12 +101,12 @@ lockVar = 0; condVar = 0; virtualVT = 0; - JInfo = 0; } Class::Class() { ctpInfo = 0; staticVT = 0; + JInfo = 0; } Class::~Class() { @@ -263,7 +263,6 @@ this->classLoader = loader; this->array = isArray; this->primitive = false; - this->JInfo = 0; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) this->delegatee = 0; #endif @@ -286,6 +285,7 @@ bytes = B; super = 0; ctpInfo = 0; + JInfo = 0; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) _staticInstance = 0; #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Oct 10 07:51:51 2008 @@ -498,18 +498,6 @@ /// CommonClass(); - mvm::JITInfo* JInfo; - template - Ty *getInfo() { - if (!JInfo) { - JInfo = new Ty(this); - } - - assert((void*)dynamic_cast(JInfo) == (void*)JInfo && - "Invalid concrete type or multiple inheritence for getInfo"); - return static_cast(JInfo); - } - void getDeclaredConstructors(std::vector& res, bool publicOnly); void getDeclaredMethods(std::vector& res, bool publicOnly); void getDeclaredFields(std::vector& res, bool publicOnly); @@ -696,6 +684,18 @@ return &innerClasses; } #endif + + mvm::JITInfo* JInfo; + template + Ty *getInfo() { + if (!JInfo) { + JInfo = new Ty(this); + } + + assert((void*)dynamic_cast(JInfo) == (void*)JInfo && + "Invalid concrete type or multiple inheritence for getInfo"); + return static_cast(JInfo); + } }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Fri Oct 10 07:51:51 2008 @@ -188,7 +188,6 @@ JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader) { ctpSize = reader.readU2(); classDef = cl; - JInfo = 0; ctpRes = new void*[ctpSize]; ctpDef = new sint32[ctpSize]; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Fri Oct 10 07:51:51 2008 @@ -258,7 +258,6 @@ ctpRes = 0; ctpType = 0; ctpDef = 0; - JInfo = 0; } /// JavaConstantPool - Reads the bytecode of the class to get @@ -272,20 +271,7 @@ delete ctpRes; delete ctpDef; delete ctpType; - } - - mvm::JITInfo* JInfo; - template - Ty *getInfo() { - if (!JInfo) { - JInfo = new Ty(this); - } - - assert((void*)dynamic_cast(JInfo) == (void*)JInfo && - "Invalid concrete type or multiple inheritence for getInfo"); - return static_cast(JInfo); - } - + } }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Fri Oct 10 07:51:51 2008 @@ -74,7 +74,7 @@ JITVerifyNull(args[0]); - Value* VT = CallInst::Create(JnjvmModule::GetVTFunction, args[0], "", + Value* VT = CallInst::Create(module->GetVTFunction, args[0], "", currentBlock); std::vector indexes2; //[3]; #ifdef ISOLATE_SHARING @@ -90,11 +90,11 @@ #endif } else { - Value* val = getConstantPoolAt(index, JnjvmModule::VirtualLookupFunction, + Value* val = getConstantPoolAt(index, module->VirtualLookupFunction, Type::Int32Ty, args[0], true); indexes2.push_back(val); #ifdef ISOLATE_SHARING - Value* mul = BinaryOperator::createMul(val, mvm::jit::constantMinusOne, + Value* mul = BinaryOperator::createMul(val, module->constantMinusOne, "", currentBlock); indexesCtp.push_back(mul); #endif @@ -112,7 +112,7 @@ currentBlock); CTP = new LoadInst(CTP, "", currentBlock); - CTP = new BitCastInst(CTP, JnjvmModule::ConstantPoolType, "", currentBlock); + CTP = new BitCastInst(CTP, module->ConstantPoolType, "", currentBlock); args.push_back(CTP); #endif Value* val = invoke(Func, args, "", currentBlock); @@ -121,7 +121,7 @@ if (retType != Type::VoidTy) { push(val, retTypedef->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, false); + push(module->constantZero, false); } } @@ -147,7 +147,7 @@ Function* func = llvmFunction; if (jnjvm) { - mvm::jit::executionEngine->addGlobalMapping(func, natPtr); + module->executionEngine->addGlobalMapping(func, natPtr); return llvmFunction; } @@ -186,7 +186,7 @@ std::vector Args; Args.push_back(lastArg); Args.push_back(isolateLocal); - CallInst::Create(JnjvmModule::ServiceCallStartFunction, Args.begin(), + CallInst::Create(module->ServiceCallStartFunction, Args.begin(), Args.end(), "", currentBlock); BranchInst::Create(endBlock, currentBlock); currentBlock = endBlock; @@ -195,11 +195,11 @@ #endif - Value* buf = llvm::CallInst::Create(JnjvmModule::GetSJLJBufferFunction, + Value* buf = llvm::CallInst::Create(module->GetSJLJBufferFunction, "", currentBlock); - Value* test = llvm::CallInst::Create(mvm::jit::setjmpLLVM, buf, "", + Value* test = llvm::CallInst::Create(module->setjmpLLVM, buf, "", currentBlock); - test = new ICmpInst(ICmpInst::ICMP_EQ, test, mvm::jit::constantZero, "", + test = new ICmpInst(ICmpInst::ICMP_EQ, test, module->constantZero, "", currentBlock); llvm::BranchInst::Create(executeBlock, endBlock, test, currentBlock); @@ -220,19 +220,17 @@ int64_t jniEnv = (int64_t)&(JavaThread::get()->isolate->jniEnv); nativeArgs.push_back( ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, jniEnv), - mvm::jit::ptrType)); + module->ptrType)); uint32 index = 0; if (stat) { #ifdef ISOLATE_SHARING Value* val = getClassCtp(); - Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, + Value* res = CallInst::Create(module->GetClassDelegateeFunction, val, "", currentBlock); nativeArgs.push_back(res); #else - LLVMClassInfo* LCI = - (LLVMClassInfo*)module->getClassInfo(compilingClass); - nativeArgs.push_back(LCI->getDelegatee(this)); + nativeArgs.push_back(module->getJavaClass(compilingClass, this)); #endif index = 2; } else { @@ -263,7 +261,7 @@ if (isSynchro(compilingMethod->access)) endSynchronize(); - llvm::CallInst::Create(JnjvmModule::JniProceedPendingExceptionFunction, "", + llvm::CallInst::Create(module->JniProceedPendingExceptionFunction, "", currentBlock); if (returnType != Type::VoidTy) @@ -281,23 +279,23 @@ void JavaJIT::monitorEnter(Value* obj) { std::vector gep; - gep.push_back(mvm::jit::constantZero); - gep.push_back(JnjvmModule::JavaObjectLockOffsetConstant); + gep.push_back(module->constantZero); + gep.push_back(module->JavaObjectLockOffsetConstant); Value* lockPtr = GetElementPtrInst::Create(obj, gep.begin(), gep.end(), "", currentBlock); - Value* threadId = CallInst::Create(JnjvmModule::GetThreadIDFunction, "", + Value* threadId = CallInst::Create(module->GetThreadIDFunction, "", currentBlock); std::vector atomicArgs; atomicArgs.push_back(lockPtr); - atomicArgs.push_back(mvm::jit::constantZero); + atomicArgs.push_back(module->constantZero); atomicArgs.push_back(threadId); // Do the atomic compare and swap. - Value* atomic = CallInst::Create(mvm::jit::llvm_atomic_lcs_i32, + Value* atomic = CallInst::Create(module->llvm_atomic_lcs_i32, atomicArgs.begin(), atomicArgs.end(), "", currentBlock); - Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, atomic, mvm::jit::constantZero, + Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, atomic, module->constantZero, "", currentBlock); BasicBlock* OK = createBasicBlock("synchronize passed"); @@ -313,7 +311,7 @@ Value* thinMask = ConstantInt::get(Type::Int32Ty, 0x80000000); Value* isThin = BinaryOperator::createAnd(atomic, thinMask, "", currentBlock); - cmp = new ICmpInst(ICmpInst::ICMP_EQ, isThin, mvm::jit::constantZero, "", + cmp = new ICmpInst(ICmpInst::ICMP_EQ, isThin, module->constantZero, "", currentBlock); BranchInst::Create(ThinLockBB, FatLockBB, cmp, currentBlock); @@ -342,7 +340,7 @@ currentBlock = IncCounterBB; // The counter will not overflow, increment it. - Value* Add = BinaryOperator::createAdd(mvm::jit::constantOne, atomic, "", + Value* Add = BinaryOperator::createAdd(module->constantOne, atomic, "", currentBlock); new StoreInst(Add, lockPtr, false, currentBlock); BranchInst::Create(OK, currentBlock); @@ -351,26 +349,26 @@ // The counter will overflow, call this function to create a new lock, // lock it 0x101 times, and pass. - CallInst::Create(JnjvmModule::OverflowThinLockFunction, obj, "", + CallInst::Create(module->OverflowThinLockFunction, obj, "", currentBlock); BranchInst::Create(OK, currentBlock); currentBlock = FatLockBB; // Either it's a fat lock or there is contention. - CallInst::Create(JnjvmModule::AquireObjectFunction, obj, "", currentBlock); + CallInst::Create(module->AquireObjectFunction, obj, "", currentBlock); BranchInst::Create(OK, currentBlock); currentBlock = OK; } void JavaJIT::monitorExit(Value* obj) { std::vector gep; - gep.push_back(mvm::jit::constantZero); - gep.push_back(JnjvmModule::JavaObjectLockOffsetConstant); + gep.push_back(module->constantZero); + gep.push_back(module->JavaObjectLockOffsetConstant); Value* lockPtr = GetElementPtrInst::Create(obj, gep.begin(), gep.end(), "", currentBlock); Value* lock = new LoadInst(lockPtr, "", currentBlock); - Value* threadId = CallInst::Create(JnjvmModule::GetThreadIDFunction, "", + Value* threadId = CallInst::Create(module->GetThreadIDFunction, "", currentBlock); Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, lock, threadId, "", @@ -388,7 +386,7 @@ // Locked once, set zero currentBlock = LockedOnceBB; - new StoreInst(mvm::jit::constantZero, lockPtr, false, currentBlock); + new StoreInst(module->constantZero, lockPtr, false, currentBlock); BranchInst::Create(EndUnlock, currentBlock); currentBlock = NotLockedOnceBB; @@ -396,7 +394,7 @@ Value* thinMask = ConstantInt::get(Type::Int32Ty, 0x80000000); Value* isThin = BinaryOperator::createAnd(lock, thinMask, "", currentBlock); - cmp = new ICmpInst(ICmpInst::ICMP_EQ, isThin, mvm::jit::constantZero, "", + cmp = new ICmpInst(ICmpInst::ICMP_EQ, isThin, module->constantZero, "", currentBlock); BranchInst::Create(ThinLockBB, FatLockBB, cmp, currentBlock); @@ -404,7 +402,7 @@ currentBlock = ThinLockBB; // Decrement the counter. - Value* Sub = BinaryOperator::createSub(lock, mvm::jit::constantOne, "", + Value* Sub = BinaryOperator::createSub(lock, module->constantOne, "", currentBlock); new StoreInst(Sub, lockPtr, false, currentBlock); BranchInst::Create(EndUnlock, currentBlock); @@ -412,7 +410,7 @@ currentBlock = FatLockBB; // Either it's a fat lock or there is contention. - CallInst::Create(JnjvmModule::ReleaseObjectFunction, obj, "", currentBlock); + CallInst::Create(module->ReleaseObjectFunction, obj, "", currentBlock); BranchInst::Create(EndUnlock, currentBlock); currentBlock = EndUnlock; } @@ -421,8 +419,8 @@ Value* JavaJIT::getStaticInstanceCtp() { Value* cl = getClassCtp(); std::vector indexes; //[3]; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(mvm::jit::constantSeven); + indexes.push_back(module->constantZero); + indexes.push_back(module->constantSeven); Value* arg1 = GetElementPtrInst::Create(cl, indexes.begin(), indexes.end(), "", currentBlock); arg1 = new LoadInst(arg1, "", false, currentBlock); @@ -432,11 +430,11 @@ Value* JavaJIT::getClassCtp() { std::vector indexes; //[3]; - indexes.push_back(mvm::jit::constantOne); + indexes.push_back(module->constantOne); Value* arg1 = GetElementPtrInst::Create(ctpCache, indexes.begin(), indexes.end(), "", currentBlock); arg1 = new LoadInst(arg1, "", false, currentBlock); - arg1 = new BitCastInst(arg1, JnjvmModule::JavaClassType, "", currentBlock); + arg1 = new BitCastInst(arg1, module->JavaClassType, "", currentBlock); return arg1; } #endif @@ -447,9 +445,7 @@ obj = llvmFunction->arg_begin(); } else { #ifndef ISOLATE_SHARING - LLVMClassInfo* LCI = - (LLVMClassInfo*)module->getClassInfo(compilingClass); - obj = LCI->getStaticVar(this); + obj = module->getStaticInstance(compilingClass, this); #else obj = getStaticInstanceCtp(); #endif @@ -458,10 +454,10 @@ monitorEnter(obj); #else if (ServiceDomain::isLockableDomain(compilingClass->isolate)) { - llvm::CallInst::Create(JnjvmModule::AquireObjectInSharedDomainFunction, + llvm::CallInst::Create(module->AquireObjectInSharedDomainFunction, obj, "", currentBlock); } else { - llvm::CallInst::Create(JnjvmModule::AquireObjectFunction, + llvm::CallInst::Create(module->AquireObjectFunction, obj, "", currentBlock); } #endif @@ -473,9 +469,7 @@ obj = llvmFunction->arg_begin(); } else { #ifndef ISOLATE_SHARING - LLVMClassInfo* LCI = - (LLVMClassInfo*)module->getClassInfo(compilingClass); - obj = LCI->getStaticVar(this); + obj = module->getStaticInstance(compilingClass, this); #else obj = getStaticInstanceCtp(); #endif @@ -484,10 +478,10 @@ monitorExit(obj); #else if (ServiceDomain::isLockableDomain(compilingClass->isolate)) { - llvm::CallInst::Create(JnjvmModule::ReleaseObjectInSharedDomainFunction, + llvm::CallInst::Create(module->ReleaseObjectInSharedDomainFunction, argsSync.begin(), argsSync.end(), "", currentBlock); } else { - llvm::CallInst::Create(JnjvmModule::ReleaseObjectFunction, argsSync.begin(), + llvm::CallInst::Create(module->ReleaseObjectFunction, argsSync.begin(), argsSync.end(), "", currentBlock); } #endif @@ -541,7 +535,7 @@ doubleLocals.push_back(new AllocaInst(Type::DoubleTy, "", currentBlock)); longLocals.push_back(new AllocaInst(Type::Int64Ty, "", currentBlock)); floatLocals.push_back(new AllocaInst(Type::FloatTy, "", currentBlock)); - objectLocals.push_back(new AllocaInst(JnjvmModule::JavaObjectType, "", + objectLocals.push_back(new AllocaInst(module->JavaObjectType, "", currentBlock)); } @@ -612,7 +606,7 @@ std::vector Args; Args.push_back(args[args.size()- 2]); Args.push_back(isolateLocal); - CallInst::Create(JnjvmModule::ServiceCallStartFunction, Args.begin(), + CallInst::Create(module->ServiceCallStartFunction, Args.begin(), Args.end(), "", currentBlock); BranchInst::Create(endBlock, currentBlock); currentBlock = endBlock; @@ -643,7 +637,7 @@ std::vector Args; Args.push_back(args[args.size() - 1]); Args.push_back(isolateLocal); - CallInst::Create(JnjvmModule::ServiceCallStopFunction, Args.begin(), + CallInst::Create(module->ServiceCallStopFunction, Args.begin(), Args.end(), "", currentBlock); BranchInst::Create(newEndBlock, currentBlock); currentBlock = newEndBlock; @@ -697,7 +691,7 @@ { std::vector args; args.push_back(ConstantInt::get(Type::Int32Ty, (int64_t)compilingMethod)); - llvm::CallInst::Create(JnjvmModule::PrintMethodStartFunction, args.begin(), + llvm::CallInst::Create(module->PrintMethodStartFunction, args.begin(), args.end(), "", currentBlock); } #endif @@ -709,7 +703,7 @@ doubleLocals.push_back(new AllocaInst(Type::DoubleTy, "", currentBlock)); longLocals.push_back(new AllocaInst(Type::Int64Ty, "", currentBlock)); floatLocals.push_back(new AllocaInst(Type::FloatTy, "", currentBlock)); - objectLocals.push_back(new AllocaInst(JnjvmModule::JavaObjectType, "", + objectLocals.push_back(new AllocaInst(module->JavaObjectType, "", currentBlock)); } @@ -779,7 +773,7 @@ std::vector Args; Args.push_back(i); Args.push_back(isolateLocal); - CallInst::Create(JnjvmModule::ServiceCallStartFunction, Args.begin(), + CallInst::Create(module->ServiceCallStartFunction, Args.begin(), Args.end(), "", currentBlock); BranchInst::Create(endBlock, currentBlock); currentBlock = endBlock; @@ -787,7 +781,7 @@ i++; ctpCache = i; #endif - Value* addrCtpCache = new AllocaInst(JnjvmModule::ConstantPoolType, "", + Value* addrCtpCache = new AllocaInst(module->ConstantPoolType, "", currentBlock); /// make it volatile to be sure it's on the stack new StoreInst(ctpCache, addrCtpCache, true, currentBlock); @@ -832,7 +826,7 @@ { std::vector args; args.push_back(ConstantInt::get(Type::Int32Ty, (int64_t)compilingMethod)); - llvm::CallInst::Create(JnjvmModule::PrintMethodEndFunction, args.begin(), + llvm::CallInst::Create(module->PrintMethodEndFunction, args.begin(), args.end(), "", currentBlock); } #endif @@ -848,7 +842,7 @@ std::vector Args; Args.push_back(i); Args.push_back(isolateLocal); - CallInst::Create(JnjvmModule::ServiceCallStopFunction, Args.begin(), + CallInst::Create(module->ServiceCallStopFunction, Args.begin(), Args.end(), "", currentBlock); BranchInst::Create(newEndBlock, currentBlock); currentBlock = newEndBlock; @@ -871,9 +865,9 @@ if (PI == PE) { endExceptionBlock->eraseFromParent(); } else { - CallInst* ptr_eh_ptr = CallInst::Create(JnjvmModule::GetExceptionFunction, + CallInst* ptr_eh_ptr = CallInst::Create(module->GetExceptionFunction, "eh_ptr", endExceptionBlock); - llvm::CallInst::Create(mvm::jit::unwindResume, ptr_eh_ptr, "", + llvm::CallInst::Create(module->unwindResume, ptr_eh_ptr, "", endExceptionBlock); new UnreachableInst(endExceptionBlock); } @@ -905,7 +899,7 @@ unsigned sync = isSynchro(compilingMethod->access) ? 1 : 0; nbe += sync; if (nbe) { - supplLocal = new AllocaInst(JnjvmModule::JavaObjectType, "exceptionVar", + supplLocal = new AllocaInst(module->JavaObjectType, "exceptionVar", currentBlock); } @@ -924,29 +918,28 @@ argsSync.push_back(llvmFunction->arg_begin()); } else { #ifndef ISOLATE_SHARING - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); - Value* arg = LCI->getStaticVar(this); + Value* arg = module->getStaticInstance(compilingClass, this); #else Value* arg = getStaticInstanceCtp(); #endif argsSync.push_back(arg); } - llvm::CallInst::Create(JnjvmModule::ReleaseObjectFunction, argsSync.begin(), argsSync.end(), + llvm::CallInst::Create(module->ReleaseObjectFunction, argsSync.begin(), argsSync.end(), "", synchronizeExceptionBlock); llvm::BranchInst::Create(endExceptionBlock, synchronizeExceptionBlock); - const PointerType* PointerTy_0 = mvm::jit::ptrType; + const PointerType* PointerTy_0 = module->ptrType; std::vector int32_eh_select_params; Instruction* ptr_eh_ptr = - llvm::CallInst::Create(mvm::jit::llvmGetException, "eh_ptr", + llvm::CallInst::Create(module->llvmGetException, "eh_ptr", trySynchronizeExceptionBlock); int32_eh_select_params.push_back(ptr_eh_ptr); Constant* C = ConstantExpr::getCast(Instruction::BitCast, - mvm::jit::personality, PointerTy_0); + module->personality, PointerTy_0); int32_eh_select_params.push_back(C); - int32_eh_select_params.push_back(mvm::jit::constantPtrNull); - llvm::CallInst::Create(mvm::jit::exceptionSelector, + int32_eh_select_params.push_back(module->constantPtrNull); + llvm::CallInst::Create(module->exceptionSelector, int32_eh_select_params.begin(), int32_eh_select_params.end(), "eh_select", trySynchronizeExceptionBlock); @@ -964,7 +957,7 @@ // 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. - mvm::jit::executionEngine->lock.release(); + module->executionEngine->lock.release(); for (uint16 i = 0; i < nbe - sync; ++i) { Exception* ex = new Exception(); ex->startpc = reader.readU2(); @@ -1017,7 +1010,7 @@ exceptions.push_back(ex); } - mvm::jit::executionEngine->lock.acquire(); + module->executionEngine->lock.acquire(); bool first = true; for (std::vector::iterator i = exceptions.begin(), @@ -1035,7 +1028,7 @@ cur->realTest = cur->test; } - cur->exceptionPHI = llvm::PHINode::Create(mvm::jit::ptrType, "", + cur->exceptionPHI = llvm::PHINode::Create(module->ptrType, "", cur->realTest); if (next && cur->startpc == next->startpc && cur->endpc == next->endpc) @@ -1067,16 +1060,16 @@ } if (cur->realTest != cur->test) { - const PointerType* PointerTy_0 = mvm::jit::ptrType; + const PointerType* PointerTy_0 = module->ptrType; std::vector int32_eh_select_params; Instruction* ptr_eh_ptr = - llvm::CallInst::Create(mvm::jit::llvmGetException, "eh_ptr", cur->test); + llvm::CallInst::Create(module->llvmGetException, "eh_ptr", cur->test); int32_eh_select_params.push_back(ptr_eh_ptr); Constant* C = ConstantExpr::getCast(Instruction::BitCast, - mvm::jit::personality, PointerTy_0); + module->personality, PointerTy_0); int32_eh_select_params.push_back(C); - int32_eh_select_params.push_back(mvm::jit::constantPtrNull); - llvm::CallInst::Create(mvm::jit::exceptionSelector, + int32_eh_select_params.push_back(module->constantPtrNull); + llvm::CallInst::Create(module->exceptionSelector, int32_eh_select_params.begin(), int32_eh_select_params.end(), "eh_select", cur->test); @@ -1090,31 +1083,30 @@ // 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); - else cl = CallInst::Create(JnjvmModule::GetJnjvmExceptionClassFunction, + else cl = CallInst::Create(module->GetJnjvmExceptionClassFunction, isolateLocal, "", currentBlock); #else assert(cur->catchClass); - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(cur->catchClass); - cl = LCI->getVar(this); + cl = module->getNativeClass(cur->catchClass, this); #endif - Value* cmp = llvm::CallInst::Create(JnjvmModule::CompareExceptionFunction, cl, "", + Value* cmp = llvm::CallInst::Create(module->CompareExceptionFunction, cl, "", currentBlock); llvm::BranchInst::Create(cur->handler, bbNext, cmp, currentBlock); if (nodeNext) nodeNext->addIncoming(cur->exceptionPHI, currentBlock); if (cur->handler->empty()) { - cur->handlerPHI = llvm::PHINode::Create(mvm::jit::ptrType, "", + cur->handlerPHI = llvm::PHINode::Create(module->ptrType, "", cur->handler); cur->handlerPHI->addIncoming(cur->exceptionPHI, currentBlock); - Value* exc = llvm::CallInst::Create(JnjvmModule::GetJavaExceptionFunction, + Value* exc = llvm::CallInst::Create(module->GetJavaExceptionFunction, "", cur->handler); - llvm::CallInst::Create(JnjvmModule::ClearExceptionFunction, "", + llvm::CallInst::Create(module->ClearExceptionFunction, "", cur->handler); - llvm::CallInst::Create(mvm::jit::exceptionBeginCatch, cur->handlerPHI, + llvm::CallInst::Create(module->exceptionBeginCatch, cur->handlerPHI, "tmp8", cur->handler); std::vector void_28_params; - llvm::CallInst::Create(mvm::jit::exceptionEndCatch, + llvm::CallInst::Create(module->exceptionEndCatch, void_28_params.begin(), void_28_params.end(), "", cur->handler); new StoreInst(exc, supplLocal, false, cur->handler); @@ -1136,9 +1128,9 @@ } void JavaJIT::compareFP(Value* val1, Value* val2, const Type* ty, bool l) { - Value* one = mvm::jit::constantOne; - Value* zero = mvm::jit::constantZero; - Value* minus = mvm::jit::constantMinusOne; + Value* one = module->constantOne; + Value* zero = module->constantZero; + Value* minus = module->constantMinusOne; Value* c = new FCmpInst(FCmpInst::FCMP_UGT, val1, val2, "", currentBlock); Value* r = llvm::SelectInst::Create(c, one, zero, "", currentBlock); @@ -1158,14 +1150,13 @@ if (type == JavaConstantPool::ConstantString) { #if defined(ISOLATE) || defined(ISOLATE_SHARING) // Lookup the constant pool cache - Value* val = getConstantPoolAt(index, JnjvmModule::StringLookupFunction, - JnjvmModule::JavaObjectType, 0, false); + Value* val = getConstantPoolAt(index, module->StringLookupFunction, + module->JavaObjectType, 0, false); push(val, false); #else const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); - LLVMStringInfo* LSI = module->getStringInfo(str); - Value* val = LSI->getDelegatee(this); + Value* val = module->getString(str, this); push(val, false); #endif @@ -1185,12 +1176,11 @@ #if !defined(ISOLATE) if (ctpInfo->ctpRes[index]) { CommonClass* cl = (CommonClass*)(ctpInfo->ctpRes[index]); - LLVMCommonClassInfo* LCI = module->getClassInfo(cl); - push(LCI->getDelegatee(this), false); + push(module->getJavaClass(cl, this), false); } else { #endif Value* val = getResolvedClass(index, false); - Value* res = CallInst::Create(JnjvmModule::GetClassDelegateeFunction, + Value* res = CallInst::Create(module->GetClassDelegateeFunction, val, "", currentBlock); push(res, false); #if !defined(ISOLATE) @@ -1204,7 +1194,7 @@ void JavaJIT::JITVerifyNull(Value* obj) { JavaJIT* jit = this; - Constant* zero = JnjvmModule::JavaObjectNullConstant; + Constant* zero = module->JavaObjectNullConstant; Value* test = new ICmpInst(ICmpInst::ICMP_EQ, obj, zero, "", jit->currentBlock); @@ -1214,12 +1204,12 @@ llvm::BranchInst::Create(exit, cont, test, jit->currentBlock); std::vector args; if (currentExceptionBlock != endExceptionBlock) { - llvm::InvokeInst::Create(JnjvmModule::NullPointerExceptionFunction, + llvm::InvokeInst::Create(module->NullPointerExceptionFunction, unifiedUnreachable, currentExceptionBlock, args.begin(), args.end(), "", exit); } else { - llvm::CallInst::Create(JnjvmModule::NullPointerExceptionFunction, + llvm::CallInst::Create(module->NullPointerExceptionFunction, args.begin(), args.end(), "", exit); new UnreachableInst(exit); } @@ -1252,12 +1242,12 @@ args.push_back(obj); args.push_back(index); if (currentExceptionBlock != endExceptionBlock) { - llvm::InvokeInst::Create(JnjvmModule::IndexOutOfBoundsExceptionFunction, + llvm::InvokeInst::Create(module->IndexOutOfBoundsExceptionFunction, unifiedUnreachable, currentExceptionBlock, args.begin(), args.end(), "", ifFalse); } else { - llvm::CallInst::Create(JnjvmModule::IndexOutOfBoundsExceptionFunction, + llvm::CallInst::Create(module->IndexOutOfBoundsExceptionFunction, args.begin(), args.end(), "", ifFalse); new UnreachableInst(ifFalse); } @@ -1265,12 +1255,12 @@ currentBlock = ifTrue; } - Constant* zero = mvm::jit::constantZero; + Constant* zero = module->constantZero; Value* val = new BitCastInst(obj, arrayType, "", currentBlock); std::vector indexes; //[3]; indexes.push_back(zero); - indexes.push_back(JnjvmModule::JavaArrayElementsOffsetConstant); + indexes.push_back(module->JavaArrayElementsOffsetConstant); indexes.push_back(index); Value* ptr = llvm::GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), @@ -1287,7 +1277,7 @@ for (BasicBlock::iterator i = newBlock->begin(), e = newBlock->end(); i != e; ++i, ++index) { // case 2 happens with handlers - if (!(isa(i)) || i->getType() == mvm::jit::ptrType) { + if (!(isa(i)) || i->getType() == module->ptrType) { break; } else { const llvm::Type* type = i->getType(); @@ -1404,8 +1394,8 @@ if (name->equals(Jnjvm::abs)) { const Type* Ty = args[0]->getType(); if (Ty == Type::Int32Ty) { - Constant* const_int32_9 = mvm::jit::constantZero; - ConstantInt* const_int32_10 = mvm::jit::constantMinusOne; + Constant* const_int32_9 = module->constantZero; + ConstantInt* const_int32_10 = module->constantMinusOne; BinaryOperator* int32_tmpneg = BinaryOperator::create(Instruction::Sub, const_int32_9, args[0], "tmpneg", currentBlock); @@ -1415,8 +1405,8 @@ return llvm::SelectInst::Create(int1_abscond, args[0], int32_tmpneg, "abs", currentBlock); } else if (Ty == Type::Int64Ty) { - Constant* const_int64_9 = mvm::jit::constantLongZero; - ConstantInt* const_int64_10 = mvm::jit::constantLongMinusOne; + Constant* const_int64_9 = module->constantLongZero; + ConstantInt* const_int64_10 = module->constantLongMinusOne; BinaryOperator* int64_tmpneg = BinaryOperator::create(Instruction::Sub, const_int64_9, args[0], @@ -1429,78 +1419,78 @@ return llvm::SelectInst::Create(int1_abscond, args[0], int64_tmpneg, "abs", currentBlock); } else if (Ty == Type::FloatTy) { - return llvm::CallInst::Create(mvm::jit::func_llvm_fabs_f32, args[0], + return llvm::CallInst::Create(module->func_llvm_fabs_f32, args[0], "tmp1", currentBlock); } else if (Ty == Type::DoubleTy) { - return llvm::CallInst::Create(mvm::jit::func_llvm_fabs_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_fabs_f64, args[0], "tmp1", currentBlock); } } else if (name->equals(Jnjvm::sqrt)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_sqrt_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_sqrt_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::sin)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_sin_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_sin_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::cos)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_cos_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_cos_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::tan)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_tan_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_tan_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::asin)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_asin_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_asin_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::acos)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_acos_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_acos_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::atan)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_atan_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_atan_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::atan2)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_atan2_f64, + return llvm::CallInst::Create(module->func_llvm_atan2_f64, args.begin(), args.end(), "tmp1", currentBlock); } else if (name->equals(Jnjvm::exp)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_exp_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_exp_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::log)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_log_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_log_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::pow)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_pow_f64, args.begin(), + return llvm::CallInst::Create(module->func_llvm_pow_f64, args.begin(), args.end(), "tmp1", currentBlock); } else if (name->equals(Jnjvm::ceil)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_ceil_f64, args[0], "tmp1", + return llvm::CallInst::Create(module->func_llvm_ceil_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::floor)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_floor_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_floor_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::rint)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_rint_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_rint_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::cbrt)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_cbrt_f64, args[0], "tmp1", + return llvm::CallInst::Create(module->func_llvm_cbrt_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::cosh)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_cosh_f64, args[0], "tmp1", + return llvm::CallInst::Create(module->func_llvm_cosh_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::expm1)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_expm1_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_expm1_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::hypot)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_hypot_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_hypot_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::log10)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_log10_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_log10_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::log1p)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_log1p_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_log1p_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::sinh)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_sinh_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_sinh_f64, args[0], "tmp1", currentBlock); } else if (name->equals(Jnjvm::tanh)) { - return llvm::CallInst::Create(mvm::jit::func_llvm_tanh_f64, args[0], + return llvm::CallInst::Create(module->func_llvm_tanh_f64, args[0], "tmp1", currentBlock); } @@ -1547,7 +1537,7 @@ if (!val) { #if defined(ISOLATE_SHARING) - const Type* Ty = JnjvmModule::ConstantPoolType; + const Type* Ty = module->ConstantPoolType; Constant* Nil = Constant::getNullValue(Ty); GlobalVariable* GV = new GlobalVariable(Ty, false, GlobalValue::ExternalLinkage, Nil, @@ -1564,7 +1554,7 @@ Args.push_back(ctpCache); Args.push_back(ConstantInt::get(Type::Int32Ty, index)); Args.push_back(GV); - res = CallInst::Create(JnjvmModule::SpecialCtpLookupFunction, Args.begin(), + res = CallInst::Create(module->SpecialCtpLookupFunction, Args.begin(), Args.end(), "", falseCl); node->addIncoming(res, falseCl); BranchInst::Create(trueCl, falseCl); @@ -1588,7 +1578,7 @@ if (retType != Type::VoidTy) { push(val, signature->ret->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, false); + push(module->constantZero, false); } } @@ -1621,8 +1611,8 @@ #if defined(ISOLATE_SHARING) Value* newCtpCache = getConstantPoolAt(index, - JnjvmModule::StaticCtpLookupFunction, - JnjvmModule::ConstantPoolType, 0, + module->StaticCtpLookupFunction, + module->ConstantPoolType, 0, false); args.push_back(newCtpCache); #endif @@ -1640,7 +1630,7 @@ if (retType != Type::VoidTy) { push(val, signature->ret->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, false); + push(module->constantZero, false); } } } @@ -1654,18 +1644,16 @@ std::vector Args; #ifdef ISOLATE_SHARING Value* CTP = ctpCache; - Args.push_back(mvm::jit::constantOne); + Args.push_back(module->constantOne); Value* Cl = GetElementPtrInst::Create(CTP, Args.begin(), Args.end(), "", currentBlock); Cl = new LoadInst(Cl, "", currentBlock); - Cl = new BitCastInst(Cl, JnjvmModule::JavaClassType, "", currentBlock); + Cl = new BitCastInst(Cl, module->JavaClassType, "", currentBlock); Args.clear(); #else JavaConstantPool* ctp = compilingClass->ctpInfo; - LLVMConstantPoolInfo* LCPI = module->getConstantPoolInfo(ctp); - Value* CTP = LCPI->getDelegatee(this); - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(compilingClass); - Value* Cl = LCI->getVar(this); + Value* CTP = module->getConstantPool(ctp, this); + Value* Cl = module->getNativeClass(compilingClass, this); #endif Args.push_back(resolver); @@ -1676,15 +1664,15 @@ Value* res = 0; if (doThrow) { - res = invoke(JnjvmModule::GetConstantPoolAtFunction, Args, "", + res = invoke(module->GetConstantPoolAtFunction, Args, "", currentBlock); } else { - res = CallInst::Create(JnjvmModule::GetConstantPoolAtFunction, Args.begin(), + res = CallInst::Create(module->GetConstantPoolAtFunction, Args.begin(), Args.end(), "", currentBlock); } const Type* realType = - JnjvmModule::GetConstantPoolAtFunction->getReturnType(); + module->GetConstantPoolAtFunction->getReturnType(); if (returnType == Type::Int32Ty) { return new PtrToIntInst(res, Type::Int32Ty, "", currentBlock); } else if (returnType != realType) { @@ -1696,11 +1684,11 @@ Value* JavaJIT::getResolvedClass(uint16 index, bool clinit, bool doThrow) { - Value* node = getConstantPoolAt(index, JnjvmModule::ClassLookupFunction, - JnjvmModule::JavaClassType, 0, doThrow); + Value* node = getConstantPoolAt(index, module->ClassLookupFunction, + module->JavaClassType, 0, doThrow); if (clinit) - return invoke(JnjvmModule::InitialisationCheckFunction, node, "", + return invoke(module->InitialisationCheckFunction, node, "", currentBlock); else return node; @@ -1715,27 +1703,27 @@ Value* Cl = 0; if (!cl || !cl->isResolved()) { Cl = getResolvedClass(index, true); - Size = CallInst::Create(JnjvmModule::GetObjectSizeFromClassFunction, Cl, + Size = CallInst::Create(module->GetObjectSizeFromClassFunction, Cl, "", currentBlock); - VT = CallInst::Create(JnjvmModule::GetVTFromClassFunction, Cl, "", + VT = CallInst::Create(module->GetVTFromClassFunction, Cl, "", currentBlock); } else { - LLVMClassInfo* LCI = (LLVMClassInfo*)module->getClassInfo(cl); + LLVMClassInfo* LCI = module->getClassInfo(cl); Size = LCI->getVirtualSize(this); #ifndef ISOLATE_SHARING - VT = LCI->getVirtualTable(this); - Cl = LCI->getVar(this); + VT = module->getVirtualTable(cl, this); + Cl = module->getNativeClass(cl, this); if (!cl->isReady()) { - Cl = invoke(JnjvmModule::InitialisationCheckFunction, Cl, "", + Cl = invoke(module->InitialisationCheckFunction, Cl, "", currentBlock); - CallInst::Create(JnjvmModule::ForceInitialisationCheckFunction, Cl, "", + CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", currentBlock); } #else Cl = getResolvedClass(index, true); - CallInst::Create(JnjvmModule::ForceInitialisationCheckFunction, Cl, "", + CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", currentBlock); - VT = CallInst::Create(JnjvmModule::GetVTFromClassFunction, Cl, "", + VT = CallInst::Create(module->GetVTFromClassFunction, Cl, "", currentBlock); #endif } @@ -1743,17 +1731,17 @@ args.push_back(Size); args.push_back(VT); #ifdef MULTIPLE_GC - args.push_back(CallInst::Create(JnjvmModule::GetCollectorFunction, + args.push_back(CallInst::Create(module->GetCollectorFunction, isolateLocal, "", currentBlock)); #endif - Value* val = invoke(JnjvmModule::JavaObjectAllocateFunction, args, "", + Value* val = invoke(module->JavaObjectAllocateFunction, args, "", currentBlock); // Set the class std::vector gep; - gep.push_back(mvm::jit::constantZero); - gep.push_back(JnjvmModule::JavaObjectClassOffsetConstant); + gep.push_back(module->constantZero); + gep.push_back(module->JavaObjectClassOffsetConstant); Value* GEP = GetElementPtrInst::Create(val, gep.begin(), gep.end(), "", currentBlock); new StoreInst(Cl, GEP, currentBlock); @@ -1763,7 +1751,7 @@ } Value* JavaJIT::arraySize(Value* val) { - return llvm::CallInst::Create(JnjvmModule::ArrayLengthFunction, val, "", + return llvm::CallInst::Create(module->ArrayLengthFunction, val, "", currentBlock); } @@ -1772,7 +1760,7 @@ llvm::Value* objectConvert = new BitCastInst(object, type, "", jit->currentBlock); - Constant* zero = mvm::jit::constantZero; + Constant* zero = jit->module->constantZero; std::vector args; // size = 2 args.push_back(zero); args.push_back(offset); @@ -1796,7 +1784,7 @@ #ifndef ISOLATE_SHARING if (field->classDef->isReady()) { - object = LCI->getStaticVar(this); + object = module->getStaticInstance(field->classDef, this); type = LCI->getStaticType(); return fieldGetter(this, type, object, LFI->getOffset()); } @@ -1810,15 +1798,15 @@ } } - const Type* Pty = mvm::jit::arrayPtrType; - Constant* zero = mvm::jit::constantZero; + const Type* Pty = module->arrayPtrType; + Constant* zero = module->constantZero; - Function* func = stat ? JnjvmModule::StaticFieldLookupFunction : - JnjvmModule::VirtualFieldLookupFunction; + Function* func = stat ? module->StaticFieldLookupFunction : + module->VirtualFieldLookupFunction; const Type* returnType = 0; if (stat) - returnType = mvm::jit::ptrType; + returnType = module->ptrType; else returnType = Type::Int32Ty; @@ -1892,7 +1880,7 @@ push(new LoadInst(ptr, "", currentBlock), sign->isUnsigned()); if (type == Type::Int64Ty || type == Type::DoubleTy) { - push(mvm::jit::constantZero, false); + push(module->constantZero, false); } } @@ -1929,7 +1917,7 @@ push(new LoadInst(ptr, "", currentBlock), sign->isUnsigned()); if (type == Type::Int64Ty || type == Type::DoubleTy) { - push(mvm::jit::constantZero, false); + push(module->constantZero, false); } } @@ -2025,8 +2013,8 @@ JITVerifyNull(args[0]); - Value* zero = mvm::jit::constantZero; - Value* one = mvm::jit::constantOne; + Value* zero = module->constantZero; + Value* one = module->constantOne; #ifndef ISOLATE_SHARING // ok now the cache @@ -2036,11 +2024,11 @@ Value* llvmEnv = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (enveloppe)), - JnjvmModule::EnveloppeType); + module->EnveloppeType); #else Value* llvmEnv = getConstantPoolAt(index, - JnjvmModule::EnveloppeLookupFunction, - JnjvmModule::EnveloppeType, 0, false); + module->EnveloppeLookupFunction, + module->EnveloppeType, 0, false); #endif std::vector args1; @@ -2050,7 +2038,7 @@ "", currentBlock); Value* cache = new LoadInst(cachePtr, "", currentBlock); - Value* cl = CallInst::Create(JnjvmModule::GetClassFunction, args[0], "", + Value* cl = CallInst::Create(module->GetClassFunction, args[0], "", currentBlock); std::vector args3; args3.push_back(zero); @@ -2067,13 +2055,13 @@ BranchInst::Create(ifTrue, ifFalse, cmp, currentBlock); currentBlock = ifFalse; - Value* _meth = invoke(JnjvmModule::InterfaceLookupFunction, cache, args[0], + Value* _meth = invoke(module->InterfaceLookupFunction, cache, args[0], "", ifFalse); Value* meth = new BitCastInst(_meth, virtualPtrType, "", currentBlock); #ifdef ISOLATE_SHARING Value* cache2 = new LoadInst(cachePtr, "", currentBlock); - Value* newCtpCache = CallInst::Create(JnjvmModule::GetCtpCacheNodeFunction, + Value* newCtpCache = CallInst::Create(module->GetCtpCacheNodeFunction, cache2, "", currentBlock); args.push_back(newCtpCache); #endif @@ -2094,7 +2082,7 @@ #ifdef ISOLATE_SHARING args.pop_back(); cache = new LoadInst(cachePtr, "", currentBlock); - newCtpCache = CallInst::Create(JnjvmModule::GetCtpCacheNodeFunction, + newCtpCache = CallInst::Create(module->GetCtpCacheNodeFunction, cache, "", currentBlock); args.push_back(newCtpCache); #endif @@ -2109,7 +2097,7 @@ if (node) { push(node, signature->ret->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { - push(mvm::jit::constantZero, false); + push(module->constantZero, false); } } } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Fri Oct 10 07:51:51 2008 @@ -152,7 +152,7 @@ (int64_t)OpcodeNames[bytecodes[i]])); args.push_back(ConstantInt::get(Type::Int32Ty, (int64_t)i)); args.push_back(ConstantInt::get(Type::Int32Ty, (int64_t)compilingMethod)); - CallInst::Create(JnjvmModule::PrintExecutionFunction, args.begin(), + CallInst::Create(module->PrintExecutionFunction, args.begin(), args.end(), "", currentBlock); } #endif @@ -164,67 +164,67 @@ switch (bytecodes[i]) { case ACONST_NULL : - push(JnjvmModule::JavaObjectNullConstant, false); + push(module->JavaObjectNullConstant, false); break; case ICONST_M1 : - push(mvm::jit::constantMinusOne, false); + push(module->constantMinusOne, false); break; case ICONST_0 : - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case ICONST_1 : - push(mvm::jit::constantOne, false); + push(module->constantOne, false); break; case ICONST_2 : - push(mvm::jit::constantTwo, false); + push(module->constantTwo, false); break; case ICONST_3 : - push(mvm::jit::constantThree, false); + push(module->constantThree, false); break; case ICONST_4 : - push(mvm::jit::constantFour, false); + push(module->constantFour, false); break; case ICONST_5 : - push(mvm::jit::constantFive, false); + push(module->constantFive, false); break; case LCONST_0 : - push(mvm::jit::constantLongZero, false); - push(mvm::jit::constantZero, false); + push(module->constantLongZero, false); + push(module->constantZero, false); break; case LCONST_1 : - push(mvm::jit::constantLongOne, false); - push(mvm::jit::constantZero, false); + push(module->constantLongOne, false); + push(module->constantZero, false); break; case FCONST_0 : - push(mvm::jit::constantFloatZero, false); + push(module->constantFloatZero, false); break; case FCONST_1 : - push(mvm::jit::constantFloatOne, false); + push(module->constantFloatOne, false); break; case FCONST_2 : - push(mvm::jit::constantFloatTwo, false); + push(module->constantFloatTwo, false); break; case DCONST_0 : - push(mvm::jit::constantDoubleZero, false); - push(mvm::jit::constantZero, false); + push(module->constantDoubleZero, false); + push(module->constantZero, false); break; case DCONST_1 : - push(mvm::jit::constantDoubleOne, false); - push(mvm::jit::constantZero, false); + push(module->constantDoubleOne, false); + push(module->constantZero, false); break; case BIPUSH : @@ -249,7 +249,7 @@ case LDC2_W : _ldc(readS2(bytecodes, i)); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case ILOAD : @@ -260,7 +260,7 @@ case LLOAD : push(new LoadInst(longLocals[WREAD_U1(bytecodes, false, i)], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case FLOAD : @@ -271,7 +271,7 @@ case DLOAD : push(new LoadInst(doubleLocals[WREAD_U1(bytecodes, false, i)], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case ALOAD : @@ -298,25 +298,25 @@ case LLOAD_0 : push(new LoadInst(longLocals[0], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case LLOAD_1 : push(new LoadInst(longLocals[1], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case LLOAD_2 : push(new LoadInst(longLocals[2], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case LLOAD_3 : push(new LoadInst(longLocals[3], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case FLOAD_0 : @@ -342,25 +342,25 @@ case DLOAD_0 : push(new LoadInst(doubleLocals[0], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case DLOAD_1 : push(new LoadInst(doubleLocals[1], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case DLOAD_2 : push(new LoadInst(doubleLocals[2], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case DLOAD_3 : push(new LoadInst(doubleLocals[3], "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case ALOAD_0 : @@ -387,7 +387,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArraySInt32Type); + module->JavaArraySInt32Type); push(new LoadInst(ptr, "", currentBlock), false); break; } @@ -396,9 +396,9 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayLongType); + module->JavaArrayLongType); push(new LoadInst(ptr, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -406,7 +406,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayFloatType); + module->JavaArrayFloatType); push(new LoadInst(ptr, "", currentBlock), false); break; } @@ -415,9 +415,9 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayDoubleType); + module->JavaArrayDoubleType); push(new LoadInst(ptr, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -425,7 +425,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayObjectType); + module->JavaArrayObjectType); push(new LoadInst(ptr, "", currentBlock), false); break; } @@ -434,7 +434,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArraySInt8Type); + module->JavaArraySInt8Type); Value* val = new LoadInst(ptr, "", currentBlock); push(new SExtInst(val, Type::Int32Ty, "", currentBlock), false); @@ -445,7 +445,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayUInt16Type); + module->JavaArrayUInt16Type); Value* val = new LoadInst(ptr, "", currentBlock); push(new ZExtInst(val, Type::Int32Ty, "", currentBlock), false); @@ -456,7 +456,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArraySInt16Type); + module->JavaArraySInt16Type); Value* val = new LoadInst(ptr, "", currentBlock); push(new SExtInst(val, Type::Int32Ty, "", currentBlock), false); @@ -601,7 +601,7 @@ Value* index = popAsInt(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArraySInt32Type); + module->JavaArraySInt32Type); new StoreInst(val, ptr, false, currentBlock); break; } @@ -612,7 +612,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayLongType); + module->JavaArrayLongType); new StoreInst(val, ptr, false, currentBlock); break; } @@ -622,7 +622,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayFloatType); + module->JavaArrayFloatType); new StoreInst(val, ptr, false, currentBlock); break; } @@ -633,7 +633,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayDoubleType); + module->JavaArrayDoubleType); new StoreInst(val, ptr, false, currentBlock); break; } @@ -643,7 +643,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayObjectType); + module->JavaArrayObjectType); new StoreInst(val, ptr, false, currentBlock); break; } @@ -656,7 +656,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArraySInt8Type); + module->JavaArraySInt8Type); new StoreInst(val, ptr, false, currentBlock); break; } @@ -672,7 +672,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArrayUInt16Type); + module->JavaArrayUInt16Type); new StoreInst(val, ptr, false, currentBlock); break; } @@ -688,7 +688,7 @@ Value* index = pop(); Value* obj = pop(); Value* ptr = verifyAndComputePtr(obj, index, - JnjvmModule::JavaArraySInt16Type); + module->JavaArraySInt16Type); new StoreInst(val, ptr, false, currentBlock); break; } @@ -785,7 +785,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createAdd(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -804,7 +804,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createAdd(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -822,7 +822,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createSub(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -841,7 +841,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createSub(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -860,7 +860,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createMul(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -879,7 +879,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createMul(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -898,7 +898,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createSDiv(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -917,7 +917,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createFDiv(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -936,7 +936,7 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createSRem(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -955,13 +955,13 @@ llvm::Value* val1 = pop(); push(BinaryOperator::createFRem(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } case INEG : push(BinaryOperator::createSub( - mvm::jit::constantZero, + module->constantZero, popAsInt(), "", currentBlock), false); break; @@ -969,24 +969,24 @@ case LNEG : { pop(); push(BinaryOperator::createSub( - mvm::jit::constantLongZero, + module->constantLongZero, pop(), "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } case FNEG : push(BinaryOperator::createSub( - mvm::jit::constantFloatMinusZero, + module->constantFloatMinusZero, pop(), "", currentBlock), false); break; case DNEG : { pop(); push(BinaryOperator::createSub( - mvm::jit::constantDoubleMinusZero, + module->constantDoubleMinusZero, pop(), "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1004,7 +1004,7 @@ Value* val1 = pop(); push(BinaryOperator::createShl(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1022,7 +1022,7 @@ Value* val1 = pop(); push(BinaryOperator::createAShr(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1044,7 +1044,7 @@ Value* val1 = pop(); push(BinaryOperator::createLShr(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1063,7 +1063,7 @@ Value* val1 = pop(); push(BinaryOperator::createAnd(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1082,7 +1082,7 @@ Value* val1 = pop(); push(BinaryOperator::createOr(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1101,7 +1101,7 @@ Value* val1 = pop(); push(BinaryOperator::createXor(val1, val2, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1119,7 +1119,7 @@ case I2L : push(new SExtInst(pop(), llvm::Type::Int64Ty, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case I2F : @@ -1130,7 +1130,7 @@ case I2D : push(new SIToFPInst(pop(), llvm::Type::DoubleTy, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case L2I : @@ -1149,7 +1149,7 @@ pop(); push(new SIToFPInst(pop(), llvm::Type::DoubleTy, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case F2I : { @@ -1159,7 +1159,7 @@ BasicBlock* res = createBasicBlock("F2I"); PHINode* node = PHINode::Create(llvm::Type::Int32Ty, "", res); - node->addIncoming(mvm::jit::constantZero, currentBlock); + node->addIncoming(module->constantZero, currentBlock); BasicBlock* cont = createBasicBlock("F2I"); BranchInst::Create(res, cont, test, currentBlock); @@ -1167,25 +1167,25 @@ currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OGE, val, - mvm::jit::constantMaxIntFloat, + module->constantMaxIntFloat, "", currentBlock); cont = createBasicBlock("F2I"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMaxInt, + node->addIncoming(module->constantMaxInt, currentBlock); currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OLE, val, - mvm::jit::constantMinIntFloat, + module->constantMinIntFloat, "", currentBlock); cont = createBasicBlock("F2I"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMinInt, currentBlock); + node->addIncoming(module->constantMinInt, currentBlock); currentBlock = cont; llvm::Value* newVal = new FPToSIInst(val, Type::Int32Ty, "", @@ -1207,7 +1207,7 @@ BasicBlock* res = createBasicBlock("F2L"); PHINode* node = PHINode::Create(llvm::Type::Int64Ty, "", res); - node->addIncoming(mvm::jit::constantLongZero, currentBlock); + node->addIncoming(module->constantLongZero, currentBlock); BasicBlock* cont = createBasicBlock("F2L"); BranchInst::Create(res, cont, test, currentBlock); @@ -1215,23 +1215,23 @@ currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OGE, val, - mvm::jit::constantMaxLongFloat, + module->constantMaxLongFloat, "", currentBlock); cont = createBasicBlock("F2L"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMaxLong, currentBlock); + node->addIncoming(module->constantMaxLong, currentBlock); currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OLE, val, - mvm::jit::constantMinLongFloat, "", currentBlock); + module->constantMinLongFloat, "", currentBlock); cont = createBasicBlock("F2L"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMinLong, currentBlock); + node->addIncoming(module->constantMinLong, currentBlock); currentBlock = cont; llvm::Value* newVal = new FPToSIInst(val, Type::Int64Ty, "", @@ -1243,14 +1243,14 @@ currentBlock = res; push(node, false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } case F2D : push(new FPExtInst(pop(), llvm::Type::DoubleTy, "", currentBlock), false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; case D2I : { @@ -1261,7 +1261,7 @@ BasicBlock* res = createBasicBlock("D2I"); PHINode* node = PHINode::Create(llvm::Type::Int32Ty, "", res); - node->addIncoming(mvm::jit::constantZero, currentBlock); + node->addIncoming(module->constantZero, currentBlock); BasicBlock* cont = createBasicBlock("D2I"); BranchInst::Create(res, cont, test, currentBlock); @@ -1269,24 +1269,24 @@ currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OGE, val, - mvm::jit::constantMaxIntDouble, + module->constantMaxIntDouble, "", currentBlock); cont = createBasicBlock("D2I"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMaxInt, currentBlock); + node->addIncoming(module->constantMaxInt, currentBlock); currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OLE, val, - mvm::jit::constantMinIntDouble, + module->constantMinIntDouble, "", currentBlock); cont = createBasicBlock("D2I"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMinInt, currentBlock); + node->addIncoming(module->constantMinInt, currentBlock); currentBlock = cont; llvm::Value* newVal = new FPToSIInst(val, Type::Int32Ty, "", @@ -1310,7 +1310,7 @@ BasicBlock* res = createBasicBlock("D2L"); PHINode* node = PHINode::Create(llvm::Type::Int64Ty, "", res); - node->addIncoming(mvm::jit::constantLongZero, currentBlock); + node->addIncoming(module->constantLongZero, currentBlock); BasicBlock* cont = createBasicBlock("D2L"); BranchInst::Create(res, cont, test, currentBlock); @@ -1318,24 +1318,24 @@ currentBlock = cont; test = new FCmpInst(FCmpInst::FCMP_OGE, val, - mvm::jit::constantMaxLongDouble, + module->constantMaxLongDouble, "", currentBlock); cont = createBasicBlock("D2L"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMaxLong, currentBlock); + node->addIncoming(module->constantMaxLong, currentBlock); currentBlock = cont; test = - new FCmpInst(FCmpInst::FCMP_OLE, val, mvm::jit::constantMinLongDouble, + new FCmpInst(FCmpInst::FCMP_OLE, val, module->constantMinLongDouble, "", currentBlock); cont = createBasicBlock("D2L"); BranchInst::Create(res, cont, test, currentBlock); - node->addIncoming(mvm::jit::constantMinLong, currentBlock); + node->addIncoming(module->constantMinLong, currentBlock); currentBlock = cont; llvm::Value* newVal = new FPToSIInst(val, Type::Int64Ty, "", @@ -1347,7 +1347,7 @@ currentBlock = res; push(node, false); - push(mvm::jit::constantZero, false); + push(module->constantZero, false); break; } @@ -1399,18 +1399,18 @@ BasicBlock* cont = createBasicBlock("LCMP"); BasicBlock* res = createBasicBlock("LCMP"); PHINode* node = PHINode::Create(llvm::Type::Int32Ty, "", res); - node->addIncoming(mvm::jit::constantZero, currentBlock); + node->addIncoming(module->constantZero, currentBlock); BranchInst::Create(res, cont, test, currentBlock); currentBlock = cont; test = new ICmpInst(ICmpInst::ICMP_SLT, val1, val2, "", currentBlock); - node->addIncoming(mvm::jit::constantMinusOne, currentBlock); + node->addIncoming(module->constantMinusOne, currentBlock); cont = createBasicBlock("LCMP"); BranchInst::Create(res, cont, test, currentBlock); currentBlock = cont; - node->addIncoming(mvm::jit::constantOne, currentBlock); + node->addIncoming(module->constantOne, currentBlock); BranchInst::Create(res, currentBlock); currentBlock = res; @@ -1654,7 +1654,7 @@ Value* expr = ConstantExpr::getIntToPtr( ConstantInt::get(Type::Int64Ty, uint64_t (jsrIndex++)), - JnjvmModule::JavaObjectType); + module->JavaObjectType); new StoreInst(expr, supplLocal, false, currentBlock); BranchInst::Create(opcodeInfos[tmp + readS2(bytecodes, i)].newBlock, @@ -1832,7 +1832,7 @@ UserClassArray* dcl = 0; #endif ConstantInt* sizeElement = 0; - GlobalVariable* TheVT = 0; + Value* TheVT = 0; Value* valCl = 0; if (bytecodes[i] == NEWARRAY) { @@ -1844,11 +1844,10 @@ std::vector args; args.push_back(isolateLocal); args.push_back(ConstantInt::get(Type::Int32Ty, id - 4)); - valCl = CallInst::Create(JnjvmModule::GetJnjvmArrayClassFunction, + valCl = CallInst::Create(module->GetJnjvmArrayClassFunction, args.begin(), args.end(), "", currentBlock); #endif - TheVT = JnjvmModule::JavaObjectVirtualTableGV; LLVMAssessorInfo& LAI = LLVMAssessorInfo::AssessorInfo[charId]; sizeElement = LAI.sizeInBytesConstant; } else { @@ -1864,20 +1863,19 @@ #else valCl = getResolvedClass(index, false); - valCl = CallInst::Create(JnjvmModule::GetArrayClassFunction, valCl, + valCl = CallInst::Create(module->GetArrayClassFunction, valCl, "", currentBlock); #endif - TheVT = JnjvmModule::ArrayObjectVirtualTableGV; - sizeElement = mvm::jit::constantPtrSize; + sizeElement = module->constantPtrSize; } #ifndef ISOLATE_SHARING - LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); - valCl = LCI->getVar(this); + valCl = module->getNativeClass(dcl, this); + TheVT = module->getVirtualTable(dcl, this); #endif llvm::Value* arg1 = popAsInt(); Value* cmp = new ICmpInst(ICmpInst::ICMP_SLT, arg1, - mvm::jit::constantZero, "", currentBlock); + module->constantZero, "", currentBlock); BasicBlock* BB1 = createBasicBlock(""); BasicBlock* BB2 = createBasicBlock(""); @@ -1887,19 +1885,19 @@ std::vector exArgs; exArgs.push_back(arg1); if (currentExceptionBlock != endExceptionBlock) { - InvokeInst::Create(JnjvmModule::NegativeArraySizeExceptionFunction, + InvokeInst::Create(module->NegativeArraySizeExceptionFunction, unifiedUnreachable, currentExceptionBlock, exArgs.begin(), exArgs.end(), "", currentBlock); } else { - CallInst::Create(JnjvmModule::NegativeArraySizeExceptionFunction, + CallInst::Create(module->NegativeArraySizeExceptionFunction, exArgs.begin(), exArgs.end(), "", currentBlock); new UnreachableInst(currentBlock); } currentBlock = BB2; cmp = new ICmpInst(ICmpInst::ICMP_SGT, arg1, - JnjvmModule::MaxArraySizeConstant, + module->MaxArraySizeConstant, "", currentBlock); BB1 = createBasicBlock(""); @@ -1908,12 +1906,12 @@ BranchInst::Create(BB1, BB2, cmp, currentBlock); currentBlock = BB1; if (currentExceptionBlock != endExceptionBlock) { - InvokeInst::Create(JnjvmModule::OutOfMemoryErrorFunction, + InvokeInst::Create(module->OutOfMemoryErrorFunction, unifiedUnreachable, currentExceptionBlock, exArgs.begin(), exArgs.end(), "", currentBlock); } else { - CallInst::Create(JnjvmModule::OutOfMemoryErrorFunction, + CallInst::Create(module->OutOfMemoryErrorFunction, exArgs.begin(), exArgs.end(), "", currentBlock); new UnreachableInst(currentBlock); } @@ -1922,32 +1920,32 @@ Value* mult = BinaryOperator::createMul(arg1, sizeElement, "", currentBlock); Value* size = - BinaryOperator::createAdd(JnjvmModule::JavaObjectSizeConstant, mult, + BinaryOperator::createAdd(module->JavaObjectSizeConstant, mult, "", currentBlock); std::vector args; args.push_back(size); - args.push_back(new LoadInst(TheVT, "", currentBlock)); + args.push_back(TheVT); #ifdef MULTIPLE_GC - args.push_back(CallInst::Create(JnjvmModule::GetCollectorFunction, + args.push_back(CallInst::Create(module->GetCollectorFunction, isolateLocal, "", currentBlock)); #endif - Value* res = invoke(JnjvmModule::JavaObjectAllocateFunction, args, "", + Value* res = invoke(module->JavaObjectAllocateFunction, args, "", currentBlock); - Value* cast = new BitCastInst(res, JnjvmModule::JavaArrayType, "", + Value* cast = new BitCastInst(res, module->JavaArrayType, "", currentBlock); // Set the size std::vector gep4; - gep4.push_back(mvm::jit::constantZero); - gep4.push_back(JnjvmModule::JavaArraySizeOffsetConstant); + gep4.push_back(module->constantZero); + gep4.push_back(module->JavaArraySizeOffsetConstant); Value* GEP = GetElementPtrInst::Create(cast, gep4.begin(), gep4.end(), "", currentBlock); new StoreInst(arg1, GEP, currentBlock); // Set the class std::vector gep; - gep.push_back(mvm::jit::constantZero); - gep.push_back(JnjvmModule::JavaObjectClassOffsetConstant); + gep.push_back(module->constantZero); + gep.push_back(module->JavaObjectClassOffsetConstant); GEP = GetElementPtrInst::Create(res, gep.begin(), gep.end(), "", currentBlock); new StoreInst(valCl, GEP, currentBlock); @@ -1969,12 +1967,12 @@ std::vector args; args.push_back(arg); if (currentExceptionBlock != endExceptionBlock) { - InvokeInst::Create(JnjvmModule::ThrowExceptionFunction, + InvokeInst::Create(module->ThrowExceptionFunction, unifiedUnreachable, currentExceptionBlock, args.begin(), args.end(), "", currentBlock); } else { - CallInst::Create(JnjvmModule::ThrowExceptionFunction, args.begin(), + CallInst::Create(module->ThrowExceptionFunction, args.begin(), args.end(), "", currentBlock); new UnreachableInst(currentBlock); } @@ -1991,7 +1989,7 @@ Value* obj = top(); Value* cmp = new ICmpInst(ICmpInst::ICMP_EQ, obj, - JnjvmModule::JavaObjectNullConstant, + module->JavaObjectNullConstant, "", currentBlock); BasicBlock* ifTrue = createBasicBlock("null checkcast"); @@ -2002,8 +2000,7 @@ Value* clVar = 0; #ifndef ISOLATE_SHARING if (dcl) { - LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); - clVar = LCI->getVar(this); + clVar = module->getNativeClass(dcl, this); } else #endif clVar = getResolvedClass(index, false); @@ -2011,7 +2008,7 @@ std::vector args; args.push_back(obj); args.push_back(clVar); - Value* call = CallInst::Create(JnjvmModule::InstanceOfFunction, + Value* call = CallInst::Create(module->InstanceOfFunction, args.begin(), args.end(), "", currentBlock); @@ -2022,12 +2019,12 @@ exArgs.push_back(obj); exArgs.push_back(clVar); if (currentExceptionBlock != endExceptionBlock) { - InvokeInst::Create(JnjvmModule::ClassCastExceptionFunction, + InvokeInst::Create(module->ClassCastExceptionFunction, unifiedUnreachable, currentExceptionBlock, exArgs.begin(), exArgs.end(), "", ex); } else { - CallInst::Create(JnjvmModule::ClassCastExceptionFunction, + CallInst::Create(module->ClassCastExceptionFunction, exArgs.begin(), exArgs.end(), "", ex); new UnreachableInst(ex); } @@ -2044,8 +2041,7 @@ Value* clVar = 0; if (dcl) { - LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); - clVar = LCI->getVar(this); + clVar = module->getNativeClass(dcl, this); } else { clVar = getResolvedClass(index, false); } @@ -2055,7 +2051,7 @@ std::vector args; args.push_back(pop()); args.push_back(clVar); - Value* val = CallInst::Create(JnjvmModule::InstanceOfFunction, + Value* val = CallInst::Create(module->InstanceOfFunction, args.begin(), args.end(), "", currentBlock); push(new ZExtInst(val, Type::Int32Ty, "", currentBlock), @@ -2067,10 +2063,10 @@ Value* obj = pop(); #ifdef SERVICE_VM if (ServiceDomain::isLockableDomain(compilingClass->isolate)) - invoke(JnjvmModule::AquireObjectInSharedDomainFunction, obj, "", + invoke(module->AquireObjectInSharedDomainFunction, obj, "", currentBlock); else - invoke(JnjvmModule::AquireObjectFunction, obj, "", + invoke(module->AquireObjectFunction, obj, "", currentBlock); #else JITVerifyNull(obj); @@ -2083,10 +2079,10 @@ Value* obj = pop(); #ifdef SERVICE_VM if (ServiceDomain::isLockableDomain(compilingClass->isolate)) - invoke(JnjvmModule::ReleaseObjectInSharedDomainFunction, obj, "", + invoke(module->ReleaseObjectInSharedDomainFunction, obj, "", currentBlock); else - invoke(JnjvmModule::ReleaseObjectFunction, obj, "", + invoke(module->ReleaseObjectFunction, obj, "", currentBlock); #else JITVerifyNull(obj); @@ -2110,8 +2106,7 @@ UserClassArray* dcl = JCL->constructArray(className); compilingClass->ctpInfo->loadClass(index); - LLVMCommonClassInfo* LCI = module->getClassInfo(dcl); - Value* valCl = LCI->getVar(this); + Value* valCl = module->getNativeClass(dcl ,this); #endif Value** args = (Value**)alloca(sizeof(Value*) * (dim + 2)); args[0] = valCl; @@ -2124,7 +2119,7 @@ for (sint32 v = 0; v < dim + 2; ++v) { Args.push_back(args[v]); } - push(invoke(JnjvmModule::MultiCallNewFunction, Args, "", currentBlock), + push(invoke(module->MultiCallNewFunction, Args, "", currentBlock), false); break; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Oct 10 07:51:51 2008 @@ -40,9 +40,9 @@ JnjvmBootstrapLoader* JnjvmBootstrapLoader::createBootstrapLoader() { JnjvmBootstrapLoader* JCL = gc_new(JnjvmBootstrapLoader)(); + JnjvmModule::initialise(); JCL->TheModule = new JnjvmModule("Bootstrap JnJVM"); JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule); - JCL->TheModule->initialise(); JCL->allocator = new JavaAllocator(); @@ -70,16 +70,16 @@ JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* I) { - TheModule = JCL.TheModule; - TheModuleProvider = JCL.TheModuleProvider; + TheModule = new JnjvmModule("Applicative loader"); + TheModuleProvider = new JnjvmModuleProvider(TheModule); bootstrapLoader = JCL.bootstrapLoader; allocator = &(isolate->allocator); - hashUTF8 = JCL.hashUTF8; + hashUTF8 = new UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); classes = allocator_new(allocator, ClassMap)(); - javaTypes = JCL.javaTypes; - javaSignatures = JCL.javaSignatures; + javaTypes = new TypeMap(); + javaSignatures = new SignMap(); javaLoader = loader; isolate = I; @@ -388,10 +388,10 @@ } JnjvmClassLoader::~JnjvmClassLoader() { - /*delete hashUTF8; + delete hashUTF8; delete javaTypes; delete javaSignatures; - delete TheModuleProvider;*/ + delete TheModuleProvider; } void JnjvmBootstrapLoader::analyseClasspathEnv(const char* str) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Oct 10 07:51:51 2008 @@ -52,8 +52,6 @@ llvm::Constant* JnjvmModule::JavaClassNullConstant; llvm::Constant* JnjvmModule::MaxArraySizeConstant; llvm::Constant* JnjvmModule::JavaObjectSizeConstant; -llvm::GlobalVariable* JnjvmModule::JavaObjectVirtualTableGV; -llvm::GlobalVariable* JnjvmModule::ArrayObjectVirtualTableGV; llvm::ConstantInt* JnjvmModule::OffsetObjectSizeInClassConstant; llvm::ConstantInt* JnjvmModule::OffsetVTInClassConstant; llvm::ConstantInt* JnjvmModule::OffsetDepthInClassConstant; @@ -67,90 +65,11 @@ llvm::ConstantInt* JnjvmModule::JavaObjectLockOffsetConstant; llvm::ConstantInt* JnjvmModule::JavaObjectClassOffsetConstant; -#ifdef WITH_TRACER -llvm::Function* JnjvmModule::MarkAndTraceFunction = 0; -llvm::Function* JnjvmModule::JavaObjectTracerFunction = 0; -#endif -llvm::Function* JnjvmModule::GetSJLJBufferFunction = 0; -llvm::Function* JnjvmModule::ThrowExceptionFunction = 0; -llvm::Function* JnjvmModule::GetExceptionFunction = 0; -llvm::Function* JnjvmModule::GetJavaExceptionFunction = 0; -llvm::Function* JnjvmModule::ClearExceptionFunction = 0; -llvm::Function* JnjvmModule::CompareExceptionFunction = 0; -llvm::Function* JnjvmModule::NullPointerExceptionFunction = 0; -llvm::Function* JnjvmModule::ClassCastExceptionFunction = 0; -llvm::Function* JnjvmModule::IndexOutOfBoundsExceptionFunction = 0; -llvm::Function* JnjvmModule::NegativeArraySizeExceptionFunction = 0; -llvm::Function* JnjvmModule::OutOfMemoryErrorFunction = 0; -llvm::Function* JnjvmModule::JavaObjectAllocateFunction = 0; -llvm::Function* JnjvmModule::InterfaceLookupFunction = 0; -llvm::Function* JnjvmModule::StaticFieldLookupFunction = 0; -llvm::Function* JnjvmModule::VirtualFieldLookupFunction = 0; -#ifndef WITHOUT_VTABLE -llvm::Function* JnjvmModule::VirtualLookupFunction = 0; -#endif -llvm::Function* JnjvmModule::PrintExecutionFunction = 0; -llvm::Function* JnjvmModule::PrintMethodStartFunction = 0; -llvm::Function* JnjvmModule::PrintMethodEndFunction = 0; -llvm::Function* JnjvmModule::JniProceedPendingExceptionFunction = 0; -llvm::Function* JnjvmModule::InitialisationCheckFunction = 0; -llvm::Function* JnjvmModule::ForceInitialisationCheckFunction = 0; -llvm::Function* JnjvmModule::ClassLookupFunction = 0; -llvm::Function* JnjvmModule::InstanceOfFunction = 0; -llvm::Function* JnjvmModule::IsAssignableFromFunction = 0; -llvm::Function* JnjvmModule::ImplementsFunction = 0; -llvm::Function* JnjvmModule::InstantiationOfArrayFunction = 0; -llvm::Function* JnjvmModule::GetDepthFunction = 0; -llvm::Function* JnjvmModule::GetDisplayFunction = 0; -llvm::Function* JnjvmModule::GetClassInDisplayFunction = 0; -llvm::Function* JnjvmModule::AquireObjectFunction = 0; -llvm::Function* JnjvmModule::ReleaseObjectFunction = 0; -llvm::Function* JnjvmModule::MultiCallNewFunction = 0; -llvm::Function* JnjvmModule::GetConstantPoolAtFunction = 0; - -#ifdef ISOLATE -llvm::Function* JnjvmModule::StringLookupFunction = 0; - -#ifdef ISOLATE_SHARING -llvm::Function* JnjvmModule::GetCtpCacheNodeFunction = 0; -llvm::Function* JnjvmModule::GetCtpClassFunction = 0; -llvm::Function* JnjvmModule::EnveloppeLookupFunction = 0; -llvm::Function* JnjvmModule::GetJnjvmExceptionClassFunction = 0; -llvm::Function* JnjvmModule::GetJnjvmArrayClassFunction = 0; -llvm::Function* JnjvmModule::StaticCtpLookupFunction = 0; -llvm::Function* JnjvmModule::GetArrayClassFunction = 0; -llvm::Function* JnjvmModule::SpecialCtpLookupFunction = 0; -#endif - -#endif - -llvm::Function* JnjvmModule::GetClassDelegateeFunction = 0; -llvm::Function* JnjvmModule::ArrayLengthFunction = 0; -llvm::Function* JnjvmModule::GetVTFunction = 0; -llvm::Function* JnjvmModule::GetClassFunction = 0; -llvm::Function* JnjvmModule::GetVTFromClassFunction = 0; -llvm::Function* JnjvmModule::GetObjectSizeFromClassFunction = 0; - -#ifdef MULTIPLE_GC -llvm::Function* JnjvmModule::GetCollectorFunction = 0; -#endif - -#ifdef SERVICE_VM -llvm::Function* JnjvmModule::AquireObjectInSharedDomainFunction = 0; -llvm::Function* JnjvmModule::ReleaseObjectInSharedDomainFunction = 0; -llvm::Function* JnjvmModule::ServiceCallStartFunction = 0; -llvm::Function* JnjvmModule::ServiceCallStopFunction = 0; -#endif - -llvm::Function* JnjvmModule::GetThreadIDFunction = 0; -llvm::Function* JnjvmModule::GetLockFunction = 0; -llvm::Function* JnjvmModule::OverflowThinLockFunction = 0; - - - -Value* LLVMCommonClassInfo::getVar(JavaJIT* jit) { - if (!varGV) { - +Value* JnjvmModule::getNativeClass(CommonClass* classDef, JavaJIT* jit) { + llvm::GlobalVariable* varGV = 0; + native_class_iterator End = nativeClasses.end(); + native_class_iterator I = nativeClasses.find(classDef); + if (I == End) { Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (classDef)), @@ -158,43 +77,119 @@ varGV = new GlobalVariable(JnjvmModule::JavaClassType, true, GlobalValue::ExternalLinkage, - cons, "", - classDef->classLoader->TheModule); - } + cons, "", this); + + nativeClasses.insert(std::make_pair(classDef, varGV)); + } else { + varGV = I->second; + } return new LoadInst(varGV, "", jit->currentBlock); } -Value* LLVMConstantPoolInfo::getDelegatee(JavaJIT* jit) { - if (!delegateeGV) { +Value* JnjvmModule::getConstantPool(JavaConstantPool* ctp, JavaJIT* jit) { + llvm::GlobalVariable* varGV = 0; + constant_pool_iterator End = constantPools.end(); + constant_pool_iterator I = constantPools.find(ctp); + if (I == End) { void* ptr = ctp->ctpRes; Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), - mvm::jit::ptrPtrType); - delegateeGV = new GlobalVariable(mvm::jit::ptrPtrType, true, - GlobalValue::ExternalLinkage, - cons, "", - ctp->classDef->classLoader->TheModule); - } - return new LoadInst(delegateeGV, "", jit->currentBlock); + mvm::MvmModule::ptrPtrType); + varGV = new GlobalVariable(mvm::MvmModule::ptrPtrType, true, + GlobalValue::ExternalLinkage, + cons, "", this); + constantPools.insert(std::make_pair(ctp, varGV)); + } else { + varGV = I->second; + } + return new LoadInst(varGV, "", jit->currentBlock); } -Value* LLVMCommonClassInfo::getDelegatee(JavaJIT* jit) { -#ifndef ISOLATE - if (!delegateeGV) { - JavaObject* obj = classDef->getClassDelegatee(JavaThread::get()->isolate); +Value* JnjvmModule::getString(JavaString* str, JavaJIT* jit) { + llvm::GlobalVariable* varGV; + string_iterator SI = strings.find(str); + if (SI != strings.end()) { + varGV = SI->second; + } else { + void* ptr = str; + Constant* cons = + ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), + JnjvmModule::JavaObjectType); + varGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, + GlobalValue::ExternalLinkage, + cons, "", this); + strings.insert(std::make_pair(str, varGV)); + } + return new LoadInst(varGV, "", jit->currentBlock); +} + +Value* JnjvmModule::getJavaClass(CommonClass* cl, JavaJIT* jit) { + llvm::GlobalVariable* varGV = 0; + java_class_iterator End = javaClasses.end(); + java_class_iterator I = javaClasses.find(cl); + if (I == End) { + + JavaObject* obj = cl->getClassDelegatee(JavaThread::get()->isolate); Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(obj)), JnjvmModule::JavaObjectType); - delegateeGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, - GlobalValue::ExternalLinkage, - cons, "", - classDef->classLoader->TheModule); + varGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, + GlobalValue::ExternalLinkage, + cons, "", this); + + javaClasses.insert(std::make_pair(cl, varGV)); + } else { + varGV = I->second; } - return new LoadInst(delegateeGV, "", jit->currentBlock); -#else - fprintf(stderr, "implement me\n"); - abort(); -#endif + return new LoadInst(varGV, "", jit->currentBlock); +} + +Value* JnjvmModule::getStaticInstance(Class* classDef, JavaJIT* jit) { + llvm::GlobalVariable* varGV = 0; + static_instance_iterator End = staticInstances.end(); + static_instance_iterator I = staticInstances.find(classDef); + if (I == End) { + LLVMClassInfo* LCI = getClassInfo(classDef); + LCI->getStaticType(); + JavaObject* obj = ((Class*)classDef)->getStaticInstance(); + Constant* cons = + ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, + uint64_t (obj)), JnjvmModule::JavaObjectType); + + varGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, + GlobalValue::ExternalLinkage, + cons, "", this); + + staticInstances.insert(std::make_pair(classDef, varGV)); + } else { + varGV = I->second; + } + + return new LoadInst(varGV, "", jit->currentBlock); +} + +Value* JnjvmModule::getVirtualTable(CommonClass* classDef, JavaJIT* jit) { + llvm::GlobalVariable* varGV = 0; + virtual_table_iterator End = virtualTables.end(); + virtual_table_iterator I = virtualTables.find(classDef); + if (I == End) { + if (!classDef->isArray() && !classDef->isPrimitive()) { + LLVMClassInfo* LCI = getClassInfo((Class*)classDef); + LCI->getVirtualType(); + } + Constant* cons = + ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, + uint64_t(classDef->virtualVT)), + JnjvmModule::VTType); + varGV = new GlobalVariable(JnjvmModule::VTType, true, + GlobalValue::ExternalLinkage, + cons, "", this); + + virtualTables.insert(std::make_pair(classDef, varGV)); + } else { + varGV = I->second; + } + return new LoadInst(varGV, "", jit->currentBlock); } #ifndef WITHOUT_VTABLE @@ -228,7 +223,7 @@ if (isa(I)) { ((void**)VT)[0] = 0; } else { - ExecutionEngine* EE = mvm::jit::executionEngine; + ExecutionEngine* EE = mvm::MvmModule::executionEngine; // LLVM does not allow recursive compilation. Create the code now. ((void**)VT)[0] = EE->getPointerToFunction(func); } @@ -252,7 +247,7 @@ VT = allocateVT(cl, ++meths); LLVMMethodInfo* LMI = getMethodInfo(meth); Function* func = LMI->getMethod(); - ExecutionEngine* EE = mvm::jit::executionEngine; + ExecutionEngine* EE = mvm::MvmModule::executionEngine; ((void**)VT)[offset] = EE->getPointerToFunctionOrStub(func); } @@ -304,9 +299,9 @@ Function* func = Function::Create(JnjvmModule::MarkAndTraceType, GlobalValue::ExternalLinkage, "markAndTraceObject", - cl->classLoader->TheModule); + this); - Constant* zero = mvm::jit::constantZero; + Constant* zero = mvm::MvmModule::constantZero; Argument* arg = func->arg_begin(); BasicBlock* block = BasicBlock::Create("", func); llvm::Value* realArg = new BitCastInst(arg, type, "", block); @@ -317,7 +312,7 @@ Args.push_back(arg); Args.push_back(GC); if (stat || cl->super == 0) { - CallInst::Create(JnjvmModule::JavaObjectTracer, Args.begin(), Args.end(), + CallInst::Create(JavaObjectTracerFunction, Args.begin(), Args.end(), "", block); } else { CallInst::Create(((Class*)cl->super)->virtualTracer, Args.begin(), @@ -325,7 +320,7 @@ } #else if (stat || cl->super == 0) { - CallInst::Create(JnjvmModule::JavaObjectTracerFunction, arg, "", block); + CallInst::Create(JavaObjectTracerFunction, arg, "", block); } else { LLVMClassInfo* LCP = (LLVMClassInfo*)getClassInfo((Class*)(cl->super)); CallInst::Create(LCP->getVirtualTracer(), arg, "", block); @@ -358,7 +353,7 @@ ReturnInst::Create(block); - void* codePtr = mvm::jit::executionEngine->getPointerToGlobal(func); + void* codePtr = mvm::MvmModule::executionEngine->getPointerToGlobal(func); ((void**)res)[VT_TRACER_OFFSET] = codePtr; func->deleteBody(); @@ -381,7 +376,7 @@ if (classDef->super) { LLVMClassInfo* CLI = - (LLVMClassInfo*)JnjvmModule::getClassInfo(classDef->super); + JnjvmModule::getClassInfo((Class*)classDef->super); fields.push_back(CLI->getVirtualType()->getContainedType(0)); } else { fields.push_back(JnjvmModule::JavaObjectType->getContainedType(0)); @@ -402,7 +397,7 @@ StructType* structType = StructType::get(fields, false); virtualType = PointerType::getUnqual(structType); - const TargetData* targetData = mvm::jit::executionEngine->getTargetData(); + const TargetData* targetData = mvm::MvmModule::executionEngine->getTargetData(); const StructLayout* sl = targetData->getStructLayout(structType); for (CommonClass::field_iterator i = classDef->virtualFields.begin(), @@ -411,9 +406,10 @@ field->ptrOffset = sl->getElementOffset(field->num + 1); } - VirtualTable* VT = JnjvmModule::makeVT((Class*)classDef, false); + JnjvmModule* Mod = classDef->classLoader->TheModule; + VirtualTable* VT = Mod->makeVT((Class*)classDef, false); - uint64 size = mvm::jit::getTypeSize(structType); + uint64 size = mvm::MvmModule::getTypeSize(structType); classDef->virtualSize = (uint32)size; classDef->virtualVT = VT; virtualSizeConstant = ConstantInt::get(Type::Int32Ty, size); @@ -447,7 +443,7 @@ StructType* structType = StructType::get(fields, false); staticType = PointerType::getUnqual(structType); - const TargetData* targetData = mvm::jit::executionEngine->getTargetData(); + const TargetData* targetData = mvm::MvmModule::executionEngine->getTargetData(); const StructLayout* sl = targetData->getStructLayout(structType); for (CommonClass::field_iterator i = classDef->staticFields.begin(), @@ -457,48 +453,16 @@ } - VirtualTable* VT = JnjvmModule::makeVT((Class*)classDef, true); + JnjvmModule* Mod = cl->classLoader->TheModule; + VirtualTable* VT = Mod->makeVT((Class*)classDef, true); - uint64 size = mvm::jit::getTypeSize(structType); + uint64 size = mvm::MvmModule::getTypeSize(structType); cl->staticSize = size; cl->staticVT = VT; } return staticType; } -#ifndef ISOLATE -Value* LLVMClassInfo::getStaticVar(JavaJIT* jit) { - if (!staticVarGV) { - getStaticType(); - JavaObject* obj = ((Class*)classDef)->getStaticInstance(); - Constant* cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64_t (obj)), JnjvmModule::JavaObjectType); - - staticVarGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, - GlobalValue::ExternalLinkage, - cons, "", - classDef->classLoader->TheModule); - } - - return new LoadInst(staticVarGV, "", jit->currentBlock); -} -#endif - -Value* LLVMClassInfo::getVirtualTable(JavaJIT* jit) { - if (!virtualTableGV) { - getVirtualType(); - Constant* cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64_t(classDef->virtualVT)), - JnjvmModule::VTType); - virtualTableGV = new GlobalVariable(JnjvmModule::VTType, true, - GlobalValue::ExternalLinkage, - cons, "", - classDef->classLoader->TheModule); - } - return new LoadInst(virtualTableGV, "", jit->currentBlock); -} Value* LLVMClassInfo::getVirtualSize(JavaJIT* jit) { if (!virtualSizeConstant) { @@ -572,7 +536,7 @@ const llvm::FunctionType* LLVMSignatureInfo::getVirtualType() { if (!virtualType) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector llvmArgs; unsigned int size = signature->args.size(); @@ -598,7 +562,7 @@ const llvm::FunctionType* LLVMSignatureInfo::getStaticType() { if (!staticType) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector llvmArgs; unsigned int size = signature->args.size(); @@ -622,11 +586,11 @@ const llvm::FunctionType* LLVMSignatureInfo::getNativeType() { if (!nativeType) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector llvmArgs; unsigned int size = signature->args.size(); - llvmArgs.push_back(mvm::jit::ptrType); // JNIEnv + llvmArgs.push_back(mvm::MvmModule::ptrType); // JNIEnv llvmArgs.push_back(JnjvmModule::JavaObjectType); // Class for (uint32 i = 0; i < size; ++i) { @@ -649,7 +613,7 @@ Function* LLVMSignatureInfo::createFunctionCallBuf(bool virt) { - ConstantInt* CI = mvm::jit::constantZero; + ConstantInt* CI = mvm::MvmModule::constantZero; std::vector Args; Function* res = Function::Create(virt ? getVirtualBufType() : @@ -688,9 +652,9 @@ Value* arg = new LoadInst(val, "", currentBlock); Args.push_back(arg); if (type == Type::Int64Ty || type == Type::DoubleTy) { - CI = mvm::jit::constantTwo; + CI = mvm::MvmModule::constantTwo; } else { - CI = mvm::jit::constantOne; + CI = mvm::MvmModule::constantOne; } } @@ -783,7 +747,7 @@ const FunctionType* LLVMSignatureInfo::getVirtualBufType() { if (!virtualBufType) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector Args2; Args2.push_back(JnjvmModule::JnjvmType); // vm Args2.push_back(JnjvmModule::ConstantPoolType); // ctp @@ -799,7 +763,7 @@ const FunctionType* LLVMSignatureInfo::getStaticBufType() { if (!staticBufType) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); std::vector Args; Args.push_back(JnjvmModule::JnjvmType); // vm Args.push_back(JnjvmModule::ConstantPoolType); // ctp @@ -814,10 +778,10 @@ Function* LLVMSignatureInfo::getVirtualBuf() { if (!virtualBufFunction) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); virtualBufFunction = createFunctionCallBuf(true); signature->setVirtualCallBuf((intptr_t) - mvm::jit::executionEngine->getPointerToGlobal(virtualBufFunction)); + mvm::MvmModule::executionEngine->getPointerToGlobal(virtualBufFunction)); virtualBufFunction->deleteBody(); } return virtualBufFunction; @@ -826,10 +790,10 @@ Function* LLVMSignatureInfo::getVirtualAP() { if (!virtualAPFunction) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); virtualAPFunction = createFunctionCallAP(true); signature->setVirtualCallAP((intptr_t) - mvm::jit::executionEngine->getPointerToGlobal(virtualAPFunction)); + mvm::MvmModule::executionEngine->getPointerToGlobal(virtualAPFunction)); virtualAPFunction->deleteBody(); } return virtualAPFunction; @@ -838,10 +802,10 @@ Function* LLVMSignatureInfo::getStaticBuf() { if (!staticBufFunction) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); staticBufFunction = createFunctionCallBuf(false); signature->setStaticCallBuf((intptr_t) - mvm::jit::executionEngine->getPointerToGlobal(staticBufFunction)); + mvm::MvmModule::executionEngine->getPointerToGlobal(staticBufFunction)); staticBufFunction->deleteBody(); } return staticBufFunction; @@ -850,10 +814,10 @@ Function* LLVMSignatureInfo::getStaticAP() { if (!staticAPFunction) { // Lock here because we are called by arbitrary code - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); staticAPFunction = createFunctionCallAP(false); signature->setStaticCallAP((intptr_t) - mvm::jit::executionEngine->getPointerToGlobal(staticAPFunction)); + mvm::MvmModule::executionEngine->getPointerToGlobal(staticAPFunction)); staticAPFunction->deleteBody(); } return staticAPFunction; @@ -861,60 +825,18 @@ void JnjvmModule::resolveVirtualClass(Class* cl) { // Lock here because we may be called by a class resolver - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl); LCI->getVirtualType(); } void JnjvmModule::resolveStaticClass(Class* cl) { // Lock here because we may be called by a class initializer - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl); LCI->getStaticType(); } -#ifdef SERVICE_VM -Value* LLVMServiceInfo::getDelegatee(JavaJIT* jit) { - if (!delegateeGV) { - Constant* cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(vm)), - mvm::jit::ptrType); - delegateeGV = new GlobalVariable(mvm::jit::ptrType, true, - GlobalValue::ExternalLinkage, - cons, "", - vm->module); - } - return new LoadInst(delegateeGV, "", jit->currentBlock); -} - -#endif - - -LLVMStringInfo* JnjvmModule::getStringInfo(JavaString* str) { - string_iterator SI = stringMap.find(str); - if (SI != stringMap.end()) { - return SI->second; - } else { - LLVMStringInfo* LSI = new LLVMStringInfo(str); - stringMap.insert(std::make_pair(str, LSI)); - return LSI; - } -} - -Value* LLVMStringInfo::getDelegatee(JavaJIT* jit) { - if (!delegateeGV) { - void* ptr = str; - Constant* cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), - JnjvmModule::JavaObjectType); - delegateeGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, - GlobalValue::ExternalLinkage, - cons, "", - jit->module); - } - return new LoadInst(delegateeGV, "", jit->currentBlock); -} - namespace jnjvm { namespace llvm_runtime { @@ -922,10 +844,13 @@ } } +Module* JnjvmModule::initialModule; + void JnjvmModule::initialise() { - Module* module = this; - jnjvm::llvm_runtime::makeLLVMModuleContents(module); - + initialModule = new Module("Initial jnjvm module"); + jnjvm::llvm_runtime::makeLLVMModuleContents(initialModule); + Module* module = initialModule; + VTType = module->getTypeByName("VT"); JnjvmType = @@ -969,6 +894,89 @@ EnveloppeType = PointerType::getUnqual(module->getTypeByName("Enveloppe")); +#ifdef WITH_TRACER + MarkAndTraceType = module->getFunction("MarkAndTrace")->getFunctionType(); +#endif + + UTF8NullConstant = Constant::getNullValue(JavaArrayUInt16Type); + JavaClassNullConstant = Constant::getNullValue(JavaClassType); + JavaObjectNullConstant = Constant::getNullValue(JnjvmModule::JavaObjectType); + MaxArraySizeConstant = ConstantInt::get(Type::Int32Ty, + JavaArray::MaxArraySize); + JavaObjectSizeConstant = ConstantInt::get(Type::Int32Ty, sizeof(JavaObject)); + + + JavaArrayElementsOffsetConstant = mvm::MvmModule::constantTwo; + JavaArraySizeOffsetConstant = mvm::MvmModule::constantOne; + JavaObjectLockOffsetConstant = mvm::MvmModule::constantTwo; + JavaObjectClassOffsetConstant = mvm::MvmModule::constantOne; + + OffsetObjectSizeInClassConstant = mvm::MvmModule::constantOne; + OffsetVTInClassConstant = mvm::MvmModule::constantTwo; + OffsetDisplayInClassConstant = mvm::MvmModule::constantThree; + OffsetDepthInClassConstant = mvm::MvmModule::constantFour; + OffsetStatusInClassConstant = mvm::MvmModule::constantFive; + OffsetCtpInClassConstant = mvm::MvmModule::constantSix; + + LLVMAssessorInfo::initialise(); +} + +void JnjvmModule::InitField(JavaField* field, JavaObject* obj, uint64 val) { + + Typedef* type = field->getSignature(); + if (!type->isPrimitive()) { + ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; + return; + } + + PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isLong()) { + ((sint64*)((uint64)obj + field->ptrOffset))[0] = val; + } else if (prim->isInt()) { + ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; + } else if (prim->isChar()) { + ((uint16*)((uint64)obj + field->ptrOffset))[0] = (uint16)val; + } else if (prim->isShort()) { + ((sint16*)((uint64)obj + field->ptrOffset))[0] = (sint16)val; + } else if (prim->isByte()) { + ((sint8*)((uint64)obj + field->ptrOffset))[0] = (sint8)val; + } else if (prim->isBool()) { + ((uint8*)((uint64)obj + field->ptrOffset))[0] = (uint8)val; + } else { + // 0 value for everything else + ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; + } +} + +void JnjvmModule::InitField(JavaField* field, JavaObject* obj, JavaObject* val) { + ((JavaObject**)((uint64)obj + field->ptrOffset))[0] = val; +} + +void JnjvmModule::InitField(JavaField* field, JavaObject* obj, double val) { + ((double*)((uint64)obj + field->ptrOffset))[0] = val; +} + +void JnjvmModule::InitField(JavaField* field, JavaObject* obj, float val) { + ((float*)((uint64)obj + field->ptrOffset))[0] = val; +} + +void JnjvmModule::setMethod(JavaMethod* meth, const char* name) { + llvm::Function* func = getMethodInfo(meth)->getMethod(); + func->setName(name); + func->setLinkage(llvm::GlobalValue::ExternalLinkage); +} + +void* JnjvmModule::getMethod(JavaMethod* meth) { + return getMethodInfo(meth)->getMethod(); +} + +JnjvmModule::JnjvmModule(const std::string &ModuleID) : MvmModule(ModuleID) { + std::string str = + mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation(); + setDataLayout(str); + + Module* module = initialModule; + InterfaceLookupFunction = module->getFunction("jnjvmVirtualLookup"); MultiCallNewFunction = module->getFunction("multiCallNew"); InitialisationCheckFunction = module->getFunction("initialisationCheck"); @@ -1052,7 +1060,6 @@ #ifdef WITH_TRACER MarkAndTraceFunction = module->getFunction("MarkAndTrace"); - MarkAndTraceType = MarkAndTraceFunction->getFunctionType(); JavaObjectTracerFunction = module->getFunction("JavaObjectTracer"); #endif @@ -1066,102 +1073,8 @@ GetThreadIDFunction = module->getFunction("getThreadID"); GetLockFunction = module->getFunction("getLock"); - - UTF8NullConstant = Constant::getNullValue(JavaArrayUInt16Type); - JavaClassNullConstant = Constant::getNullValue(JavaClassType); - JavaObjectNullConstant = Constant::getNullValue(JnjvmModule::JavaObjectType); - MaxArraySizeConstant = ConstantInt::get(Type::Int32Ty, - JavaArray::MaxArraySize); - JavaObjectSizeConstant = ConstantInt::get(Type::Int32Ty, sizeof(JavaObject)); - - - Constant* cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64_t (JavaObject::VT)), VTType); - - JavaObjectVirtualTableGV = new GlobalVariable(VTType, true, - GlobalValue::ExternalLinkage, - cons, "", - module); - - cons = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64_t (ArrayObject::VT)), VTType); - - ArrayObjectVirtualTableGV = new GlobalVariable(VTType, true, - GlobalValue::ExternalLinkage, - cons, "", - module); - - JavaArrayElementsOffsetConstant = mvm::jit::constantTwo; - JavaArraySizeOffsetConstant = mvm::jit::constantOne; - JavaObjectLockOffsetConstant = mvm::jit::constantTwo; - JavaObjectClassOffsetConstant = mvm::jit::constantOne; - - OffsetObjectSizeInClassConstant = mvm::jit::constantOne; - OffsetVTInClassConstant = mvm::jit::constantTwo; - OffsetDisplayInClassConstant = mvm::jit::constantThree; - OffsetDepthInClassConstant = mvm::jit::constantFour; - OffsetStatusInClassConstant = mvm::jit::constantFive; - OffsetCtpInClassConstant = mvm::jit::constantSix; - - LLVMAssessorInfo::initialise(); -} - -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, uint64 val) { - - Typedef* type = field->getSignature(); - if (!type->isPrimitive()) { - ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - return; - } - - PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isLong()) { - ((sint64*)((uint64)obj + field->ptrOffset))[0] = val; - } else if (prim->isInt()) { - ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - } else if (prim->isChar()) { - ((uint16*)((uint64)obj + field->ptrOffset))[0] = (uint16)val; - } else if (prim->isShort()) { - ((sint16*)((uint64)obj + field->ptrOffset))[0] = (sint16)val; - } else if (prim->isByte()) { - ((sint8*)((uint64)obj + field->ptrOffset))[0] = (sint8)val; - } else if (prim->isBool()) { - ((uint8*)((uint64)obj + field->ptrOffset))[0] = (uint8)val; - } else { - // 0 value for everything else - ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - } -} - -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, JavaObject* val) { - ((JavaObject**)((uint64)obj + field->ptrOffset))[0] = val; -} - -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, double val) { - ((double*)((uint64)obj + field->ptrOffset))[0] = val; -} - -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, float val) { - ((float*)((uint64)obj + field->ptrOffset))[0] = val; } -void JnjvmModule::setMethod(JavaMethod* meth, const char* name) { - llvm::Function* func = getMethodInfo(meth)->getMethod(); - func->setName(name); - func->setLinkage(llvm::GlobalValue::ExternalLinkage); -} - -void* JnjvmModule::getMethod(JavaMethod* meth) { - return getMethodInfo(meth)->getMethod(); -} - -JnjvmModule::JnjvmModule(const std::string &ModuleID) : llvm::Module(ModuleID) { - std::string str = - mvm::jit::executionEngine->getTargetData()->getStringRepresentation(); - setDataLayout(str); -} void LLVMAssessorInfo::initialise() { AssessorInfo[I_VOID].llvmType = Type::VoidTy; AssessorInfo[I_VOID].llvmTypePtr = 0; @@ -1172,63 +1085,63 @@ AssessorInfo[I_BOOL].llvmTypePtr = PointerType::getUnqual(Type::Int8Ty); AssessorInfo[I_BOOL].llvmNullConstant = Constant::getNullValue(Type::Int8Ty); - AssessorInfo[I_BOOL].sizeInBytesConstant = mvm::jit::constantOne; + AssessorInfo[I_BOOL].sizeInBytesConstant = mvm::MvmModule::constantOne; AssessorInfo[I_BYTE].llvmType = Type::Int8Ty; AssessorInfo[I_BYTE].llvmTypePtr = PointerType::getUnqual(Type::Int8Ty); AssessorInfo[I_BYTE].llvmNullConstant = Constant::getNullValue(Type::Int8Ty); - AssessorInfo[I_BYTE].sizeInBytesConstant = mvm::jit::constantOne; + AssessorInfo[I_BYTE].sizeInBytesConstant = mvm::MvmModule::constantOne; AssessorInfo[I_SHORT].llvmType = Type::Int16Ty; AssessorInfo[I_SHORT].llvmTypePtr = PointerType::getUnqual(Type::Int16Ty); AssessorInfo[I_SHORT].llvmNullConstant = Constant::getNullValue(Type::Int16Ty); - AssessorInfo[I_SHORT].sizeInBytesConstant = mvm::jit::constantTwo; + AssessorInfo[I_SHORT].sizeInBytesConstant = mvm::MvmModule::constantTwo; AssessorInfo[I_CHAR].llvmType = Type::Int16Ty; AssessorInfo[I_CHAR].llvmTypePtr = PointerType::getUnqual(Type::Int16Ty); AssessorInfo[I_CHAR].llvmNullConstant = Constant::getNullValue(Type::Int16Ty); - AssessorInfo[I_CHAR].sizeInBytesConstant = mvm::jit::constantTwo; + AssessorInfo[I_CHAR].sizeInBytesConstant = mvm::MvmModule::constantTwo; AssessorInfo[I_INT].llvmType = Type::Int32Ty; AssessorInfo[I_INT].llvmTypePtr = PointerType::getUnqual(Type::Int32Ty); AssessorInfo[I_INT].llvmNullConstant = Constant::getNullValue(Type::Int32Ty); - AssessorInfo[I_INT].sizeInBytesConstant = mvm::jit::constantFour; + AssessorInfo[I_INT].sizeInBytesConstant = mvm::MvmModule::constantFour; AssessorInfo[I_FLOAT].llvmType = Type::FloatTy; AssessorInfo[I_FLOAT].llvmTypePtr = PointerType::getUnqual(Type::FloatTy); AssessorInfo[I_FLOAT].llvmNullConstant = Constant::getNullValue(Type::FloatTy); - AssessorInfo[I_FLOAT].sizeInBytesConstant = mvm::jit::constantFour; + AssessorInfo[I_FLOAT].sizeInBytesConstant = mvm::MvmModule::constantFour; AssessorInfo[I_LONG].llvmType = Type::Int64Ty; AssessorInfo[I_LONG].llvmTypePtr = PointerType::getUnqual(Type::Int64Ty); AssessorInfo[I_LONG].llvmNullConstant = Constant::getNullValue(Type::Int64Ty); - AssessorInfo[I_LONG].sizeInBytesConstant = mvm::jit::constantEight; + AssessorInfo[I_LONG].sizeInBytesConstant = mvm::MvmModule::constantEight; AssessorInfo[I_DOUBLE].llvmType = Type::DoubleTy; AssessorInfo[I_DOUBLE].llvmTypePtr = PointerType::getUnqual(Type::DoubleTy); AssessorInfo[I_DOUBLE].llvmNullConstant = Constant::getNullValue(Type::DoubleTy); - AssessorInfo[I_DOUBLE].sizeInBytesConstant = mvm::jit::constantEight; + AssessorInfo[I_DOUBLE].sizeInBytesConstant = mvm::MvmModule::constantEight; AssessorInfo[I_TAB].llvmType = JnjvmModule::JavaObjectType; AssessorInfo[I_TAB].llvmTypePtr = PointerType::getUnqual(JnjvmModule::JavaObjectType); AssessorInfo[I_TAB].llvmNullConstant = JnjvmModule::JavaObjectNullConstant; - AssessorInfo[I_TAB].sizeInBytesConstant = mvm::jit::constantPtrSize; + AssessorInfo[I_TAB].sizeInBytesConstant = mvm::MvmModule::constantPtrSize; AssessorInfo[I_REF].llvmType = JnjvmModule::JavaObjectType; AssessorInfo[I_REF].llvmTypePtr = PointerType::getUnqual(JnjvmModule::JavaObjectType); AssessorInfo[I_REF].llvmNullConstant = JnjvmModule::JavaObjectNullConstant; - AssessorInfo[I_REF].sizeInBytesConstant = mvm::jit::constantPtrSize; + AssessorInfo[I_REF].sizeInBytesConstant = mvm::MvmModule::constantPtrSize; } std::map LLVMAssessorInfo::AssessorInfo; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Fri Oct 10 07:51:51 2008 @@ -50,42 +50,13 @@ }; -class LLVMCommonClassInfo : public mvm::JITInfo { - - friend class JnjvmModule; - -protected: - CommonClass* classDef; - -private: - /// varGV - The LLVM global variable representing this class. - /// - llvm::GlobalVariable* varGV; - - /// delegateeGV - The LLVM global variable representing the - /// java/lang/Class instance of this class. - llvm::GlobalVariable* delegateeGV; - - -public: - llvm::Value* getVar(JavaJIT* jit); - llvm::Value* getDelegatee(JavaJIT* jit); - - LLVMCommonClassInfo(CommonClass* cl) : - classDef(cl), - varGV(0), - delegateeGV(0) - {} -}; - -class LLVMClassInfo : public LLVMCommonClassInfo { +class LLVMClassInfo : public mvm::JITInfo { friend class JnjvmModule; private: + CommonClass* classDef; /// virtualSizeLLVM - The LLVM constant size of instances of this class. /// llvm::ConstantInt* virtualSizeConstant; - llvm::GlobalVariable* staticVarGV; - llvm::GlobalVariable* virtualTableGV; llvm::Function* virtualTracerFunction; llvm::Function* staticTracerFunction; /// virtualType - The LLVM type of instance of this class. @@ -97,19 +68,15 @@ const llvm::Type * staticType; public: - llvm::Value* getStaticVar(JavaJIT* jit); - llvm::Value* getVirtualTable(JavaJIT* jit); llvm::Value* getVirtualSize(JavaJIT* jit); llvm::Function* getStaticTracer(); llvm::Function* getVirtualTracer(); const llvm::Type* getVirtualType(); const llvm::Type* getStaticType(); - LLVMClassInfo(CommonClass* cl) : - LLVMCommonClassInfo(cl), + LLVMClassInfo(CommonClass* cl) : + classDef(cl), virtualSizeConstant(0), - staticVarGV(0), - virtualTableGV(0), virtualTracerFunction(0), staticTracerFunction(0), virtualType(0), @@ -209,74 +176,38 @@ }; -#ifdef SERVICE_VM -class LLVMServiceInfo : public mvm::JITInfo { -private: - ServiceDomain* vm; - llvm::GlobalVariable* delegateeGV; - -public: - llvm::Value* getDelegatee(JavaJIT* jit); -}; -#endif - -class LLVMConstantPoolInfo : public mvm::JITInfo { -private: - JavaConstantPool* ctp; - llvm::GlobalVariable* delegateeGV; - -public: - llvm::Value* getDelegatee(JavaJIT* jit); - - LLVMConstantPoolInfo(JavaConstantPool* c) : - ctp(c), delegateeGV(0) {} -}; - -class LLVMStringInfo : public mvm::JITInfo { -private: - JavaString* str; - llvm::GlobalVariable* delegateeGV; - -public: - llvm::Value* getDelegatee(JavaJIT* jit); - - LLVMStringInfo(JavaString* c) : - str(c), delegateeGV(0) {} -}; - -class JnjvmModule : public llvm::Module { +class JnjvmModule : public mvm::MvmModule { friend class LLVMClassInfo; private: - std::map classMap; - std::map signatureMap; - std::map fieldMap; - std::map methodMap; - std::map stringMap; + std::map nativeClasses; + std::map javaClasses; + std::map virtualTables; + std::map staticInstances; + std::map constantPools; + std::map strings; -#ifdef SERVICE_VM - std::map serviceMap; - typedef std::map::iterator - class_iterator; -#endif + typedef std::map::iterator + native_class_iterator; - typedef std::map::iterator - class_iterator; + typedef std::map::iterator + java_class_iterator; - typedef std::map::iterator - signature_iterator; + typedef std::map::iterator + virtual_table_iterator; - typedef std::map::iterator - method_iterator; + typedef std::map::iterator + static_instance_iterator; - typedef std::map::iterator - field_iterator; + typedef std::map::iterator + constant_pool_iterator; - typedef std::map::iterator + typedef std::map::iterator string_iterator; + - static VirtualTable* makeVT(Class* cl, bool stat); - static VirtualTable* allocateVT(Class* cl, CommonClass::method_iterator meths); + VirtualTable* makeVT(Class* cl, bool stat); + VirtualTable* allocateVT(Class* cl, CommonClass::method_iterator meths); public: @@ -308,71 +239,71 @@ static const llvm::Type* ConstantPoolType; #ifdef WITH_TRACER - static llvm::Function* MarkAndTraceFunction; + llvm::Function* MarkAndTraceFunction; static const llvm::FunctionType* MarkAndTraceType; - static llvm::Function* JavaObjectTracerFunction; + llvm::Function* JavaObjectTracerFunction; #endif - static llvm::Function* GetSJLJBufferFunction; - static llvm::Function* InterfaceLookupFunction; - static llvm::Function* VirtualFieldLookupFunction; - static llvm::Function* StaticFieldLookupFunction; - static llvm::Function* PrintExecutionFunction; - static llvm::Function* PrintMethodStartFunction; - static llvm::Function* PrintMethodEndFunction; - static llvm::Function* JniProceedPendingExceptionFunction; - static llvm::Function* InitialisationCheckFunction; - static llvm::Function* ForceInitialisationCheckFunction; - static llvm::Function* ClassLookupFunction; + llvm::Function* GetSJLJBufferFunction; + llvm::Function* InterfaceLookupFunction; + llvm::Function* VirtualFieldLookupFunction; + llvm::Function* StaticFieldLookupFunction; + llvm::Function* PrintExecutionFunction; + llvm::Function* PrintMethodStartFunction; + llvm::Function* PrintMethodEndFunction; + llvm::Function* JniProceedPendingExceptionFunction; + llvm::Function* InitialisationCheckFunction; + llvm::Function* ForceInitialisationCheckFunction; + llvm::Function* ClassLookupFunction; #ifndef WITHOUT_VTABLE - static llvm::Function* VirtualLookupFunction; + llvm::Function* VirtualLookupFunction; #endif - static llvm::Function* InstanceOfFunction; - static llvm::Function* IsAssignableFromFunction; - static llvm::Function* ImplementsFunction; - static llvm::Function* InstantiationOfArrayFunction; - static llvm::Function* GetDepthFunction; - static llvm::Function* GetClassInDisplayFunction; - static llvm::Function* GetDisplayFunction; - static llvm::Function* AquireObjectFunction; - static llvm::Function* ReleaseObjectFunction; - static llvm::Function* GetConstantPoolAtFunction; + llvm::Function* InstanceOfFunction; + llvm::Function* IsAssignableFromFunction; + llvm::Function* ImplementsFunction; + llvm::Function* InstantiationOfArrayFunction; + llvm::Function* GetDepthFunction; + llvm::Function* GetClassInDisplayFunction; + llvm::Function* GetDisplayFunction; + llvm::Function* AquireObjectFunction; + llvm::Function* ReleaseObjectFunction; + llvm::Function* GetConstantPoolAtFunction; #ifdef SERVICE_VM - static llvm::Function* AquireObjectInSharedDomainFunction; - static llvm::Function* ReleaseObjectInSharedDomainFunction; - static llvm::Function* ServiceCallStartFunction; - static llvm::Function* ServiceCallStopFunction; + llvm::Function* AquireObjectInSharedDomainFunction; + llvm::Function* ReleaseObjectInSharedDomainFunction; + llvm::Function* ServiceCallStartFunction; + llvm::Function* ServiceCallStopFunction; #endif - static llvm::Function* MultiCallNewFunction; + llvm::Function* MultiCallNewFunction; #ifdef ISOLATE - static llvm::Function* StringLookupFunction; + llvm::Function* StringLookupFunction; #ifdef ISOLATE_SHARING - static llvm::Function* GetCtpCacheNodeFunction; - static llvm::Function* GetCtpClassFunction; - static llvm::Function* EnveloppeLookupFunction; - static llvm::Function* GetJnjvmExceptionClassFunction; - static llvm::Function* GetJnjvmArrayClassFunction; - static llvm::Function* StaticCtpLookupFunction; - static llvm::Function* SpecialCtpLookupFunction; - static llvm::Function* GetArrayClassFunction; + llvm::Function* GetCtpCacheNodeFunction; + llvm::Function* GetCtpClassFunction; + llvm::Function* EnveloppeLookupFunction; + llvm::Function* GetJnjvmExceptionClassFunction; + llvm::Function* GetJnjvmArrayClassFunction; + llvm::Function* StaticCtpLookupFunction; + llvm::Function* SpecialCtpLookupFunction; + llvm::Function* GetArrayClassFunction; #endif #endif - static llvm::Function* GetClassDelegateeFunction; - static llvm::Function* ArrayLengthFunction; - static llvm::Function* GetVTFunction; - static llvm::Function* GetClassFunction; - static llvm::Function* JavaObjectAllocateFunction; + llvm::Function* GetClassDelegateeFunction; + llvm::Function* ArrayLengthFunction; + llvm::Function* GetVTFunction; + llvm::Function* GetClassFunction; + llvm::Function* JavaObjectAllocateFunction; #ifdef MULTIPLE_GC - static llvm::Function* GetCollectorFunction; + llvm::Function* GetCollectorFunction; #endif - static llvm::Function* GetVTFromClassFunction; - static llvm::Function* GetObjectSizeFromClassFunction; + llvm::Function* GetVTFromClassFunction; + llvm::Function* GetObjectSizeFromClassFunction; - static llvm::Function* GetLockFunction; - static llvm::Function* GetThreadIDFunction; - static llvm::Function* OverflowThinLockFunction; + llvm::Function* GetLockFunction; + llvm::Function* GetThreadIDFunction; + llvm::Function* OverflowThinLockFunction; static llvm::ConstantInt* OffsetObjectSizeInClassConstant; static llvm::ConstantInt* OffsetVTInClassConstant; @@ -388,19 +319,16 @@ static llvm::Constant* MaxArraySizeConstant; static llvm::Constant* JavaObjectSizeConstant; - static llvm::GlobalVariable* ArrayObjectVirtualTableGV; - static llvm::GlobalVariable* JavaObjectVirtualTableGV; - - static llvm::Function* GetExceptionFunction; - static llvm::Function* GetJavaExceptionFunction; - static llvm::Function* ThrowExceptionFunction; - static llvm::Function* ClearExceptionFunction; - static llvm::Function* CompareExceptionFunction; - static llvm::Function* NullPointerExceptionFunction; - static llvm::Function* IndexOutOfBoundsExceptionFunction; - static llvm::Function* ClassCastExceptionFunction; - static llvm::Function* OutOfMemoryErrorFunction; - static llvm::Function* NegativeArraySizeExceptionFunction; + llvm::Function* GetExceptionFunction; + llvm::Function* GetJavaExceptionFunction; + llvm::Function* ThrowExceptionFunction; + llvm::Function* ClearExceptionFunction; + llvm::Function* CompareExceptionFunction; + llvm::Function* NullPointerExceptionFunction; + llvm::Function* IndexOutOfBoundsExceptionFunction; + llvm::Function* ClassCastExceptionFunction; + llvm::Function* OutOfMemoryErrorFunction; + llvm::Function* NegativeArraySizeExceptionFunction; static void InitField(JavaField* field); static void InitField(JavaField* field, JavaObject* obj, uint64 val = 0); @@ -418,11 +346,7 @@ return sign->getInfo(); } - static LLVMCommonClassInfo* getClassInfo(CommonClass* cl) { - if (cl->isArray() || cl->isPrimitive()) { - return cl->getInfo(); - } - + static LLVMClassInfo* getClassInfo(Class* cl) { return cl->getInfo(); } @@ -434,22 +358,22 @@ return method->getInfo(); } - static LLVMConstantPoolInfo* getConstantPoolInfo(JavaConstantPool* ctp) { - return ctp->getInfo(); - } - static LLVMAssessorInfo& getTypedefInfo(Typedef* type); - LLVMStringInfo* getStringInfo(JavaString* str); + explicit JnjvmModule(const std::string &ModuleID); + static void initialise(); -#ifdef SERVICE_VM - static LLVMServiceInfo* getServiceInfo(ServiceDomain* service) { - return service->getInfo(); - } -#endif + llvm::Value* getNativeClass(CommonClass* cl, JavaJIT* jit); + llvm::Value* getJavaClass(CommonClass* cl, JavaJIT* jit); + llvm::Value* getStaticInstance(Class* cl, JavaJIT* jit); + llvm::Value* getVirtualTable(CommonClass* cl, JavaJIT* jit); - explicit JnjvmModule(const std::string &ModuleID); - void initialise(); + llvm::Value* getString(JavaString* str, JavaJIT* jit); + llvm::Value* getConstantPool(JavaConstantPool* ctp, JavaJIT* jit); + +private: + static llvm::Module* initialModule; + }; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Fri Oct 10 07:51:51 2008 @@ -9,6 +9,7 @@ #include "llvm/LinkAllPasses.h" #include "llvm/Analysis/LoopPass.h" +#include "llvm/Analysis/Verifier.h" #include "llvm/Support/MutexGuard.h" #include "mvm/JIT.h" @@ -74,7 +75,7 @@ bool JnjvmModuleProvider::materializeFunction(Function *F, std::string *ErrInfo) { - if (mvm::jit::executionEngine->getPointerToGlobalIfAvailable(F)) + if (mvm::MvmModule::executionEngine->getPointerToGlobalIfAvailable(F)) return false; if (!(F->hasNotBeenReadFromBitcode())) @@ -91,7 +92,7 @@ void* val = meth->compiledPtr(); if (F->isDeclaration()) - mvm::jit::executionEngine->updateGlobalMapping(F, val); + mvm::MvmModule::executionEngine->updateGlobalMapping(F, val); if (isVirtual(meth->access)) { LLVMMethodInfo* LMI = ((JnjvmModule*)TheModule)->getMethodInfo(meth); @@ -115,8 +116,8 @@ void* JnjvmModuleProvider::materializeFunction(JavaMethod* meth) { Function* func = parseFunction(meth); - void* res = mvm::jit::executionEngine->getPointerToGlobal(func); - mvm::Code* m = mvm::jit::getCodeFromPointer(res); + void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(func); + mvm::Code* m = mvm::MvmModule::getCodeFromPointer(res); if (m) m->setMetaInfo(meth); func->deleteBody(); @@ -128,7 +129,7 @@ Function* func = LMI->getMethod(); if (func->hasNotBeenReadFromBitcode()) { // We are jitting. Take the lock. - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); JavaJIT jit; jit.compilingClass = meth->classDef; jit.compilingMethod = meth; @@ -138,7 +139,7 @@ jit.nativeCompile(); } else { jit.javaCompile(); - mvm::jit::runPasses(func, perFunctionPasses); + mvm::MvmModule::runPasses(func, perFunctionPasses); } } return func; @@ -197,9 +198,15 @@ // -indvars -loop-unroll -instcombine -gvn -sccp -simplifycfg // -instcombine -condprop -dse -adce -simplifycfg // -static void AddStandardCompilePasses(FunctionPassManager *PM) { - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); - // LLVM does not allow calling functions from other modules in verifier +static void AddStandardCompilePasses(JnjvmModule* mod, FunctionPassManager *PM) { + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); + + // TODO: enable this when + // - we can call multiple times the makeLLVMModuleContents function generated + // by llc -march=cpp -cppgen=contents + // - intrinsics won't be in the .ll files + // - each module will have its declaration of external functions + // //PM->add(llvm::createVerifierPass()); // Verify that input is correct addPass(PM, llvm::createCFGSimplificationPass()); // Clean up disgusting code @@ -226,7 +233,7 @@ addPass(PM, createSCCPPass()); // Constant prop with SCCP addPass(PM, createCFGSimplificationPass()); // Merge & remove BBs - Function* func = JnjvmModule::JavaObjectAllocateFunction; + Function* func = mod->JavaObjectAllocateFunction; addPass(PM, mvm::createEscapeAnalysisPass(func)); addPass(PM, mvm::createLowerConstantCallsPass()); @@ -245,17 +252,17 @@ JnjvmModuleProvider::JnjvmModuleProvider(JnjvmModule *m) { TheModule = (Module*)m; - mvm::jit::protectEngine->lock(); - mvm::jit::executionEngine->addModuleProvider(this); - mvm::jit::protectEngine->unlock(); + mvm::MvmModule::protectEngine->lock(); + mvm::MvmModule::executionEngine->addModuleProvider(this); + mvm::MvmModule::protectEngine->unlock(); perFunctionPasses = new llvm::FunctionPassManager(this); perFunctionPasses->add(new llvm::TargetData(m)); - AddStandardCompilePasses(perFunctionPasses); + AddStandardCompilePasses(m, perFunctionPasses); } JnjvmModuleProvider::~JnjvmModuleProvider() { - mvm::jit::protectEngine->lock(); - mvm::jit::executionEngine->removeModuleProvider(this); - mvm::jit::protectEngine->unlock(); + mvm::MvmModule::protectEngine->lock(); + mvm::MvmModule::executionEngine->removeModuleProvider(this); + mvm::MvmModule::protectEngine->unlock(); delete TheModule; } Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Fri Oct 10 07:51:51 2008 @@ -37,6 +37,7 @@ static RegisterPass X("LowerConstantCalls", "Lower Constant calls"); bool LowerConstantCalls::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; @@ -47,87 +48,87 @@ Instruction* CI = Call.getInstruction(); if (CI) { Value* V = Call.getCalledValue(); - if (V == jnjvm::JnjvmModule::ArrayLengthFunction) { + if (V == module->ArrayLengthFunction) { Changed = true; Value* val = Call.getArgument(0); // get the array - Value* array = new BitCastInst(val, jnjvm::JnjvmModule::JavaArrayType, + Value* array = new BitCastInst(val, module->JavaArrayType, "", CI); std::vector args; //size= 2 - args.push_back(mvm::jit::constantZero); - args.push_back(jnjvm::JnjvmModule::JavaArraySizeOffsetConstant); + args.push_back(mvm::MvmModule::constantZero); + args.push_back(module->JavaArraySizeOffsetConstant); Value* ptr = GetElementPtrInst::Create(array, args.begin(), args.end(), "", CI); Value* load = new LoadInst(ptr, "", CI); CI->replaceAllUsesWith(load); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetVTFunction) { + } else if (V == module->GetVTFunction) { Changed = true; Value* val = Call.getArgument(0); // get the object std::vector indexes; //[3]; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(mvm::jit::constantZero); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(mvm::MvmModule::constantZero); Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* VT = new LoadInst(VTPtr, "", CI); CI->replaceAllUsesWith(VT); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetClassFunction) { + } else if (V == module->GetClassFunction) { Changed = true; Value* val = Call.getArgument(0); // get the object std::vector args2; - args2.push_back(mvm::jit::constantZero); - args2.push_back(jnjvm::JnjvmModule::JavaObjectClassOffsetConstant); + args2.push_back(mvm::MvmModule::constantZero); + args2.push_back(module->JavaObjectClassOffsetConstant); Value* classPtr = GetElementPtrInst::Create(val, args2.begin(), args2.end(), "", CI); Value* cl = new LoadInst(classPtr, "", CI); CI->replaceAllUsesWith(cl); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetVTFromClassFunction) { + } else if (V == module->GetVTFromClassFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(jnjvm::JnjvmModule::OffsetVTInClassConstant); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(module->OffsetVTInClassConstant); Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* VT = new LoadInst(VTPtr, "", CI); CI->replaceAllUsesWith(VT); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetObjectSizeFromClassFunction) { + } else if (V == module->GetObjectSizeFromClassFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(JnjvmModule::OffsetObjectSizeInClassConstant); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(module->OffsetObjectSizeInClassConstant); Value* SizePtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* Size = new LoadInst(SizePtr, "", CI); CI->replaceAllUsesWith(Size); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetDepthFunction) { + } else if (V == module->GetDepthFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(JnjvmModule::OffsetDepthInClassConstant); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(module->OffsetDepthInClassConstant); Value* DepthPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* Depth = new LoadInst(DepthPtr, "", CI); CI->replaceAllUsesWith(Depth); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetDisplayFunction) { + } else if (V == module->GetDisplayFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(JnjvmModule::OffsetDisplayInClassConstant); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(module->OffsetDisplayInClassConstant); Value* DisplayPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* Display = new LoadInst(DisplayPtr, "", CI); CI->replaceAllUsesWith(Display); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetClassInDisplayFunction) { + } else if (V == module->GetClassInDisplayFunction) { Changed = true; Value* val = Call.getArgument(0); Value* depth = Call.getArgument(1); @@ -135,7 +136,7 @@ Value* Class = new LoadInst(ClassPtr, "", CI); CI->replaceAllUsesWith(Class); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::InstanceOfFunction) { + } else if (V == module->InstanceOfFunction) { ConstantExpr* CE = dyn_cast(Call.getArgument(1)); if (CE) { ConstantInt* C = (ConstantInt*)CE->getOperand(0); @@ -145,21 +146,21 @@ I->getParent()->getTerminator()->eraseFromParent(); Value* obj = Call.getArgument(0); Instruction* cmp = new ICmpInst(ICmpInst::ICMP_EQ, obj, - JnjvmModule::JavaObjectNullConstant, + 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(JnjvmModule::GetClassFunction, obj, + Value* objCl = CallInst::Create(module->GetClassFunction, obj, "", ifFalse); if (isInterface(cl->access)) { std::vector args; args.push_back(objCl); args.push_back(CE); - Value* res = CallInst::Create(JnjvmModule::ImplementsFunction, + Value* res = CallInst::Create(module->ImplementsFunction, args.begin(), args.end(), "", ifFalse); node->addIncoming(res, ifFalse); @@ -174,7 +175,7 @@ std::vector args; args.push_back(objCl); args.push_back(CE); - cmp = CallInst::Create(JnjvmModule::IsAssignableFromFunction, + cmp = CallInst::Create(module->IsAssignableFromFunction, args.begin(), args.end(), "", notEquals); node->addIncoming(cmp, notEquals); BranchInst::Create(ifTrue, notEquals); @@ -183,7 +184,7 @@ args.push_back(objCl); args.push_back(CE); Value* res = - CallInst::Create(JnjvmModule::InstantiationOfArrayFunction, + CallInst::Create(module->InstantiationOfArrayFunction, args.begin(), args.end(), "", notEquals); node->addIncoming(res, notEquals); BranchInst::Create(ifTrue, notEquals); @@ -192,10 +193,10 @@ if (cl->isResolved()) { depthCl = ConstantInt::get(Type::Int32Ty, cl->depth); } else { - depthCl = CallInst::Create(JnjvmModule::GetDepthFunction, + depthCl = CallInst::Create(module->GetDepthFunction, CE, "", notEquals); } - Value* depthClObj = CallInst::Create(JnjvmModule::GetDepthFunction, + Value* depthClObj = CallInst::Create(module->GetDepthFunction, objCl, "", notEquals); Value* cmp = new ICmpInst(ICmpInst::ICMP_ULE, depthCl, depthClObj, "", notEquals); @@ -206,14 +207,14 @@ node->addIncoming(ConstantInt::getFalse(), notEquals); Value* inDisplay = - CallInst::Create(JnjvmModule::GetDisplayFunction, objCl, + CallInst::Create(module->GetDisplayFunction, objCl, "", supDepth); std::vector args; args.push_back(inDisplay); args.push_back(depthCl); Value* clInDisplay = - CallInst::Create(JnjvmModule::GetClassInDisplayFunction, + CallInst::Create(module->GetClassInDisplayFunction, args.begin(), args.end(), "", supDepth); cmp = new ICmpInst(ICmpInst::ICMP_EQ, clInDisplay, CE, "", @@ -229,7 +230,7 @@ } } - else if (V == jnjvm::JnjvmModule::GetConstantPoolAtFunction) { + else if (V == module->GetConstantPoolAtFunction) { Function* resolver = dyn_cast(Call.getArgument(0)); assert(resolver && "Wrong use of GetConstantPoolAt"); const Type* returnType = resolver->getReturnType(); @@ -259,7 +260,7 @@ indexes.end(), "", CI); arg1 = new LoadInst(arg1, "", false, CI); Value* test = new ICmpInst(ICmpInst::ICMP_EQ, arg1, - mvm::jit::constantPtrNull, "", CI); + mvm::MvmModule::constantPtrNull, "", CI); BasicBlock* trueCl = BasicBlock::Create("Ctp OK", &F); BasicBlock* falseCl = BasicBlock::Create("Ctp Not OK", &F); @@ -303,12 +304,12 @@ break; } #ifdef MULTIPLE_GC - else if (V == jnjvm::JnjvmModule::GetCollectorFunction) { + else if (V == module->GetCollectorFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantOne); - val = new BitCastInst(val, mvm::jit::ptrPtrType, "", CI); + indexes.push_back(mvm::MvmModule::constantOne); + val = new BitCastInst(val, mvm::MvmModule::ptrPtrType, "", CI); Value* CollectorPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); @@ -319,47 +320,47 @@ #endif #ifdef ISOLATE_SHARING - else if (V == jnjvm::JnjvmModule::GetCtpClassFunction) { + else if (V == module->GetCtpClassFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(jnjvm::JnjvmModule::OffsetCtpInClassConstant); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(module->OffsetCtpInClassConstant); Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* VT = new LoadInst(VTPtr, "", CI); CI->replaceAllUsesWith(VT); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetCtpCacheNodeFunction) { + } else if (V == module->GetCtpCacheNodeFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(mvm::jit::constantFour); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(mvm::MvmModule::constantFour); Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* VT = new LoadInst(VTPtr, "", CI); CI->replaceAllUsesWith(VT); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetJnjvmArrayClassFunction) { + } else if (V == module->GetJnjvmArrayClassFunction) { Changed = true; Value* val = Call.getArgument(0); Value* index = Call.getArgument(1); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(mvm::jit::constantTwo); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(mvm::MvmModule::constantTwo); indexes.push_back(index); Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* VT = new LoadInst(VTPtr, "", CI); CI->replaceAllUsesWith(VT); CI->eraseFromParent(); - } else if (V == jnjvm::JnjvmModule::GetJnjvmExceptionClassFunction) { + } else if (V == module->GetJnjvmExceptionClassFunction) { Changed = true; Value* val = Call.getArgument(0); std::vector indexes; - indexes.push_back(mvm::jit::constantZero); - indexes.push_back(mvm::jit::constantOne); + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(mvm::MvmModule::constantOne); Value* VTPtr = GetElementPtrInst::Create(val, indexes.begin(), indexes.end(), "", CI); Value* VT = new LoadInst(VTPtr, "", CI); @@ -391,6 +392,7 @@ "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; @@ -399,7 +401,7 @@ II++; if (CallInst *CI = dyn_cast(I)) { Value* V = CI->getOperand(0); - if (V == jnjvm::JnjvmModule::ForceInitialisationCheckFunction) { + if (V == module->ForceInitialisationCheckFunction) { Changed = true; CI->eraseFromParent(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Fri Oct 10 07:51:51 2008 @@ -75,7 +75,7 @@ } void Class::TRACER { - CommonClass::PARENT_TRACER; + CommonClass::CALL_TRACER; bytes->MARK_AND_TRACE; #if !defined(ISOLATE) _staticInstance->MARK_AND_TRACE; @@ -83,7 +83,7 @@ } void ClassArray::TRACER { - CommonClass::PARENT_TRACER; + CommonClass::CALL_TRACER; } void JavaObject::TRACER { @@ -181,7 +181,7 @@ #ifdef SERVICE_VM void ServiceDomain::TRACER { - JavaIsolate::PARENT_TRACER; + JavaIsolate::CALL_TRACER; classes->MARK_AND_TRACE; } #endif Modified: vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h Fri Oct 10 07:51:51 2008 @@ -22,11 +22,11 @@ #ifdef MULTIPLE_GC #define TRACER tracer(void* GC) -#define PARENT_TRACER tracer(GC) +#define CALL_TRACER tracer(GC) #define MARK_AND_TRACE markAndTrace((Collector*)GC) #else #define TRACER tracer() -#define PARENT_TRACER tracer() +#define CALL_TRACER tracer() #define MARK_AND_TRACE markAndTrace() #endif Modified: vmkit/trunk/lib/Mvm/Runtime/Disassembler.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Disassembler.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/Disassembler.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/Disassembler.cpp Fri Oct 10 07:51:51 2008 @@ -25,7 +25,7 @@ // this is the only function exported from this file -int mvm::jit::disassemble(unsigned int *addr) +int mvm::MvmModule::disassemble(unsigned int *addr) { if (!initialised) @@ -56,7 +56,7 @@ static int initialised= 0; -int mvm::jit::disassemble(unsigned int *addr) +int mvm::MvmModule::disassemble(unsigned int *addr) { if (!initialised) { @@ -74,7 +74,7 @@ #else -int mvm::jit::disassemble(unsigned int* addr) { +int mvm::MvmModule::disassemble(unsigned int* addr) { return 0; } @@ -82,7 +82,7 @@ #else -int mvm::jit::disassemble(unsigned int* addr) { +int mvm::MvmModule::disassemble(unsigned int* addr) { return 0; } Modified: vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/EscapeAnalysis.cpp Fri Oct 10 07:51:51 2008 @@ -112,7 +112,7 @@ if (CE) { ConstantInt* C = (ConstantInt*)CE->getOperand(0); VirtualTable* Table = (VirtualTable*)C->getZExtValue(); - // If the class has a finalize method, do not stack allocate the object + // If the class has a finalize method, do not stack allocate the object. if (!((void**)Table)[0]) { std::map visited; if (!(escapes(Alloc, visited))) { @@ -120,6 +120,10 @@ BitCastInst* BI = new BitCastInst(AI, Alloc->getType(), "", Alloc); DOUT << "escape" << Alloc->getParent()->getParent()->getName() << "\n"; Alloc->replaceAllUsesWith(BI); + // If it's an invoke, replace the invoke with a direct branch. + if (InvokeInst *CI = dyn_cast(Alloc)) { + BranchInst::Create(CI->getNormalDest(), Alloc); + } Alloc->eraseFromParent(); return true; } Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Fri Oct 10 07:51:51 2008 @@ -24,7 +24,6 @@ #include "mvm/Threads/Thread.h" using namespace mvm; -using namespace mvm::jit; using namespace llvm; @@ -54,95 +53,38 @@ } } -void mvm::jit::initialise() { +void MvmModule::initialise() { llvm::NoFramePointerElim = true; llvm::ExceptionHandling = true; - llvm::Module *module = globalModule = new Module("microvm"); - jit::globalModuleProvider = new ExistingModuleProvider (globalModule); - jit::memoryManager = new MvmMemoryManager(); + globalModule = new llvm::Module("bootstrap module"); + globalModuleProvider = new ExistingModuleProvider (globalModule); + memoryManager = new MvmMemoryManager(); executionEngine = ExecutionEngine::createJIT(globalModuleProvider, 0, memoryManager); - std::string str = executionEngine->getTargetData()->getStringRepresentation(); - module->setDataLayout(str); - - mvm::llvm_runtime::makeLLVMModuleContents(module); - - printFloatLLVM = module->getFunction("printFloat"); - printDoubleLLVM = module->getFunction("printDouble"); - printLongLLVM = module->getFunction("printLong"); - printIntLLVM = module->getFunction("printInt"); - printObjectLLVM = module->getFunction("printObject"); - - unwindResume = module->getFunction("_Unwind_Resume_or_Rethrow"); - - llvmGetException = module->getFunction("llvm.eh.exception"); - exceptionSelector = sizeof(void*) == 4 ? - module->getFunction("llvm.eh.selector.i32") : - module->getFunction("llvm.eh.selector.i64"); - - personality = module->getFunction("__gxx_personality_v0"); - exceptionEndCatch = module->getFunction("__cxa_end_catch"); - exceptionBeginCatch = module->getFunction("__cxa_begin_catch"); - - func_llvm_sqrt_f64 = module->getFunction("llvm.sqrt.f64"); - func_llvm_sin_f64 = module->getFunction("llvm.sin.f64"); - func_llvm_cos_f64 = module->getFunction("llvm.cos.f64"); - - func_llvm_tan_f64 = module->getFunction("tan"); - func_llvm_asin_f64 = module->getFunction("asin"); - func_llvm_acos_f64 = module->getFunction("acos"); - func_llvm_atan_f64 = module->getFunction("atan"); - func_llvm_exp_f64 = module->getFunction("exp"); - func_llvm_log_f64 = module->getFunction("log"); - func_llvm_ceil_f64 = module->getFunction("ceil"); - func_llvm_floor_f64 = module->getFunction("floor"); - func_llvm_cbrt_f64 = module->getFunction("cbrt"); - func_llvm_cosh_f64 = module->getFunction("cosh"); - func_llvm_expm1_f64 = module->getFunction("expm1"); - func_llvm_log10_f64 = module->getFunction("log10"); - func_llvm_log1p_f64 = module->getFunction("log1p"); - func_llvm_sinh_f64 = module->getFunction("sinh"); - func_llvm_tanh_f64 = module->getFunction("tanh"); - func_llvm_fabs_f64 = module->getFunction("fabs"); - func_llvm_rint_f64 = module->getFunction("rint"); - - func_llvm_hypot_f64 = module->getFunction("hypot"); - func_llvm_pow_f64 = module->getFunction("pow"); - func_llvm_atan2_f64 = module->getFunction("atan2"); - - func_llvm_fabs_f32 = module->getFunction("fabsf"); - - setjmpLLVM = module->getFunction("setjmp"); - - llvm_memcpy_i32 = module->getFunction("llvm.memcpy.i32"); - llvm_memset_i32 = module->getFunction("llvm.memset.i32"); - - llvm_atomic_lcs_i8 = module->getFunction("llvm.atomic.cmp.swap.i8.p0i8"); - llvm_atomic_lcs_i16 = module->getFunction("llvm.atomic.cmp.swap.i16.p0i16"); - llvm_atomic_lcs_i32 = module->getFunction("llvm.atomic.cmp.swap.i32.p0i32"); - llvm_atomic_lcs_i64 = module->getFunction("llvm.atomic.cmp.swap.i64.p0i64"); + Module module("unused"); + 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")); + 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")); + 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")); + module.getFunction("runtime.llvm.atomic.cmp.swap.i32")); llvm_atomic_cmp_swap_i64 = (uint64 (*)(uint64*, uint64, uint64)) (uintptr_t)executionEngine->getPointerToFunction( - module->getFunction("runtime.llvm.atomic.cmp.swap.i64")); + module.getFunction("runtime.llvm.atomic.cmp.swap.i64")); - executionEnvironment = module->getGlobalVariable("executionEnvironment"); + executionEnvironment = module.getGlobalVariable("executionEnvironment"); getExecutionEnvironment = (mvm::Thread* (*)()) (uintptr_t)executionEngine->getPointerToFunction( - module->getFunction("getExecutionEnvironment")); + module.getFunction("getExecutionEnvironment")); setExecutionEnvironment = (void (*)(mvm::Thread*)) (uintptr_t)executionEngine->getPointerToFunction( - module->getFunction("setExecutionEnvironment")); + module.getFunction("setExecutionEnvironment")); // Type declaration ptrType = PointerType::getUnqual(Type::Int8Ty); @@ -193,130 +135,145 @@ constantPtrSize = ConstantInt::get(Type::Int32Ty, sizeof(void*)); arrayPtrType = PointerType::getUnqual(ArrayType::get(Type::Int8Ty, 0)); - mvm::jit::protectEngine = mvm::Lock::allocNormal(); + protectEngine = mvm::Lock::allocNormal(); +} + + +MvmModule::MvmModule(const std::string& ModuleID) : llvm::Module(ModuleID) { + Module* module = this; + std::string str = executionEngine->getTargetData()->getStringRepresentation(); + module->setDataLayout(str); + + mvm::llvm_runtime::makeLLVMModuleContents(module); + + printFloatLLVM = module->getFunction("printFloat"); + printDoubleLLVM = module->getFunction("printDouble"); + printLongLLVM = module->getFunction("printLong"); + printIntLLVM = module->getFunction("printInt"); + printObjectLLVM = module->getFunction("printObject"); + + unwindResume = module->getFunction("_Unwind_Resume_or_Rethrow"); + + llvmGetException = module->getFunction("llvm.eh.exception"); + exceptionSelector = sizeof(void*) == 4 ? + module->getFunction("llvm.eh.selector.i32") : + module->getFunction("llvm.eh.selector.i64"); + + personality = module->getFunction("__gxx_personality_v0"); + exceptionEndCatch = module->getFunction("__cxa_end_catch"); + exceptionBeginCatch = module->getFunction("__cxa_begin_catch"); + + func_llvm_sqrt_f64 = module->getFunction("llvm.sqrt.f64"); + func_llvm_sin_f64 = module->getFunction("llvm.sin.f64"); + func_llvm_cos_f64 = module->getFunction("llvm.cos.f64"); + + func_llvm_tan_f64 = module->getFunction("tan"); + func_llvm_asin_f64 = module->getFunction("asin"); + func_llvm_acos_f64 = module->getFunction("acos"); + func_llvm_atan_f64 = module->getFunction("atan"); + func_llvm_exp_f64 = module->getFunction("exp"); + func_llvm_log_f64 = module->getFunction("log"); + func_llvm_ceil_f64 = module->getFunction("ceil"); + func_llvm_floor_f64 = module->getFunction("floor"); + func_llvm_cbrt_f64 = module->getFunction("cbrt"); + func_llvm_cosh_f64 = module->getFunction("cosh"); + func_llvm_expm1_f64 = module->getFunction("expm1"); + func_llvm_log10_f64 = module->getFunction("log10"); + func_llvm_log1p_f64 = module->getFunction("log1p"); + func_llvm_sinh_f64 = module->getFunction("sinh"); + func_llvm_tanh_f64 = module->getFunction("tanh"); + func_llvm_fabs_f64 = module->getFunction("fabs"); + func_llvm_rint_f64 = module->getFunction("rint"); + + func_llvm_hypot_f64 = module->getFunction("hypot"); + func_llvm_pow_f64 = module->getFunction("pow"); + func_llvm_atan2_f64 = module->getFunction("atan2"); + + func_llvm_fabs_f32 = module->getFunction("fabsf"); + setjmpLLVM = module->getFunction("setjmp"); + + llvm_memcpy_i32 = module->getFunction("llvm.memcpy.i32"); + llvm_memset_i32 = module->getFunction("llvm.memset.i32"); + + llvm_atomic_lcs_i8 = module->getFunction("llvm.atomic.cmp.swap.i8.p0i8"); + llvm_atomic_lcs_i16 = module->getFunction("llvm.atomic.cmp.swap.i16.p0i16"); + llvm_atomic_lcs_i32 = module->getFunction("llvm.atomic.cmp.swap.i32.p0i32"); + llvm_atomic_lcs_i64 = module->getFunction("llvm.atomic.cmp.swap.i64.p0i64"); } -llvm::Function* mvm::jit::llvm_memcpy_i32; -llvm::Function* mvm::jit::llvm_memset_i32; +llvm::ExecutionEngine* MvmModule::executionEngine; +mvm::Lock* MvmModule::protectEngine; -llvm::Function* mvm::jit::llvm_atomic_lcs_i8; -llvm::Function* mvm::jit::llvm_atomic_lcs_i16; -llvm::Function* mvm::jit::llvm_atomic_lcs_i32; -llvm::Function* mvm::jit::llvm_atomic_lcs_i64; - - -llvm::Function* mvm::jit::exceptionEndCatch; -llvm::Function* mvm::jit::exceptionBeginCatch; -llvm::Function* mvm::jit::unwindResume; -llvm::Function* mvm::jit::exceptionSelector; -llvm::Function* mvm::jit::personality; -llvm::Function* mvm::jit::llvmGetException; - -llvm::Function* mvm::jit::printFloatLLVM; -llvm::Function* mvm::jit::printDoubleLLVM; -llvm::Function* mvm::jit::printLongLLVM; -llvm::Function* mvm::jit::printIntLLVM; -llvm::Function* mvm::jit::printObjectLLVM; - -llvm::Function* mvm::jit::setjmpLLVM; - -llvm::Function* mvm::jit::func_llvm_fabs_f32; -llvm::Function* mvm::jit::func_llvm_fabs_f64; -llvm::Function* mvm::jit::func_llvm_sqrt_f64; -llvm::Function* mvm::jit::func_llvm_sin_f64; -llvm::Function* mvm::jit::func_llvm_cos_f64; -llvm::Function* mvm::jit::func_llvm_tan_f64; -llvm::Function* mvm::jit::func_llvm_asin_f64; -llvm::Function* mvm::jit::func_llvm_acos_f64; -llvm::Function* mvm::jit::func_llvm_atan_f64; -llvm::Function* mvm::jit::func_llvm_atan2_f64; -llvm::Function* mvm::jit::func_llvm_exp_f64; -llvm::Function* mvm::jit::func_llvm_log_f64; -llvm::Function* mvm::jit::func_llvm_pow_f64; -llvm::Function* mvm::jit::func_llvm_ceil_f64; -llvm::Function* mvm::jit::func_llvm_floor_f64; -llvm::Function* mvm::jit::func_llvm_rint_f64; -llvm::Function* mvm::jit::func_llvm_cbrt_f64; -llvm::Function* mvm::jit::func_llvm_cosh_f64; -llvm::Function* mvm::jit::func_llvm_expm1_f64; -llvm::Function* mvm::jit::func_llvm_hypot_f64; -llvm::Function* mvm::jit::func_llvm_log10_f64; -llvm::Function* mvm::jit::func_llvm_log1p_f64; -llvm::Function* mvm::jit::func_llvm_sinh_f64; -llvm::Function* mvm::jit::func_llvm_tanh_f64; - -llvm::ExecutionEngine* mvm::jit::executionEngine; - -mvm::Lock* mvm::jit::protectEngine; -llvm::ConstantInt* mvm::jit::constantInt8Zero; -llvm::ConstantInt* mvm::jit::constantZero; -llvm::ConstantInt* mvm::jit::constantOne; -llvm::ConstantInt* mvm::jit::constantTwo; -llvm::ConstantInt* mvm::jit::constantThree; -llvm::ConstantInt* mvm::jit::constantFour; -llvm::ConstantInt* mvm::jit::constantFive; -llvm::ConstantInt* mvm::jit::constantSix; -llvm::ConstantInt* mvm::jit::constantSeven; -llvm::ConstantInt* mvm::jit::constantEight; -llvm::ConstantInt* mvm::jit::constantMinusOne; -llvm::ConstantInt* mvm::jit::constantLongMinusOne; -llvm::ConstantInt* mvm::jit::constantLongZero; -llvm::ConstantInt* mvm::jit::constantLongOne; -llvm::ConstantInt* mvm::jit::constantMinInt; -llvm::ConstantInt* mvm::jit::constantMaxInt; -llvm::ConstantInt* mvm::jit::constantMinLong; -llvm::ConstantInt* mvm::jit::constantMaxLong; -llvm::ConstantFP* mvm::jit::constantFloatZero; -llvm::ConstantFP* mvm::jit::constantFloatOne; -llvm::ConstantFP* mvm::jit::constantFloatTwo; -llvm::ConstantFP* mvm::jit::constantDoubleZero; -llvm::ConstantFP* mvm::jit::constantDoubleOne; -llvm::ConstantFP* mvm::jit::constantMaxIntFloat; -llvm::ConstantFP* mvm::jit::constantMinIntFloat; -llvm::ConstantFP* mvm::jit::constantMinLongFloat; -llvm::ConstantFP* mvm::jit::constantMinLongDouble; -llvm::ConstantFP* mvm::jit::constantMaxLongFloat; -llvm::ConstantFP* mvm::jit::constantMaxIntDouble; -llvm::ConstantFP* mvm::jit::constantMinIntDouble; -llvm::ConstantFP* mvm::jit::constantMaxLongDouble; -llvm::ConstantFP* mvm::jit::constantDoubleInfinity; -llvm::ConstantFP* mvm::jit::constantDoubleMinusInfinity; -llvm::ConstantFP* mvm::jit::constantFloatInfinity; -llvm::ConstantFP* mvm::jit::constantFloatMinusInfinity; -llvm::ConstantFP* mvm::jit::constantFloatMinusZero; -llvm::ConstantFP* mvm::jit::constantDoubleMinusZero; -llvm::Constant* mvm::jit::constantPtrNull; -llvm::ConstantInt* mvm::jit::constantPtrSize; -const llvm::PointerType* mvm::jit::ptrType; -const llvm::PointerType* mvm::jit::ptr32Type; -const llvm::PointerType* mvm::jit::ptrPtrType; -const llvm::Type* mvm::jit::arrayPtrType; - -llvm::Module *mvm::jit::globalModule; -llvm::ExistingModuleProvider *mvm::jit::globalModuleProvider; -mvm::MvmMemoryManager *mvm::jit::memoryManager; +llvm::ConstantInt* MvmModule::constantInt8Zero; +llvm::ConstantInt* MvmModule::constantZero; +llvm::ConstantInt* MvmModule::constantOne; +llvm::ConstantInt* MvmModule::constantTwo; +llvm::ConstantInt* MvmModule::constantThree; +llvm::ConstantInt* MvmModule::constantFour; +llvm::ConstantInt* MvmModule::constantFive; +llvm::ConstantInt* MvmModule::constantSix; +llvm::ConstantInt* MvmModule::constantSeven; +llvm::ConstantInt* MvmModule::constantEight; +llvm::ConstantInt* MvmModule::constantMinusOne; +llvm::ConstantInt* MvmModule::constantLongMinusOne; +llvm::ConstantInt* MvmModule::constantLongZero; +llvm::ConstantInt* MvmModule::constantLongOne; +llvm::ConstantInt* MvmModule::constantMinInt; +llvm::ConstantInt* MvmModule::constantMaxInt; +llvm::ConstantInt* MvmModule::constantMinLong; +llvm::ConstantInt* MvmModule::constantMaxLong; +llvm::ConstantFP* MvmModule::constantFloatZero; +llvm::ConstantFP* MvmModule::constantFloatOne; +llvm::ConstantFP* MvmModule::constantFloatTwo; +llvm::ConstantFP* MvmModule::constantDoubleZero; +llvm::ConstantFP* MvmModule::constantDoubleOne; +llvm::ConstantFP* MvmModule::constantMaxIntFloat; +llvm::ConstantFP* MvmModule::constantMinIntFloat; +llvm::ConstantFP* MvmModule::constantMinLongFloat; +llvm::ConstantFP* MvmModule::constantMinLongDouble; +llvm::ConstantFP* MvmModule::constantMaxLongFloat; +llvm::ConstantFP* MvmModule::constantMaxIntDouble; +llvm::ConstantFP* MvmModule::constantMinIntDouble; +llvm::ConstantFP* MvmModule::constantMaxLongDouble; +llvm::ConstantFP* MvmModule::constantDoubleInfinity; +llvm::ConstantFP* MvmModule::constantDoubleMinusInfinity; +llvm::ConstantFP* MvmModule::constantFloatInfinity; +llvm::ConstantFP* MvmModule::constantFloatMinusInfinity; +llvm::ConstantFP* MvmModule::constantFloatMinusZero; +llvm::ConstantFP* MvmModule::constantDoubleMinusZero; +llvm::Constant* MvmModule::constantPtrNull; +llvm::ConstantInt* MvmModule::constantPtrSize; +const llvm::PointerType* MvmModule::ptrType; +const llvm::PointerType* MvmModule::ptr32Type; +const llvm::PointerType* MvmModule::ptrPtrType; +const llvm::Type* MvmModule::arrayPtrType; + +llvm::Module *MvmModule::globalModule; +llvm::ExistingModuleProvider *MvmModule::globalModuleProvider; +mvm::MvmMemoryManager *MvmModule::memoryManager; -uint8 (*mvm::jit::llvm_atomic_cmp_swap_i8) (uint8* ptr, uint8 cmp, +uint8 (*MvmModule::llvm_atomic_cmp_swap_i8) (uint8* ptr, uint8 cmp, uint8 val); -uint16 (*mvm::jit::llvm_atomic_cmp_swap_i16) (uint16* ptr, uint16 cmp, +uint16 (*MvmModule::llvm_atomic_cmp_swap_i16) (uint16* ptr, uint16 cmp, uint16 val); -uint32 (*mvm::jit::llvm_atomic_cmp_swap_i32) (uint32* ptr, uint32 cmp, +uint32 (*MvmModule::llvm_atomic_cmp_swap_i32) (uint32* ptr, uint32 cmp, uint32 val); -uint64 (*mvm::jit::llvm_atomic_cmp_swap_i64) (uint64* ptr, uint64 cmp, +uint64 (*MvmModule::llvm_atomic_cmp_swap_i64) (uint64* ptr, uint64 cmp, uint64 val); -llvm::GlobalVariable* mvm::jit::executionEnvironment; -mvm::Thread* (*mvm::jit::getExecutionEnvironment)(); -void (*mvm::jit::setExecutionEnvironment)(mvm::Thread*); +llvm::GlobalVariable* MvmModule::executionEnvironment; +mvm::Thread* (*MvmModule::getExecutionEnvironment)(); +void (*MvmModule::setExecutionEnvironment)(mvm::Thread*); -uint64 mvm::jit::getTypeSize(const llvm::Type* type) { +uint64 MvmModule::getTypeSize(const llvm::Type* type) { return executionEngine->getTargetData()->getABITypeSize(type); } -void mvm::jit::runPasses(llvm::Function* func, llvm::FunctionPassManager* pm) { +void MvmModule::runPasses(llvm::Function* func, + llvm::FunctionPassManager* pm) { pm->run(*func); } @@ -326,7 +283,7 @@ #define FRAME_IP(fp) (fp[1]) #endif -int mvm::jit::getBacktrace(void** stack, int size) { +int MvmModule::getBacktrace(void** stack, int size) { void** addr = (void**)__builtin_frame_address(0); int cpt = 0; void* baseSP = mvm::Thread::get()->baseSP; @@ -340,7 +297,7 @@ LockNormal lock; std::map pointerMap; -Code* mvm::jit::getCodeFromPointer(void* Addr) { +Code* MvmModule::getCodeFromPointer(void* Addr) { lock.lock(); std::map::iterator I = pointerMap.lower_bound(Addr); @@ -354,7 +311,7 @@ return 0; } -void mvm::jit::addMethodInfo(void* Addr, Code* C) { +void MvmModule::addMethodInfo(void* Addr, Code* C) { lock.lock(); pointerMap.insert(std::make_pair(Addr, C)); lock.unlock(); Modified: vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll (original) +++ vmkit/trunk/lib/Mvm/Runtime/LLVMRuntime.ll Fri Oct 10 07:51:51 2008 @@ -20,9 +20,9 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; declare void @_Unwind_Resume_or_Rethrow(i8*) -declare i8* @llvm.eh.exception() -declare i32 @llvm.eh.selector.i32(i8*, i8*, ...) -declare i64 @llvm.eh.selector.i64(i8*, i8*, ...) +declare i8* @llvm.eh.exception() nounwind +declare i32 @llvm.eh.selector.i32(i8*, i8*, ...) nounwind +declare i64 @llvm.eh.selector.i64(i8*, i8*, ...) nounwind declare void @__gxx_personality_v0() declare i8* @__cxa_begin_catch(i8*) declare void @__cxa_end_catch() @@ -32,9 +32,9 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Math ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -declare double @llvm.sqrt.f64(double) -declare double @llvm.sin.f64(double) -declare double @llvm.cos.f64(double) +declare double @llvm.sqrt.f64(double) nounwind +declare double @llvm.sin.f64(double) nounwind +declare double @llvm.cos.f64(double) nounwind declare double @tan(double) declare double @asin(double) declare double @acos(double) @@ -61,17 +61,17 @@ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Memory ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -declare void @llvm.memcpy.i32(i8 *, i8 *, i32, i32) -declare void @llvm.memset.i32(i8 *, i8, i32, i32) +declare void @llvm.memcpy.i32(i8 *, i8 *, i32, i32) nounwind +declare void @llvm.memset.i32(i8 *, i8, i32, i32) nounwind ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Atomic ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -declare i8 @llvm.atomic.cmp.swap.i8.p0i8(i8*, i8, i8) -declare i16 @llvm.atomic.cmp.swap.i16.p0i16(i16*, i16, i16) -declare i32 @llvm.atomic.cmp.swap.i32.p0i32(i32*, i32, i32) -declare i64 @llvm.atomic.cmp.swap.i64.p0i64(i64*, i64, i64) +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 ;;;;;;;;;;;;;;;;;;;;;;;; Modified: vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/MvmMemoryManager.cpp Fri Oct 10 07:51:51 2008 @@ -30,7 +30,7 @@ unsigned Alignment) { unsigned char* res = realMemoryManager->allocateStub(GV, StubSize, Alignment); Code* meth = new Code(); - mvm::jit::addMethodInfo((void*)(res + StubSize), meth); + MvmModule::addMethodInfo((void*)(res + StubSize), meth); currentMethod = meth; meth->FunctionStart = res; meth->FunctionEnd = res + StubSize; @@ -42,7 +42,7 @@ void MvmMemoryManager::endFunctionBody(const Function *F, unsigned char *FunctionStart, unsigned char *FunctionEnd) { - mvm::jit::addMethodInfo((void*)FunctionEnd, currentMethod); + MvmModule::addMethodInfo((void*)FunctionEnd, currentMethod); currentMethod->FunctionStart = FunctionStart; currentMethod->FunctionEnd = FunctionEnd; realMemoryManager->endFunctionBody(F, FunctionStart, FunctionEnd); Modified: vmkit/trunk/lib/N3/Mono/MonoMSCorlib.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Mono/MonoMSCorlib.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/Mono/MonoMSCorlib.cpp (original) +++ vmkit/trunk/lib/N3/Mono/MonoMSCorlib.cpp Fri Oct 10 07:51:51 2008 @@ -30,7 +30,7 @@ type->resolveType(true, false, NULL); type->resolveVT(); - uint64 size = mvm::jit::getTypeSize(type->virtualType->getContainedType(0)) + sizeof(const UTF8*) + sizeof(llvm::GlobalVariable*); + uint64 size = mvm::MvmModule::getTypeSize(type->virtualType->getContainedType(0)) + sizeof(const UTF8*) + sizeof(llvm::GlobalVariable*); type->virtualInstance = (VMObject*)gc::operator new(size, type->virtualInstance->getVirtualTable()); type->virtualInstance->initialise(type); Modified: vmkit/trunk/lib/N3/Mono/MonoString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Mono/MonoString.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/Mono/MonoString.cpp (original) +++ vmkit/trunk/lib/N3/Mono/MonoString.cpp Fri Oct 10 07:51:51 2008 @@ -48,7 +48,7 @@ if (!str->_llvmVar) { VirtualMachine* vm = VMThread::get()->vm; if (!str->_llvmVar) { - const Type* pty = mvm::jit::ptrType; + const Type* pty = mvm::MvmModule::ptrType; Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (this)), pty); Modified: vmkit/trunk/lib/N3/PNetLib/PNetMSCorlib.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/PNetLib/PNetMSCorlib.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/PNetLib/PNetMSCorlib.cpp (original) +++ vmkit/trunk/lib/N3/PNetLib/PNetMSCorlib.cpp Fri Oct 10 07:51:51 2008 @@ -30,7 +30,7 @@ type->resolveType(true, false, NULL); type->resolveVT(); - uint64 size = mvm::jit::getTypeSize(type->virtualType->getContainedType(0)) + sizeof(const UTF8*) + sizeof(llvm::GlobalVariable*); + uint64 size = mvm::MvmModule::getTypeSize(type->virtualType->getContainedType(0)) + sizeof(const UTF8*) + sizeof(llvm::GlobalVariable*); type->virtualInstance = (VMObject*)gc::operator new(size, type->virtualInstance->getVirtualTable()); type->virtualInstance->initialise(type); Modified: vmkit/trunk/lib/N3/PNetLib/PNetString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/PNetLib/PNetString.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/PNetLib/PNetString.cpp (original) +++ vmkit/trunk/lib/N3/PNetLib/PNetString.cpp Fri Oct 10 07:51:51 2008 @@ -49,7 +49,7 @@ if (!str->_llvmVar) { VirtualMachine* vm = VMThread::get()->vm; if (!str->_llvmVar) { - const Type* pty = mvm::jit::ptrType; + const Type* pty = mvm::MvmModule::ptrType; Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (this)), pty); Modified: vmkit/trunk/lib/N3/VMCore/BackTrace.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/BackTrace.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/BackTrace.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/BackTrace.cpp Fri Oct 10 07:51:51 2008 @@ -26,10 +26,10 @@ void CLIJit::printBacktrace() { int* ips[100]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 100); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 100); int n = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { VMMethod* meth = (VMMethod*)code->getMetaInfo(); if (meth) { @@ -53,10 +53,10 @@ Assembly* Assembly::getExecutingAssembly() { int* ips[5]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 5); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 5); int n = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { VMMethod* meth = (VMMethod*)code->getMetaInfo(); if (meth) { @@ -69,11 +69,11 @@ Assembly* Assembly::getCallingAssembly() { int* ips[5]; - int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 5); + int real_size = mvm::MvmModule::getBacktrace((void**)(void*)ips, 5); int n = 0; int i = 0; while (n < real_size) { - mvm::Code* code = mvm::jit::getCodeFromPointer(ips[n++]); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(ips[n++]); if (code) { VMMethod* meth = (VMMethod*)code->getMetaInfo(); if (meth && i >= 1) { Modified: vmkit/trunk/lib/N3/VMCore/CLIJit.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJit.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIJit.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLIJit.cpp Fri Oct 10 07:51:51 2008 @@ -106,7 +106,7 @@ Value* GC = ++(block->getParent()->arg_begin()); #endif - Constant* zero = mvm::jit::constantZero; + Constant* zero = mvm::MvmModule::constantZero; for (std::vector::iterator i = fields.begin(), e = fields.end(); i!= e; ++i) { VMField* field = *i; @@ -160,9 +160,9 @@ Argument* GC = ++(func->arg_begin()); #endif // Constant Definitions - Constant* const_int32_8 = mvm::jit::constantZero; - ConstantInt* const_int32_9 = mvm::jit::constantOne; - ConstantInt* const_int32_10 = mvm::jit::constantTwo; + Constant* const_int32_8 = mvm::MvmModule::constantZero; + ConstantInt* const_int32_9 = mvm::MvmModule::constantOne; + ConstantInt* const_int32_10 = mvm::MvmModule::constantTwo; // Function Definitions @@ -238,7 +238,7 @@ } - void* tracer = mvm::jit::executionEngine->getPointerToGlobal(func); + void* tracer = mvm::MvmModule::executionEngine->getPointerToGlobal(func); ((void**)res)[VT_TRACER_OFFSET] = tracer; cl->virtualTracer = func; #endif @@ -286,7 +286,7 @@ traceClass(cl, block, realArg, fields, (cl->super == MSCorlib::pValue && !stat)); ReturnInst::Create(block); - void* tracer = mvm::jit::executionEngine->getPointerToGlobal(func); + void* tracer = mvm::MvmModule::executionEngine->getPointerToGlobal(func); ((void**)res)[VT_TRACER_OFFSET] = tracer; if (!stat) { @@ -423,28 +423,28 @@ std::vector& args) { if (meth->name == N3::sqrt) { - return CallInst::Create(mvm::jit::func_llvm_sqrt_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_sqrt_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::sin) { - return CallInst::Create(mvm::jit::func_llvm_sin_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_sin_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::cos) { - return CallInst::Create(mvm::jit::func_llvm_cos_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_cos_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::exp) { - return CallInst::Create(mvm::jit::func_llvm_exp_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_exp_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::log) { - return CallInst::Create(mvm::jit::func_llvm_log_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_log_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::floor) { - return CallInst::Create(mvm::jit::func_llvm_floor_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_floor_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::log10) { - return CallInst::Create(mvm::jit::func_llvm_log10_f64, args[0], "tmp1", + return CallInst::Create(module->func_llvm_log10_f64, args[0], "tmp1", currentBlock); } else if (meth->name == N3::pow) { - Instruction* val = CallInst::Create(mvm::jit::func_llvm_pow_f64, + Instruction* val = CallInst::Create(module->func_llvm_pow_f64, args.begin(), args.end(), "tmp1", currentBlock); return val; @@ -457,6 +457,7 @@ std::vector& args, VMGenericClass* genClass, VMGenericMethod* genMethod) { CLIJit* jit = gc_new(CLIJit)(); + jit->module = meth->classDef->vm->module; jit->compilingClass = meth->classDef; jit->compilingMethod = meth; @@ -501,8 +502,8 @@ VMClassArray* base = type; for (uint32 v = 0; v < dims; ++v) { std::vector Args; - Args.push_back(mvm::jit::constantZero); - Args.push_back(mvm::jit::constantTwo); + Args.push_back(module->constantZero); + Args.push_back(module->constantTwo); Args.push_back(args[v]); obj = verifyAndComputePtr(obj, args[v], base->naturalType, true); if (v != dims - 1) { @@ -536,22 +537,22 @@ meth->classDef->name == N3::doubleName) { if (meth->name == N3::isNan) { push(new FCmpInst(FCmpInst::FCMP_UNO, Args[0], - mvm::jit::constantDoubleZero, "tmp1", currentBlock)); + module->constantDoubleZero, "tmp1", currentBlock)); return; } else if (meth->name == N3::testInfinity) { BasicBlock* endBlock = createBasicBlock("end test infinity"); BasicBlock* minusInfinity = createBasicBlock("- infinity"); BasicBlock* noInfinity = createBasicBlock("no infinity"); PHINode* node = PHINode::Create(Type::Int32Ty, "", endBlock); - node->addIncoming(mvm::jit::constantOne, currentBlock); - node->addIncoming(mvm::jit::constantMinusOne, minusInfinity); - node->addIncoming(mvm::jit::constantZero, noInfinity); + node->addIncoming(module->constantOne, currentBlock); + node->addIncoming(module->constantMinusOne, minusInfinity); + node->addIncoming(module->constantZero, noInfinity); Value* val1 = new FCmpInst(FCmpInst::FCMP_OEQ, Args[0], - mvm::jit::constantDoubleInfinity, "tmp1", + module->constantDoubleInfinity, "tmp1", currentBlock); BranchInst::Create(endBlock, minusInfinity, val1, currentBlock); Value* val2 = new FCmpInst(FCmpInst::FCMP_OEQ, Args[0], - mvm::jit::constantDoubleMinusInfinity, "tmp1", + module->constantDoubleMinusInfinity, "tmp1", minusInfinity); BranchInst::Create(endBlock, noInfinity, val2, minusInfinity); BranchInst::Create(endBlock, noInfinity); @@ -563,22 +564,22 @@ meth->classDef->name == N3::floatName) { if (meth->name == N3::isNan) { push(new FCmpInst(FCmpInst::FCMP_UNO, Args[0], - mvm::jit::constantFloatZero, "tmp1", currentBlock)); + module->constantFloatZero, "tmp1", currentBlock)); return; } else if (meth->name == N3::testInfinity) { BasicBlock* endBlock = createBasicBlock("end test infinity"); BasicBlock* minusInfinity = createBasicBlock("- infinity"); BasicBlock* noInfinity = createBasicBlock("no infinity"); PHINode* node = PHINode::Create(Type::Int32Ty, "", endBlock); - node->addIncoming(mvm::jit::constantOne, currentBlock); - node->addIncoming(mvm::jit::constantMinusOne, minusInfinity); - node->addIncoming(mvm::jit::constantZero, noInfinity); + node->addIncoming(module->constantOne, currentBlock); + node->addIncoming(module->constantMinusOne, minusInfinity); + node->addIncoming(module->constantZero, noInfinity); Value* val1 = new FCmpInst(FCmpInst::FCMP_OEQ, Args[0], - mvm::jit::constantFloatInfinity, "tmp1", + module->constantFloatInfinity, "tmp1", currentBlock); BranchInst::Create(endBlock, minusInfinity, val1, currentBlock); Value* val2 = new FCmpInst(FCmpInst::FCMP_OEQ, Args[0], - mvm::jit::constantFloatMinusInfinity, "tmp1", + module->constantFloatMinusInfinity, "tmp1", minusInfinity); BranchInst::Create(endBlock, noInfinity, val2, minusInfinity); BranchInst::Create(endBlock, noInfinity); @@ -629,14 +630,14 @@ } else if (type->super == MSCorlib::pValue || type->super == MSCorlib::pEnum) { obj = new AllocaInst(type->naturalType, "", currentBlock); - uint64 size = mvm::jit::getTypeSize(type->naturalType); + uint64 size = module->getTypeSize(type->naturalType); std::vector params; - params.push_back(new BitCastInst(obj, mvm::jit::ptrType, "", currentBlock)); - params.push_back(mvm::jit::constantInt8Zero); + params.push_back(new BitCastInst(obj, module->ptrType, "", currentBlock)); + params.push_back(module->constantInt8Zero); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memset_i32, params.begin(), params.end(), + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memset_i32, params.begin(), params.end(), "", currentBlock); } else { Value* var = new LoadInst(type->llvmVar(), "", currentBlock); @@ -683,7 +684,7 @@ currentBlock); } std::vector args; - args.push_back(mvm::jit::constantZero); + args.push_back(module->constantZero); args.push_back(field->offset); Value* ptr = GetElementPtrInst::Create(obj, args.begin(), args.end(), "", currentBlock); @@ -700,7 +701,7 @@ Value* staticCl = new BitCastInst(call, cl->staticType, "", currentBlock); std::vector args; - args.push_back(mvm::jit::constantZero); + args.push_back(module->constantZero); args.push_back(field->offset); Value* ptr = GetElementPtrInst::Create(staticCl, args.begin(), args.end(), "", currentBlock); @@ -728,7 +729,7 @@ obj = new BitCastInst(obj, field->classDef->naturalType, "", currentBlock); } std::vector args; - args.push_back(mvm::jit::constantZero); + args.push_back(module->constantZero); args.push_back(field->offset); ptr = GetElementPtrInst::Create(obj, args.begin(), args.end(), "", currentBlock); @@ -736,14 +737,14 @@ if (field->signature->super == MSCorlib::pValue && field->signature->virtualFields.size() > 1) { - uint64 size = mvm::jit::getTypeSize(field->signature->naturalType); + uint64 size = module->getTypeSize(field->signature->naturalType); std::vector params; params.push_back(new BitCastInst(ptr, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(new BitCastInst(val, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); } else { type = field->signature->naturalType; @@ -766,7 +767,7 @@ Value* staticCl = new BitCastInst(call, cl->staticType, "", currentBlock); std::vector args; - args.push_back(mvm::jit::constantZero); + args.push_back(module->constantZero); args.push_back(field->offset); Value* ptr = GetElementPtrInst::Create(staticCl, args.begin(), args.end(), "", currentBlock); @@ -844,7 +845,7 @@ currentBlock = ifTrue; } - Constant* zero = mvm::jit::constantZero; + Constant* zero = module->constantZero; Value* val = new BitCastInst(obj, arrayType, "", currentBlock); std::vector indexes; //[3]; @@ -859,11 +860,11 @@ } ConstantInt* VMArray::sizeOffset() { - return mvm::jit::constantOne; + return mvm::MvmModule::constantOne; } ConstantInt* VMArray::elementsOffset() { - return mvm::jit::constantTwo; + return mvm::MvmModule::constantTwo; } Value* CLIJit::arraySize(Value* array) { @@ -873,7 +874,7 @@ return CallInst::Create(arrayLengthLLVM, array, "", currentBlock); /* std::vector args; //size= 2 - args.push_back(mvm::jit::constantZero); + args.push_back(module->constantZero); args.push_back(VMArray::sizeOffset()); Value* ptr = GetElementPtrInst::Create(array, args.begin(), args.end(), "", currentBlock); @@ -891,13 +892,13 @@ BasicBlock* entry = createBasicBlock("entry"); obj = new BitCastInst(obj, MSCorlib::pDelegate->virtualType, "", entry); std::vector elts; - elts.push_back(mvm::jit::constantZero); - elts.push_back(mvm::jit::constantOne); + elts.push_back(module->constantZero); + elts.push_back(module->constantOne); Value* targetPtr = GetElementPtrInst::Create(obj, elts.begin(), elts.end(), "", entry); elts.pop_back(); - elts.push_back(mvm::jit::constantTwo); + elts.push_back(module->constantTwo); Value* handlePtr = GetElementPtrInst::Create(obj, elts.begin(), elts.end(), "", entry); @@ -1084,16 +1085,16 @@ } if (cur->realTest != cur->test) { - const PointerType* PointerTy_0 = mvm::jit::ptrType; + const PointerType* PointerTy_0 = module->ptrType; std::vector int32_eh_select_params; - Instruction* ptr_eh_ptr = CallInst::Create(mvm::jit::llvmGetException, + Instruction* ptr_eh_ptr = CallInst::Create(module->llvmGetException, "eh_ptr", cur->test); int32_eh_select_params.push_back(ptr_eh_ptr); Constant* C = ConstantExpr::getCast(Instruction::BitCast, - mvm::jit::personality, PointerTy_0); + module->personality, PointerTy_0); int32_eh_select_params.push_back(C); - int32_eh_select_params.push_back(mvm::jit::constantPtrNull); - CallInst::Create(mvm::jit::exceptionSelector, + int32_eh_select_params.push_back(module->constantPtrNull); + CallInst::Create(module->exceptionSelector, int32_eh_select_params.begin(), int32_eh_select_params.end(), "eh_select", cur->test); BranchInst::Create(cur->realTest, cur->test); @@ -1107,10 +1108,10 @@ Value* cpp = CallInst::Create(getCppExceptionLLVM, "", cur->handler); Value* exc = CallInst::Create(getCLIExceptionLLVM, "", cur->handler); CallInst::Create(clearExceptionLLVM, "", cur->handler); - CallInst::Create(mvm::jit::exceptionBeginCatch, cpp, "tmp8", + CallInst::Create(module->exceptionBeginCatch, cpp, "tmp8", cur->handler); std::vector void_28_params; - CallInst::Create(mvm::jit::exceptionEndCatch, void_28_params.begin(), + CallInst::Create(module->exceptionEndCatch, void_28_params.begin(), void_28_params.end(), "", cur->handler); new StoreInst(exc, supplLocal, false, cur->handler); @@ -1133,17 +1134,17 @@ llvm::Value* arg = *i; const llvm::Type* type = arg->getType(); if (type == Type::Int8Ty || type == Type::Int16Ty || type == Type::Int1Ty) { - CallInst::Create(mvm::jit::printIntLLVM, new ZExtInst(arg, Type::Int32Ty, "", insertAt), "", insertAt); + CallInst::Create(module->printIntLLVM, new ZExtInst(arg, Type::Int32Ty, "", insertAt), "", insertAt); } else if (type == Type::Int32Ty) { - CallInst::Create(mvm::jit::printIntLLVM, arg, "", insertAt); + CallInst::Create(module->printIntLLVM, arg, "", insertAt); } else if (type == Type::Int64Ty) { - CallInst::Create(mvm::jit::printLongLLVM, arg, "", insertAt); + CallInst::Create(module->printLongLLVM, arg, "", insertAt); } else if (type == Type::FloatTy) { - CallInst::Create(mvm::jit::printFloatLLVM, arg, "", insertAt); + CallInst::Create(module->printFloatLLVM, arg, "", insertAt); } else if (type == Type::DoubleTy) { - CallInst::Create(mvm::jit::printDoubleLLVM, arg, "", insertAt); + CallInst::Create(module->printDoubleLLVM, arg, "", insertAt); } else { - CallInst::Create(mvm::jit::printIntLLVM, new PtrToIntInst(arg, Type::Int32Ty, "", insertAt), "", insertAt); + CallInst::Create(module->printIntLLVM, new PtrToIntInst(arg, Type::Int32Ty, "", insertAt), "", insertAt); } } @@ -1231,15 +1232,15 @@ new StoreInst(Constant::getNullValue(cl->naturalType), alloc, false, currentBlock); } else { - uint64 size = mvm::jit::getTypeSize(cl->naturalType); + uint64 size = module->getTypeSize(cl->naturalType); std::vector params; - params.push_back(new BitCastInst(alloc, mvm::jit::ptrType, "", + params.push_back(new BitCastInst(alloc, module->ptrType, "", currentBlock)); - params.push_back(mvm::jit::constantInt8Zero); + params.push_back(module->constantInt8Zero); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memset_i32, params.begin(), + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memset_i32, params.begin(), params.end(), "", currentBlock); } @@ -1278,16 +1279,16 @@ } else if (compilingMethod->structReturn) { const Type* lastType = funcType->getContainedType(funcType->getNumContainedTypes() - 1); - uint64 size = mvm::jit::getTypeSize(lastType->getContainedType(0)); + uint64 size = module->getTypeSize(lastType->getContainedType(0)); Value* obj = --llvmFunction->arg_end(); std::vector params; - params.push_back(new BitCastInst(obj, mvm::jit::ptrType, "", + params.push_back(new BitCastInst(obj, module->ptrType, "", currentBlock)); - params.push_back(new BitCastInst(endNode, mvm::jit::ptrType, "", + params.push_back(new BitCastInst(endNode, module->ptrType, "", currentBlock)); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantFour); - CallInst::Create(mvm::jit::llvm_memcpy_i32, params.begin(), params.end(), + params.push_back(module->constantFour); + CallInst::Create(module->llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); ReturnInst::Create(currentBlock); } else { @@ -1302,7 +1303,7 @@ } else { CallInst* ptr_eh_ptr = CallInst::Create(getCppExceptionLLVM, "eh_ptr", endExceptionBlock); - CallInst::Create(mvm::jit::unwindResume, ptr_eh_ptr, "", endExceptionBlock); + CallInst::Create(module->unwindResume, ptr_eh_ptr, "", endExceptionBlock); new UnreachableInst(endExceptionBlock); } @@ -1314,7 +1315,7 @@ new UnreachableInst(unifiedUnreachable); } - mvm::jit::runPasses(llvmFunction, VMThread::get()->perFunctionPasses); + module->runPasses(llvmFunction, VMThread::get()->perFunctionPasses); if (nbe == 0 && codeLen < 50) { PRINT_DEBUG(N3_COMPILE, 1, COLOR_NORMAL, "%s can be inlined\n", @@ -1408,15 +1409,15 @@ new StoreInst(Constant::getNullValue(cl->naturalType), alloc, false, currentBlock); } else { - uint64 size = mvm::jit::getTypeSize(cl->naturalType); + uint64 size = module->getTypeSize(cl->naturalType); std::vector params; - params.push_back(new BitCastInst(alloc, mvm::jit::ptrType, "", + params.push_back(new BitCastInst(alloc, module->ptrType, "", currentBlock)); - params.push_back(mvm::jit::constantInt8Zero); + params.push_back(module->constantInt8Zero); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memset_i32, params.begin(), + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memset_i32, params.begin(), params.end(), "", currentBlock); } @@ -1453,7 +1454,7 @@ CLIJit* jit = gc_new(CLIJit)(); jit->compilingClass = cl; jit->compilingMethod = meth; - + jit->module = cl->vm->module; Function* func; meth->getSignature(dynamic_cast(meth)); @@ -1485,7 +1486,7 @@ void VMField::initField(VMObject* obj) { VMField* field = this; ConstantInt* offset = field->offset; - const TargetData* targetData = mvm::jit::executionEngine->getTargetData(); + const TargetData* targetData = mvm::MvmModule::executionEngine->getTargetData(); bool stat = isStatic(field->flags); const Type* clType = stat ? field->classDef->staticType : field->classDef->virtualType; @@ -1502,9 +1503,9 @@ } void CLIJit::initialiseAppDomain(N3* vm) { - mvm::jit::protectEngine->lock(); - mvm::jit::executionEngine->addModuleProvider(vm->TheModuleProvider); - mvm::jit::protectEngine->unlock(); + mvm::MvmModule::protectEngine->lock(); + mvm::MvmModule::executionEngine->addModuleProvider(vm->TheModuleProvider); + mvm::MvmModule::protectEngine->unlock(); } namespace n3 { @@ -1515,10 +1516,10 @@ void CLIJit::initialiseBootstrapVM(N3* vm) { - Module* module = vm->module; - mvm::jit::protectEngine->lock(); - mvm::jit::executionEngine->addModuleProvider(vm->TheModuleProvider); - mvm::jit::protectEngine->unlock(); + mvm::MvmModule* module = vm->module; + module->protectEngine->lock(); + module->executionEngine->addModuleProvider(vm->TheModuleProvider); + module->protectEngine->unlock(); n3::llvm_runtime::makeLLVMModuleContents(module); @@ -1736,7 +1737,7 @@ } void AddStandardCompilePasses(FunctionPassManager *PM) { - llvm::MutexGuard locked(mvm::jit::executionEngine->lock); + llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); // LLVM does not allow calling functions from other modules in verifier //PM->add(llvm::createVerifierPass()); // Verify that input is correct Modified: vmkit/trunk/lib/N3/VMCore/CLIJit.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJit.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIJit.h (original) +++ vmkit/trunk/lib/N3/VMCore/CLIJit.h Fri Oct 10 07:51:51 2008 @@ -10,6 +10,7 @@ #ifndef N3_CLIJit_H #define N3_CLIJit_H +#include "mvm/JIT.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" #include "mvm/Threads/Locks.h" @@ -93,6 +94,7 @@ llvm::Function* llvmFunction; VMMethod* compilingMethod; VMClass* compilingClass; + mvm::MvmModule* module; std::vector arguments; std::vector locals; Modified: vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLIJitMeta.cpp Fri Oct 10 07:51:51 2008 @@ -231,7 +231,7 @@ } } - return mvm::jit::executionEngine->runFunction(func, args); + return mvm::MvmModule::executionEngine->runFunction(func, args); } GenericValue VMMethod::operator()(VMObject* obj, va_list ap) { @@ -278,7 +278,7 @@ } } - return mvm::jit::executionEngine->runFunction(func, args); + return mvm::MvmModule::executionEngine->runFunction(func, args); } @@ -304,7 +304,7 @@ classDef->resolveType(true, true, NULL); Function* func = compiledPtr(NULL); - return mvm::jit::executionEngine->runFunction(func, args); + return mvm::MvmModule::executionEngine->runFunction(func, args); } GenericValue VMObject::operator()(VMField* field) { @@ -364,7 +364,7 @@ if (!_llvmVar) { aquire(); if (!_llvmVar) { - const Type* pty = mvm::jit::ptrType; + const Type* pty = mvm::MvmModule::ptrType; Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (this)), pty); @@ -384,7 +384,7 @@ if (!_llvmVar) { classDef->aquire(); if (!_llvmVar) { - const Type* pty = mvm::jit::ptrType; + const Type* pty = mvm::MvmModule::ptrType; Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (this)), pty); @@ -403,7 +403,7 @@ if (!_llvmVar) { classDef->aquire(); if (!_llvmVar) { - const Type* pty = mvm::jit::ptrType; + const Type* pty = mvm::MvmModule::ptrType; Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (this)), pty); @@ -420,5 +420,5 @@ } ConstantInt* VMObject::classOffset() { - return mvm::jit::constantOne; + return mvm::MvmModule::constantOne; } Modified: vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLIRuntimeJIT.cpp Fri Oct 10 07:51:51 2008 @@ -156,7 +156,7 @@ } Function* func = dmeth->compiledPtr(NULL); - rcache->methPtr = mvm::jit::executionEngine->getPointerToGlobal(func); + rcache->methPtr = mvm::MvmModule::executionEngine->getPointerToGlobal(func); rcache->lastCible = (VMClass*)ocl; rcache->box = (dmeth->classDef->super == MSCorlib::pValue); } Modified: vmkit/trunk/lib/N3/VMCore/LowerArrayLength.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/LowerArrayLength.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/LowerArrayLength.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/LowerArrayLength.cpp Fri Oct 10 07:51:51 2008 @@ -46,7 +46,7 @@ Changed = true; Value* val = CI->getOperand(1); // get the array std::vector args; //size= 2 - args.push_back(mvm::jit::constantZero); + args.push_back(mvm::MvmModule::constantZero); args.push_back(n3::VMArray::sizeOffset()); Value* ptr = GetElementPtrInst::Create(val, args.begin(), args.end(), "", CI); Modified: vmkit/trunk/lib/N3/VMCore/N3.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3.cpp Fri Oct 10 07:51:51 2008 @@ -65,9 +65,9 @@ #endif std::string str = - mvm::jit::executionEngine->getTargetData()->getStringRepresentation(); + mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation(); - vm->module = new llvm::Module("Bootstrap N3"); + vm->module = new mvm::MvmModule("Bootstrap N3"); vm->module->setDataLayout(str); vm->protectModule = mvm::Lock::allocNormal(); vm->functions = FunctionMap::allocate(); @@ -78,7 +78,7 @@ vm->bootstrapThread->baseSP = mvm::Thread::get()->baseSP; #ifdef MULTIPLE_GC vm->bootstrapThread->GC = GC; - mvm::jit::memoryManager->addGCForModule(vm->module, GC); + mvm::MvmModule::memoryManager->addGCForModule(vm->module, GC); #endif VMThread::set(vm->bootstrapThread); @@ -100,8 +100,8 @@ #endif std::string str = - mvm::jit::executionEngine->getTargetData()->getStringRepresentation(); - vm->module = new llvm::Module("App Domain"); + mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation(); + vm->module = new mvm::MvmModule("App Domain"); vm->module->setDataLayout(str); vm->protectModule = mvm::Lock::allocNormal(); vm->functions = FunctionMap::allocate(); @@ -112,7 +112,7 @@ vm->bootstrapThread->baseSP = mvm::Thread::get()->baseSP; #ifdef MULTIPLE_GC vm->bootstrapThread->GC = GC; - mvm::jit::memoryManager->addGCForModule(vm->module, GC); + mvm::MvmModule::memoryManager->addGCForModule(vm->module, GC); #endif VMThread::set(vm->bootstrapThread); Modified: vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3ModuleProvider.cpp Fri Oct 10 07:51:51 2008 @@ -31,16 +31,16 @@ return false; } else { void* res = - mvm::jit::executionEngine->getPointerToGlobalIfAvailable(meth->methPtr); + mvm::MvmModule::executionEngine->getPointerToGlobalIfAvailable(meth->methPtr); if (res == 0) { meth->classDef->aquire(); res = - mvm::jit::executionEngine->getPointerToGlobalIfAvailable(meth->methPtr); + mvm::MvmModule::executionEngine->getPointerToGlobalIfAvailable(meth->methPtr); if (res == 0) { CLIJit::compile(meth->classDef, meth); - void* res = mvm::jit::executionEngine->getPointerToGlobal(meth->methPtr); + void* res = mvm::MvmModule::executionEngine->getPointerToGlobal(meth->methPtr); meth->code = res; - mvm::Code* code = mvm::jit::getCodeFromPointer(res); + mvm::Code* code = mvm::MvmModule::getCodeFromPointer(res); code->setMetaInfo(meth); } meth->classDef->release(); Modified: vmkit/trunk/lib/N3/VMCore/Opcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/Opcodes.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/Opcodes.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/Opcodes.cpp Fri Oct 10 07:51:51 2008 @@ -162,7 +162,7 @@ } static void store(Value* val, Value* local, bool vol, - BasicBlock* currentBlock) { + BasicBlock* currentBlock, mvm::MvmModule* module) { const Type* contained = local->getType()->getContainedType(0); if (contained->isSingleValueType()) { if (val->getType() != contained) { @@ -170,32 +170,32 @@ } new StoreInst(val, local, vol, currentBlock); } else if (isa(val->getType())) { - uint64 size = mvm::jit::getTypeSize(contained); + uint64 size = module->getTypeSize(contained); std::vector params; params.push_back(new BitCastInst(local, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(new BitCastInst(val, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); } else { new StoreInst(val, local, vol, currentBlock); } } -static Value* load(Value* val, const char* name, BasicBlock* currentBlock) { +static Value* load(Value* val, const char* name, BasicBlock* currentBlock, mvm::MvmModule* module) { const Type* contained = val->getType()->getContainedType(0); if (contained->isSingleValueType()) { return new LoadInst(val, name, currentBlock); } else { - uint64 size = mvm::jit::getTypeSize(contained); + uint64 size = module->getTypeSize(contained); Value* ret = new AllocaInst(contained, "", currentBlock); std::vector params; params.push_back(new BitCastInst(ret, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(new BitCastInst(val, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); return ret; } } @@ -247,13 +247,13 @@ case ADD: { Value* val2 = pop(); - bool isPointer = (val2->getType() == mvm::jit::ptrType); + bool isPointer = (val2->getType() == module->ptrType); Value* val1 = pop(); - isPointer |= (val1->getType() == mvm::jit::ptrType); + isPointer |= (val1->getType() == module->ptrType); verifyType(val1, val2, currentBlock); Value* res = BinaryOperator::createAdd(val1, val2, "", currentBlock); if (isPointer) { - res = new IntToPtrInst(res, mvm::jit::ptrType, "", currentBlock); + res = new IntToPtrInst(res, module->ptrType, "", currentBlock); } push(res); break; @@ -767,52 +767,52 @@ } case LDC_I4_0 : { - push(mvm::jit::constantZero); + push(module->constantZero); break; } case LDC_I4_1 : { - push(mvm::jit::constantOne); + push(module->constantOne); break; } case LDC_I4_2 : { - push(mvm::jit::constantTwo); + push(module->constantTwo); break; } case LDC_I4_3 : { - push(mvm::jit::constantThree); + push(module->constantThree); break; } case LDC_I4_4 : { - push(mvm::jit::constantFour); + push(module->constantFour); break; } case LDC_I4_5 : { - push(mvm::jit::constantFive); + push(module->constantFive); break; } case LDC_I4_6 : { - push(mvm::jit::constantSix); + push(module->constantSix); break; } case LDC_I4_7 : { - push(mvm::jit::constantSeven); + push(module->constantSeven); break; } case LDC_I4_8 : { - push(mvm::jit::constantEight); + push(module->constantEight); break; } case LDC_I4_M1 : { - push(mvm::jit::constantMinusOne); + push(module->constantMinusOne); break; } @@ -895,31 +895,31 @@ } case LDLOC_S : { - Value* val = load(locals[readU1(bytecodes, i)], "", currentBlock); + Value* val = load(locals[readU1(bytecodes, i)], "", currentBlock, module); push(val); break; } case LDLOC_0 : { - Value* val = load(locals[0], "", currentBlock); + Value* val = load(locals[0], "", currentBlock, module); push(val); break; } case LDLOC_1 : { - Value* val = load(locals[1], "", currentBlock); + Value* val = load(locals[1], "", currentBlock, module); push(val); break; } case LDLOC_2 : { - Value* val = load(locals[2], "", currentBlock); + Value* val = load(locals[2], "", currentBlock, module); push(val); break; } case LDLOC_3 : { - Value* val = load(locals[3], "", currentBlock); + Value* val = load(locals[3], "", currentBlock, module); push(val); break; } @@ -1199,35 +1199,35 @@ case STLOC_S : { Value* val = pop(); Value* local = locals[readU1(bytecodes, i)]; - store(val, local, false, currentBlock); + store(val, local, false, currentBlock, module); break; } case STLOC_0 : { Value* val = pop(); Value* local = locals[0]; - store(val, local, false, currentBlock); + store(val, local, false, currentBlock, module); break; } case STLOC_1 : { Value* val = pop(); Value* local = locals[1]; - store(val, local, false, currentBlock); + store(val, local, false, currentBlock, module); break; } case STLOC_2 : { Value* val = pop(); Value* local = locals[2]; - store(val, local, false, currentBlock); + store(val, local, false, currentBlock, module); break; } case STLOC_3 : { Value* val = pop(); Value* local = locals[3]; - store(val, local, false, currentBlock); + store(val, local, false, currentBlock, module); break; } @@ -1293,8 +1293,8 @@ std::vector ptrs; - ptrs.push_back(mvm::jit::constantZero); - ptrs.push_back(mvm::jit::constantOne); + ptrs.push_back(module->constantZero); + ptrs.push_back(module->constantOne); Value* ptr = GetElementPtrInst::Create(obj, ptrs.begin(), ptrs.end(), "", currentBlock); @@ -1306,14 +1306,14 @@ } - uint64 size = mvm::jit::getTypeSize(type->naturalType); + uint64 size = module->getTypeSize(type->naturalType); std::vector params; params.push_back(new BitCastInst(ptr, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(new BitCastInst(val, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); push(obj); @@ -1351,7 +1351,7 @@ "", ifFalse); cmp = new ICmpInst(ICmpInst::ICMP_EQ, call, - mvm::jit::constantZero, "", ifFalse); + module->constantZero, "", ifFalse); BasicBlock* ex = createBasicBlock("false checkcast"); branch(cmp, ex, ifTrue, ifFalse); @@ -1408,7 +1408,7 @@ "", ifFalse); cmp = new ICmpInst(ICmpInst::ICMP_EQ, call, - mvm::jit::constantZero, "", ifFalse); + module->constantZero, "", ifFalse); BasicBlock* falseInst = createBasicBlock("false isinst"); BasicBlock* trueInst = createBasicBlock("true isinst"); @@ -1581,7 +1581,7 @@ uint32 index = value & 0xfffffff; const UTF8* utf8 = compilingClass->assembly->readUserString(index); Value* val = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, (int64_t)utf8), - mvm::jit::ptrType); + module->ptrType); Value* res = CallInst::Create(newStringLLVM, val, "", currentBlock); /*CLIString * str = (CLIString*)(((N3*)VMThread::get()->vm)->UTF8ToStr(utf8)); @@ -1802,19 +1802,19 @@ } std::vector ptrs; - ptrs.push_back(mvm::jit::constantZero); - ptrs.push_back(mvm::jit::constantOne); + ptrs.push_back(module->constantZero); + ptrs.push_back(module->constantOne); Value* ptr = GetElementPtrInst::Create(obj, ptrs.begin(), ptrs.end(), "", currentBlock); - uint64 size = mvm::jit::getTypeSize(type->naturalType); + uint64 size = module->getTypeSize(type->naturalType); std::vector params; params.push_back(new BitCastInst(val, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(new BitCastInst(ptr, PointerType::getUnqual(Type::Int8Ty), "", currentBlock)); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memcpy_i32, params.begin(), params.end(), "", currentBlock); push(val); @@ -1865,7 +1865,7 @@ args.push_back(one); args.push_back(two); args.push_back(three); - CallInst::Create(mvm::jit::llvm_memcpy_i32, + CallInst::Create(module->llvm_memcpy_i32, args.begin(), args.end(), "", currentBlock); isVolatile = false; break; @@ -1912,7 +1912,7 @@ args.push_back(one); args.push_back(two); args.push_back(three); - CallInst::Create(mvm::jit::llvm_memset_i32, + CallInst::Create(module->llvm_memset_i32, args.begin(), args.end(), "", currentBlock); isVolatile = false; break; @@ -1936,7 +1936,7 @@ case STLOC : { Value* val = pop(); Value* local = locals[readU2(bytecodes, i)]; - store(val, local, false, currentBlock); + store(val, local, false, currentBlock, module); break; } @@ -1957,15 +1957,15 @@ VMCommonClass* type = assembly->loadType(vm, token, true, false, false, true, genClass, genMethod); if (type->super == MSCorlib::pValue) { - uint64 size = mvm::jit::getTypeSize(type->naturalType); + uint64 size = module->getTypeSize(type->naturalType); std::vector params; - params.push_back(new BitCastInst(pop(), mvm::jit::ptrType, "", + params.push_back(new BitCastInst(pop(), module->ptrType, "", currentBlock)); - params.push_back(mvm::jit::constantInt8Zero); + params.push_back(module->constantInt8Zero); params.push_back(ConstantInt::get(Type::Int32Ty, size)); - params.push_back(mvm::jit::constantZero); - CallInst::Create(mvm::jit::llvm_memset_i32, params.begin(), + params.push_back(module->constantZero); + CallInst::Create(module->llvm_memset_i32, params.begin(), params.end(), "", currentBlock); } Modified: vmkit/trunk/lib/N3/VMCore/VMCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMCache.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMCache.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMCache.cpp Fri Oct 10 07:51:51 2008 @@ -87,10 +87,10 @@ Enveloppe* enveloppe = Enveloppe::allocate(origMeth); compilingMethod->caches.push_back(enveloppe); - Value* zero = mvm::jit::constantZero; - Value* one = mvm::jit::constantOne; - Value* two = mvm::jit::constantTwo; - Value* five = mvm::jit::constantFive; + Value* zero = module->constantZero; + Value* one = module->constantOne; + Value* two = module->constantTwo; + Value* five = module->constantFive; Value* llvmEnv = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (enveloppe)), Modified: vmkit/trunk/lib/N3/VMCore/VMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMClass.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMClass.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMClass.cpp Fri Oct 10 07:51:51 2008 @@ -251,7 +251,7 @@ if (meth) { llvm::Function* pred = meth->compiledPtr(genMethod); clinit_t res = (clinit_t) - (intptr_t)mvm::jit::executionEngine->getPointerToGlobal(pred); + (intptr_t)mvm::MvmModule::executionEngine->getPointerToGlobal(pred); res(); } @@ -291,7 +291,7 @@ VirtualTable* VT = CLIJit::makeVT(cl, true); - uint64 size = mvm::jit::getTypeSize(cl->staticType->getContainedType(0)); + uint64 size = mvm::MvmModule::getTypeSize(cl->staticType->getContainedType(0)); cl->staticInstance = (VMObject*)gc::operator new(size, VT); cl->staticInstance->initialise(cl); @@ -320,7 +320,7 @@ if (super == MSCorlib::pValue) { uint32 size = virtualFields.size(); if (size == 1) { - virtualFields[0]->offset = mvm::jit::constantZero; + virtualFields[0]->offset = mvm::MvmModule::constantZero; ResultTy = virtualFields[0]->signature->naturalType; } else if (size == 0) { ResultTy = Type::VoidTy; @@ -460,7 +460,7 @@ if (super != MSCorlib::pEnum && !cl->virtualInstance) { VirtualTable* VT = CLIJit::makeVT(cl, false); - uint64 size = mvm::jit::getTypeSize(cl->virtualType->getContainedType(0)); + uint64 size = mvm::MvmModule::getTypeSize(cl->virtualType->getContainedType(0)); cl->virtualInstance = (VMObject*)gc::operator new(size, VT); cl->virtualInstance->initialise(cl); @@ -614,14 +614,14 @@ } VMObject* VMClass::initialiseObject(VMObject* obj) { - uint64 size = mvm::jit::getTypeSize(virtualType->getContainedType(0)); + uint64 size = mvm::MvmModule::getTypeSize(virtualType->getContainedType(0)); memcpy(obj, virtualInstance, size); return obj; } VMObject* VMClass::doNew() { if (status < inClinit) resolveType(true, true, NULL); - uint64 size = mvm::jit::getTypeSize(virtualType->getContainedType(0)); + uint64 size = mvm::MvmModule::getTypeSize(virtualType->getContainedType(0)); VMObject* res = (VMObject*) gc::operator new(size, virtualInstance->getVirtualTable()); memcpy(res, virtualInstance, size); @@ -630,7 +630,7 @@ VMObject* VMClassArray::doNew(uint32 nb) { if (status < inClinit) resolveType(true, true, NULL); - uint64 size = mvm::jit::getTypeSize(baseClass->naturalType); + uint64 size = mvm::MvmModule::getTypeSize(baseClass->naturalType); VMArray* res = (VMArray*) gc::operator new(size * nb + sizeof(VMObject) + sizeof(sint32), arrayVT); memset(res->elements, 0, size * nb); Modified: vmkit/trunk/lib/N3/VMCore/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VirtualMachine.h?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VirtualMachine.h (original) +++ vmkit/trunk/lib/N3/VMCore/VirtualMachine.h Fri Oct 10 07:51:51 2008 @@ -14,6 +14,7 @@ #include "llvm/Function.h" +#include "mvm/JIT.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" #include "mvm/VirtualMachine.h" @@ -121,7 +122,7 @@ mvm::Lock* protectModule; FunctionMap* functions; - llvm::Module* module; + mvm::MvmModule* module; N3ModuleProvider* TheModuleProvider; VMThread* bootstrapThread; Modified: vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VirtualTables.cpp Fri Oct 10 07:51:51 2008 @@ -109,11 +109,11 @@ } void VMArray::TRACER { - VMObject::PARENT_TRACER; + VMObject::CALL_TRACER; } void ArrayObject::TRACER { - VMObject::PARENT_TRACER; + VMObject::CALL_TRACER; for (sint32 i = 0; i < size; i++) { elements[i]->MARK_AND_TRACE; } @@ -121,7 +121,7 @@ #define ARRAYTRACER(name) \ void name::TRACER { \ - VMObject::PARENT_TRACER; \ + VMObject::CALL_TRACER; \ } @@ -164,7 +164,7 @@ } void VMClass::TRACER { - VMCommonClass::PARENT_TRACER; + VMCommonClass::CALL_TRACER; staticInstance->MARK_AND_TRACE; virtualInstance->MARK_AND_TRACE; TRACE_VECTOR(VMClass*, innerClasses, std::allocator); @@ -173,17 +173,17 @@ } void VMGenericClass::TRACER { - VMClass::PARENT_TRACER; + VMClass::CALL_TRACER; TRACE_VECTOR(VMCommonClass*, genericParams, std::allocator); } void VMClassArray::TRACER { - VMCommonClass::PARENT_TRACER; + VMCommonClass::CALL_TRACER; baseClass->MARK_AND_TRACE; } void VMClassPointer::TRACER { - VMCommonClass::PARENT_TRACER; + VMCommonClass::CALL_TRACER; baseClass->MARK_AND_TRACE; } @@ -198,7 +198,7 @@ } void VMGenericMethod::TRACER { - VMMethod::PARENT_TRACER; + VMMethod::CALL_TRACER; TRACE_VECTOR(VMCommonClass*, genericParams, std::allocator); } @@ -269,7 +269,7 @@ } void N3::TRACER { - VirtualMachine::PARENT_TRACER; + VirtualMachine::CALL_TRACER; hashUTF8->MARK_AND_TRACE; hashStr->MARK_AND_TRACE; loadedAssemblies->MARK_AND_TRACE; Modified: vmkit/trunk/tools/jnjvm/Main.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/jnjvm/Main.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/tools/jnjvm/Main.cpp (original) +++ vmkit/trunk/tools/jnjvm/Main.cpp Fri Oct 10 07:51:51 2008 @@ -21,7 +21,7 @@ llvm::llvm_shutdown_obj X; int base; - jit::initialise(); + MvmModule::initialise(); Object::initialise(); Thread::initialise(); Collector::initialise(0, &base); Modified: vmkit/trunk/tools/n3-mono/Main.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/n3-mono/Main.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/tools/n3-mono/Main.cpp (original) +++ vmkit/trunk/tools/n3-mono/Main.cpp Fri Oct 10 07:51:51 2008 @@ -21,7 +21,7 @@ llvm::llvm_shutdown_obj X; int base; - jit::initialise(); + MvmModule::initialise(); Object::initialise(); Thread::initialise(); Collector::initialise(0, &base); Modified: vmkit/trunk/tools/n3-pnetlib/Main.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/n3-pnetlib/Main.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/tools/n3-pnetlib/Main.cpp (original) +++ vmkit/trunk/tools/n3-pnetlib/Main.cpp Fri Oct 10 07:51:51 2008 @@ -21,7 +21,7 @@ llvm::llvm_shutdown_obj X; int base; - jit::initialise(); + MvmModule::initialise(); Object::initialise(); Thread::initialise(); Collector::initialise(0, &base); Modified: vmkit/trunk/tools/vmkit/Launcher.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/Launcher.cpp?rev=57349&r1=57348&r2=57349&view=diff ============================================================================== --- vmkit/trunk/tools/vmkit/Launcher.cpp (original) +++ vmkit/trunk/tools/vmkit/Launcher.cpp Fri Oct 10 07:51:51 2008 @@ -44,7 +44,7 @@ llvm::llvm_shutdown_obj X; int base; - mvm::jit::initialise(); + mvm::MvmModule::initialise(); mvm::Object::initialise(); mvm::Thread::initialise(); Collector::initialise(0, &base); From nicolas.geoffray at lip6.fr Fri Oct 10 08:40:35 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 10 Oct 2008 15:40:35 -0000 Subject: [vmkit-commits] [vmkit] r57351 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaClass.h JavaInitialise.cpp JnjvmClassLoader.cpp JnjvmClassLoader.h LockedMap.h VirtualTables.cpp Message-ID: <200810101540.m9AFeape027487@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 10 10:40:35 2008 New Revision: 57351 URL: http://llvm.org/viewvc/llvm-project?rev=57351&view=rev Log: Make ClassMap non-GC allocated. Classes still need to be GC-allocated because they may be referenced by things external to the class loader. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Oct 10 10:40:35 2008 @@ -90,8 +90,7 @@ CommonClass::~CommonClass() { - free(display); - free(virtualVT); + delete display; delete lockVar; delete condVar; } @@ -107,6 +106,8 @@ ctpInfo = 0; staticVT = 0; JInfo = 0; + outerClass = 0; + innerOuterResolved = false; } Class::~Class() { @@ -142,6 +143,11 @@ delete ctpInfo; free(staticVT); + + // Currently, only regular classes have a heap allocated virtualVT. + // Array classes have a C++ allocated virtualVT and primitive classes + // do not have a virtualVT. + free(virtualVT); } JavaField::~JavaField() { @@ -257,6 +263,7 @@ CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n, bool isArray) { name = n; + this->virtualVT = 0; this->lockVar = mvm::Lock::allocRecursive(); this->condVar = mvm::Cond::allocCond(); this->status = loaded; @@ -272,7 +279,7 @@ uint32 nb) : CommonClass(loader, n, false) { - display = (CommonClass**)malloc(sizeof(CommonClass*)); + display = new CommonClass*[1]; display[0] = this; primitive = true; status = ready; @@ -286,6 +293,9 @@ super = 0; ctpInfo = 0; JInfo = 0; + outerClass = 0; + innerOuterResolved = false; + display = 0; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) _staticInstance = 0; #endif @@ -298,7 +308,7 @@ super = ClassArray::SuperArray; interfaces = ClassArray::InterfacesArray; depth = 1; - display = (CommonClass**)malloc(2 * sizeof(CommonClass*)); + display = new CommonClass*[2]; display[0] = ClassArray::SuperArray; display[1] = this; access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC; @@ -670,12 +680,12 @@ const UTF8* superUTF8 = getSuperUTF8(); if (superUTF8 == 0) { depth = 0; - display = (UserCommonClass**)malloc(sizeof(UserCommonClass*)); + display = new UserCommonClass*[1]; display[0] = this; } else { super = classLoader->loadName(superUTF8, true, true); depth = super->depth + 1; - display = (UserCommonClass**)malloc((depth + 1) * sizeof(UserCommonClass*)); + display = new UserCommonClass*[depth + 1]; memcpy(display, super->display, depth * sizeof(UserCommonClass*)); display[depth] = this; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Oct 10 10:40:35 2008 @@ -118,8 +118,9 @@ }; /// CommonClass - This class is the root class of all Java classes. It is -/// currently GC-allocated in JnJVM, but will be permanently allocated when the -/// class loader finalizer method will be defined. +/// GC-allocated because CommonClasses have to be traceable. A java/lang/Class +/// object that stays in memory has a reference to the class. Same for +/// super or interfaces. /// class CommonClass : public mvm::Object { #ifdef ISOLATE_SHARING Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Fri Oct 10 10:40:35 2008 @@ -50,7 +50,6 @@ INIT(ClassArray); INIT(JavaThread); INIT(Jnjvm); - INIT(ClassMap); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); #ifdef ISOLATE_SHARING Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Oct 10 10:40:35 2008 @@ -47,7 +47,7 @@ JCL->allocator = new JavaAllocator(); JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0); - JCL->classes = allocator_new(allocator, ClassMap)(); + JCL->classes = new ClassMap(); JCL->javaTypes = new TypeMap(); JCL->javaSignatures = new SignMap(); @@ -77,7 +77,7 @@ allocator = &(isolate->allocator); hashUTF8 = new UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); - classes = allocator_new(allocator, ClassMap)(); + classes = new ClassMap(); javaTypes = new TypeMap(); javaSignatures = new SignMap(); @@ -388,6 +388,7 @@ } JnjvmClassLoader::~JnjvmClassLoader() { + delete classes; delete hashUTF8; delete javaTypes; delete javaSignatures; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Fri Oct 10 10:40:35 2008 @@ -204,6 +204,7 @@ TheModule = 0; TheModuleProvider = 0; isolate = 0; + classes = 0; } #ifdef ISOLATE_SHARING Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Fri Oct 10 10:40:35 2008 @@ -40,7 +40,7 @@ }; template -class LockedMap : public mvm::Object { +class LockedMap { public: typedef typename std::map::iterator iterator; typedef Container (*funcCreate)(Key& V, Meta meta); @@ -130,7 +130,6 @@ class ClassMap : public LockedMap { public: - static VirtualTable* VT; ClassMap() { lock = mvm::Lock::allocNormal(); @@ -140,7 +139,6 @@ delete lock; } - virtual void TRACER; }; class StringMap { Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57351&r1=57350&r2=57351&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Fri Oct 10 10:40:35 2008 @@ -37,7 +37,6 @@ INIT(JavaObject); INIT(JavaThread); INIT(Jnjvm); - INIT(ClassMap); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); #if defined(ISOLATE_SHARING) @@ -68,6 +67,8 @@ (*i)->MARK_AND_TRACE; }} void CommonClass::TRACER { + super->MARK_AND_TRACE; + TRACE_VECTOR(Class*, gc_allocator, interfaces); classLoader->MARK_AND_TRACE; #if !defined(ISOLATE) delegatee->MARK_AND_TRACE; @@ -76,6 +77,8 @@ void Class::TRACER { CommonClass::CALL_TRACER; + TRACE_VECTOR(Class*, gc_allocator, innerClasses); + outerClass->MARK_AND_TRACE; bytes->MARK_AND_TRACE; #if !defined(ISOLATE) _staticInstance->MARK_AND_TRACE; @@ -116,20 +119,21 @@ #endif } -void ClassMap::TRACER { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { +static void traceClassMap(ClassMap* classes) { + for (ClassMap::iterator i = classes->map.begin(), e = classes->map.end(); + i!= e; ++i) { i->second->MARK_AND_TRACE; } } void JnjvmClassLoader::TRACER { javaLoader->MARK_AND_TRACE; - classes->MARK_AND_TRACE; + traceClassMap(classes); isolate->MARK_AND_TRACE; } void JnjvmBootstrapLoader::TRACER { - classes->MARK_AND_TRACE; + traceClassMap(classes); for (std::vector::iterator i = bootArchives.begin(), e = bootArchives.end(); i != e; ++i) { From nicolas.geoffray at lip6.fr Fri Oct 10 08:44:22 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 10 Oct 2008 15:44:22 -0000 Subject: [vmkit-commits] [vmkit] r57352 - /vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Message-ID: <200810101544.m9AFiMn9027653@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 10 10:44:21 2008 New Revision: 57352 URL: http://llvm.org/viewvc/llvm-project?rev=57352&view=rev Log: Fix macro. A thread does not need to trace its vm. It is already on the stack. 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=57352&r1=57351&r2=57352&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Fri Oct 10 10:44:21 2008 @@ -21,7 +21,7 @@ #ifdef SERVICE_VM #include "ServiceDomain.h" #endif -#ifdef CODE_SHARING +#ifdef ISOLATE_SHARING #include "SharedMaps.h" #include "IsolateSharedLoader.h" #endif @@ -104,8 +104,6 @@ void JavaThread::TRACER { javaThread->MARK_AND_TRACE; - // FIXME: do I need this? - isolate->MARK_AND_TRACE; if (pendingException) pendingException->MARK_AND_TRACE; } From nicolas.geoffray at lip6.fr Sat Oct 11 05:54:40 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 11 Oct 2008 12:54:40 -0000 Subject: [vmkit-commits] [vmkit] r57374 - in /vmkit/trunk: include/mvm/Allocator.h lib/JnJVM/Classpath/ClasspathVMObject.cpp lib/JnJVM/VMCore/JavaAllocator.h lib/JnJVM/VMCore/JavaArray.cpp lib/JnJVM/VMCore/JavaArray.h lib/JnJVM/VMCore/JavaClass.cpp lib/JnJVM/VMCore/JavaClass.h lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/Jnjvm.h lib/JnJVM/VMCore/JnjvmClassLoader.cpp lib/JnJVM/VMCore/JnjvmClassLoader.h lib/JnJVM/VMCore/LockedMap.cpp lib/JnJVM/VMCore/LockedMap.h lib/JnJVM/VMCore/Zip.cpp lib/JnJVM/VMCore/Zip.h Message-ID: <200810111254.m9BCsfVH022227@zion.cs.uiuc.edu> Author: geoffray Date: Sat Oct 11 07:54:38 2008 New Revision: 57374 URL: http://llvm.org/viewvc/llvm-project?rev=57374&view=rev Log: Move the Allocator to mvm, it is not jnjvm-specific. Added: vmkit/trunk/include/mvm/Allocator.h Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp vmkit/trunk/lib/JnJVM/VMCore/Zip.h Added: vmkit/trunk/include/mvm/Allocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57374&view=auto ============================================================================== --- vmkit/trunk/include/mvm/Allocator.h (added) +++ vmkit/trunk/include/mvm/Allocator.h Sat Oct 11 07:54:38 2008 @@ -0,0 +1,66 @@ +//===----------- Allocator.h - A memory allocator ------------------------===// +// +// The VMKit project +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef MVM_ALLOCATOR_H +#define MVM_ALLOCATOR_H + +#include + +#include "MvmGC.h" + +#ifdef MULTIPLE_GC +#define allocator_new(alloc, cl) collector_new(cl, alloc.GC) +#else +#define allocator_new(alloc, cl) gc_new(cl) +#endif + +namespace mvm { + + +class Allocator { +private: +#ifdef MULTIPLE_GC + Collector* GC; +#endif + +public: + +#ifndef MULTIPLE_GC + void* allocateManagedObject(unsigned int sz, VirtualTable* VT) { + return gc::operator new(sz, VT); + } +#else + void* allocateManagedObject(unsigned int sz, VirtualTable* VT) { + return gc::operator new(sz, VT, GC); + } +#endif + + void* allocatePermanentMemory(unsigned int sz) { + return malloc(sz); + } + + void freePermanentMemory(void* obj) { + return free(obj); + } +}; + +class PermanentObject { +public: + void* operator new(size_t sz, Allocator* allocator) { + return allocator->allocatePermanentMemory(sz); + } + + void operator delete(void* obj, Allocator* allocator) { + allocator->freePermanentMemory(obj); + } +}; + +} // end namespace mvm + +#endif // MVM_ALLOCATOR_H Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Sat Oct 11 07:54:38 2008 @@ -41,7 +41,7 @@ size = cl->getVirtualSize(); } JavaObject* res = (JavaObject*) - vm->allocator.allocateObject(size, src->getVirtualTable()); + vm->allocator.allocateManagedObject(size, src->getVirtualTable()); memcpy(res, src, size); res->lock = 0; return (jobject)res; Removed: vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h?rev=57373&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaAllocator.h (removed) @@ -1,45 +0,0 @@ -//===------- JavaAllocator.h - A memory allocator for Jnjvm ---------------===// -// -// JnJVM -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef JNJVM_JAVA_ALLOCATOR_H -#define JNJVM_JAVA_ALLOCATOR_H - -#include "MvmGC.h" - -#ifdef MULTIPLE_GC -#define allocator_new(alloc, cl) collector_new(cl, alloc.GC) -#else -#define allocator_new(alloc, cl) gc_new(cl) -#endif - -namespace jnjvm { - -class JavaAllocator { - -#ifdef MULTIPLE_GC - Collector* GC; -#endif - -public: - -#ifndef MULTIPLE_GC - void* allocateObject(unsigned int sz, VirtualTable* VT) { - return gc::operator new(sz, VT); - } -#else - void* allocateObject(unsigned int sz, VirtualTable* VT) { - return gc::operator new(sz, VT, GC); - } -#endif - -}; - -} // end namespace jnjvm - -#endif // JNJVM_JAVA_ALLOCATOR_H Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Sat Oct 11 07:54:38 2008 @@ -34,10 +34,6 @@ const unsigned int JavaArray::T_INT = 10; const unsigned int JavaArray::T_LONG = 11; -// This will force linking runtime methods -extern "C" void negativeArraySizeException(sint32 val); -extern "C" void outOfMemoryError(sint32 val); - void UTF8::print(mvm::PrintBuffer* buf) const { for (int i = 0; i < size; i++) buf->writeChar((char)elements[i]); @@ -55,6 +51,8 @@ return map->lookupOrCreateReader(java, len); } +// We also define a checked java to internal function to disallow +// users to load classes with '/'. const UTF8* UTF8::checkedJavaToInternal(UTF8Map* map, unsigned int start, unsigned int len) const { uint16* java = (uint16*) alloca(len * sizeof(uint16)); @@ -100,6 +98,7 @@ buf->setAt(size, 0); return buf->cString(); #else + // To bypass GC-allocation, use malloc here. Only when debugging. char* buf = (char*)malloc(size + 1); for (sint32 i = 0; i < size; ++i) { buf[i] = elements[i]; @@ -110,23 +109,18 @@ } /// Currently, this uses malloc/free. This should use a custom memory pool. -void* UTF8::operator new(size_t sz, sint32 size) { - return malloc(sz + size * sizeof(uint16)); -} - -void UTF8::operator delete(void* obj) { - free(obj); +void* UTF8::operator new(size_t sz, mvm::Allocator* allocator, sint32 size) { + return allocator->allocatePermanentMemory(sz + size * sizeof(uint16)); } - const UTF8* UTF8::acons(sint32 n, UserClassArray* cl, - JavaAllocator* allocator) { - if (n < 0) - negativeArraySizeException(n); - else if (n > JavaArray::MaxArraySize) - outOfMemoryError(n); - UTF8* res = new (n) UTF8(); + mvm::Allocator* allocator) { + assert(n >= 0 && "Creating an UTF8 with a size < 0"); + assert(n <= JavaArray::MaxArraySize && + "Creating an UTF8 with a size too big"); + + UTF8* res = new (allocator, n) UTF8(); res->initialise(cl); - res->size = n; - return (const UTF8*)res; + res->size = n; + return (const UTF8*)res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Sat Oct 11 07:54:38 2008 @@ -14,6 +14,7 @@ #ifndef JNJVM_JAVA_ARRAY_H #define JNJVM_JAVA_ARRAY_H +#include "mvm/Allocator.h" #include "mvm/PrintBuffer.h" #include "types.h" @@ -24,7 +25,6 @@ class ClassArray; class CommonClass; -class JavaAllocator; class JavaObject; class Jnjvm; @@ -117,7 +117,7 @@ /// acons - Allocates an UTF8 in permanent memory. The class argument must be /// JavaArray::ofChar. static const UTF8* acons(sint32 n, UserClassArray* cl, - JavaAllocator* allocator); + mvm::Allocator* allocator); /// internalToJava - Creates a copy of the UTF8 at its given offset and size /// woth all its '.' replaced by '/'. The JVM bytecode reference classes in @@ -165,11 +165,8 @@ /// operator new - Redefines the new operator of this class to allocate /// its objects in permanent memory, not with the garbage collector. - void* operator new(size_t sz, sint32 size); + void* operator new(size_t sz, mvm::Allocator* allocator, sint32 size); - /// operator delete - Redefines the delete operator to remove the object - /// from permanent memory. - void operator delete(void* obj); }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sat Oct 11 07:54:38 2008 @@ -340,13 +340,13 @@ return doNew(n, vm->allocator); } -JavaArray* UserClassArray::doNew(sint32 n, JavaAllocator& allocator) { +JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator& allocator) { UserCommonClass* cl = baseClass(); assert(cl && virtualVT && "array class not resolved"); uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize; - JavaArray* res = (JavaArray*)allocator.allocateObject(size, virtualVT); + JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size, virtualVT); res->initialise(this); res->size = n; return res; @@ -486,8 +486,9 @@ JavaObject* UserClass::doNew(Jnjvm* vm) { assert(this && "No class when allocating."); assert(this->isReady() && "Uninitialized class when allocating."); - JavaObject* res = (JavaObject*)vm->allocator.allocateObject(getVirtualSize(), - getVirtualVT()); + JavaObject* res = + (JavaObject*)vm->allocator.allocateManagedObject(getVirtualSize(), + getVirtualVT()); res->classOf = this; return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Sat Oct 11 07:54:38 2008 @@ -15,6 +15,7 @@ #include "types.h" +#include "mvm/Allocator.h" #include "mvm/JIT.h" #include "mvm/Method.h" #include "mvm/Object.h" @@ -23,7 +24,6 @@ #include "mvm/Threads/Locks.h" #include "JavaAccess.h" -#include "JavaAllocator.h" #include "JnjvmClassLoader.h" namespace jnjvm { @@ -708,9 +708,9 @@ /// Reader is a friend because it allocates arrays without a vm. friend class Reader; private: - /// doNew - Allocate a new array with the given loader. + /// doNew - Allocate a new array with the given allocator. /// - JavaArray* doNew(sint32 n, JavaAllocator& allocator); + JavaArray* doNew(sint32 n, mvm::Allocator& allocator); public: Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sat Oct 11 07:54:38 2008 @@ -121,8 +121,8 @@ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", printString()); JavaObject* val = - (JavaObject*)vm->allocator.allocateObject(cl->getStaticSize(), - cl->getStaticVT()); + (JavaObject*)vm->allocator.allocateManagedObject(cl->getStaticSize(), + cl->getStaticVT()); val->initialise(cl); CommonClass::field_map* map = cl->getStaticFields(); for (CommonClass::field_iterator i = map->begin(), e = map->end(); i!= e; @@ -446,7 +446,7 @@ ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, jarFile); - ZipArchive archive(bytes); + ZipArchive archive(bytes, &vm->allocator); if (archive.getOfscd() != -1) { ZipFile* file = archive.getFile(PATH_MANIFEST); if (file) { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sat Oct 11 07:54:38 2008 @@ -14,13 +14,13 @@ #include "types.h" +#include "mvm/Allocator.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" #include "mvm/VirtualMachine.h" #include "mvm/Threads/Cond.h" #include "mvm/Threads/Locks.h" -#include "JavaAllocator.h" #include "JavaTypes.h" #include "JnjvmConfig.h" @@ -231,7 +231,7 @@ /// allocator - Memory allocator of this JVM. /// - JavaAllocator allocator; + mvm::Allocator allocator; /// jniEnv - The JNI environment of this JVM. /// Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sat Oct 11 07:54:38 2008 @@ -13,7 +13,8 @@ #include "debug.h" -#include "JavaAllocator.h" +#include "mvm/Allocator.h" + #include "JavaClass.h" #include "JavaConstantPool.h" #include "JavaThread.h" @@ -44,7 +45,7 @@ JCL->TheModule = new JnjvmModule("Bootstrap JnJVM"); JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule); - JCL->allocator = new JavaAllocator(); + JCL->allocator = new mvm::Allocator(); JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0); JCL->classes = new ClassMap(); @@ -74,7 +75,7 @@ TheModuleProvider = new JnjvmModuleProvider(TheModule); bootstrapLoader = JCL.bootstrapLoader; - allocator = &(isolate->allocator); + allocator = new mvm::Allocator(); hashUTF8 = new UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); classes = new ClassMap(); @@ -426,7 +427,7 @@ ArrayUInt8* bytes = Reader::openFile(this, rp); if (bytes) { - ZipArchive *archive = new ZipArchive(bytes); + ZipArchive *archive = new(allocator) ZipArchive(bytes, allocator); if (archive) { bootArchives.push_back(archive); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sat Oct 11 07:54:38 2008 @@ -15,6 +15,7 @@ #include "types.h" +#include "mvm/Allocator.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" @@ -29,7 +30,6 @@ class ClassMap; class Classpath; class UserCommonClass; -class JavaAllocator; class JavaObject; class JavaString; class Jnjvm; @@ -96,7 +96,7 @@ /// allocator - Reference to the memory allocator, which will allocate UTF8s, /// signatures and types. /// - JavaAllocator* allocator; + mvm::Allocator* allocator; /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp Sat Oct 11 07:54:38 2008 @@ -9,7 +9,6 @@ #include -#include "JavaAllocator.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaString.h" Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Sat Oct 11 07:54:38 2008 @@ -16,6 +16,7 @@ #include "types.h" +#include "mvm/Allocator.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" #include "mvm/Threads/Locks.h" @@ -29,7 +30,6 @@ namespace jnjvm { class JavaObject; -class Allocator; struct ltutf8 { @@ -96,7 +96,7 @@ typedef std::multimap::iterator iterator; mvm::Lock* lock; - JavaAllocator* allocator; + mvm::Allocator* allocator; UserClassArray* array; std::multimap map; const UTF8* lookupOrCreateAsciiz(const char* asciiz); @@ -104,7 +104,7 @@ const UTF8* lookupAsciiz(const char* asciiz); const UTF8* lookupReader(const uint16* buf, uint32 size); - UTF8Map(JavaAllocator* A, UserClassArray* cl) { + UTF8Map(mvm::Allocator* A, UserClassArray* cl) { lock = mvm::Lock::allocNormal(); allocator = A; array = cl; @@ -113,7 +113,7 @@ ~UTF8Map() { delete lock; for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - delete(i->second); + allocator->freePermanentMemory((void*)i->second); } } Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp Sat Oct 11 07:54:38 2008 @@ -9,17 +9,19 @@ #include +#include + #include "JavaArray.h" #include "Reader.h" #include "Zip.h" using namespace jnjvm; -ZipArchive::ZipArchive(ArrayUInt8* bytes) { +ZipArchive::ZipArchive(ArrayUInt8* bytes, mvm::Allocator* allocator) { this->bytes = bytes; + this->allocator = allocator, findOfscd(); - if (ofscd > -1) - addFiles(); + if (ofscd > -1) addFiles(); } ZipFile* ZipArchive::getFile(const char* filename) { @@ -123,7 +125,7 @@ while (true) { if (memcmp(&(reader.bytes->elements[temp]), HDR_CENTRAL, 4)) return; - ZipFile* ptr = new ZipFile(); + ZipFile* ptr = new(allocator) ZipFile(); reader.cursor = temp + 4 + C_COMPRESSION_METHOD; ptr->compressionMethod = readEndianDep2(reader); @@ -144,7 +146,8 @@ (reader.max - temp) < ptr->filenameLength) return; - ptr->filename = (char*)malloc(ptr->filenameLength + 1); + ptr->filename = + (char*)allocator->allocatePermanentMemory(ptr->filenameLength + 1); memcpy(ptr->filename, &(reader.bytes->elements[temp]), ptr->filenameLength); ptr->filename[ptr->filenameLength] = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=57374&r1=57373&r2=57374&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Sat Oct 11 07:54:38 2008 @@ -12,12 +12,14 @@ #include +#include "mvm/Allocator.h" + namespace jnjvm { class ArrayUInt8; class JnjvmBootstrapLoader; -struct ZipFile { +struct ZipFile : public mvm::PermanentObject { char* filename; int ucsize; int csize; @@ -30,10 +32,12 @@ -class ZipArchive { +class ZipArchive : public mvm::PermanentObject { friend class JnjvmBootstrapLoader; private: + mvm::Allocator* allocator; + struct ltstr { bool operator()(const char* s1, const char* s2) const @@ -57,13 +61,13 @@ ~ZipArchive() { for (table_iterator I = filetable.begin(), E = filetable.end(); I != E; ++I) { - free((void*)I->first); - delete I->second; + allocator->freePermanentMemory((void*)I->first); + delete(I->second, allocator); } } int getOfscd() { return ofscd; } - ZipArchive(ArrayUInt8* bytes); + ZipArchive(ArrayUInt8* bytes, mvm::Allocator* allocator); ZipFile* getFile(const char* filename); int readFile(ArrayUInt8* array, const ZipFile* file); From nicolas.geoffray at lip6.fr Sun Oct 12 11:45:53 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 12 Oct 2008 18:45:53 -0000 Subject: [vmkit-commits] [vmkit] r57419 - in /vmkit/trunk: include/mvm/Threads/Thread.h lib/JnJVM/VMCore/JavaThread.h lib/Mvm/GCMmap2/gccollector.cpp lib/N3/VMCore/VMThread.cpp lib/N3/VMCore/VMThread.h Message-ID: <200810121845.m9CIjrlA019979@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 12 13:45:52 2008 New Revision: 57419 URL: http://llvm.org/viewvc/llvm-project?rev=57419&view=rev Log: Catch exceptions and clean them when the destructor throws an exception. Modified: vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp vmkit/trunk/lib/N3/VMCore/VMThread.cpp vmkit/trunk/lib/N3/VMCore/VMThread.h Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=57419&r1=57418&r2=57419&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Sun Oct 12 13:45:52 2008 @@ -13,6 +13,7 @@ #include "types.h" #include "MvmGC.h" +#include "mvm/Allocator.h" #include "mvm/JIT.h" #include "mvm/Threads/Key.h" @@ -64,9 +65,7 @@ static mvm::Key* threadKey; public: - /// GC - The collector of this thread. - /// - Collector* GC; + Allocator* allocator; /// baseSP - The base stack pointer. /// @@ -95,6 +94,20 @@ mvm::jit::setExecutionEnvironment(th); #endif } + +private: + + /// internalClearException - Clear any pending exception. + virtual void internalClearException() { + } + +public: + + /// clearException - Clear any pending exception of the current thread. + static void clearException() { + Thread* th = Thread::get(); + th->internalClearException(); + } }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=57419&r1=57418&r2=57419&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Sun Oct 12 13:45:52 2008 @@ -94,12 +94,6 @@ __cxa_throw(exc, 0, 0); } - static void clearException() { - JavaThread* th = JavaThread::get(); - th->pendingException = 0; - th->internalPendingException = 0; - } - static bool compareException(UserClass* cl) { JavaObject* pe = JavaThread::get()->pendingException; assert(pe && "no pending exception?"); @@ -119,6 +113,12 @@ longjmp((__jmp_buf_tag*)sjlj_buffers.back(), 1); #endif } + +private: + virtual void internalClearException() { + pendingException = 0; + internalPendingException = 0; + } }; } // end namespace jnjvm Modified: vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp?rev=57419&r1=57418&r2=57419&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/gccollector.cpp Sun Oct 12 13:45:52 2008 @@ -95,8 +95,13 @@ next = cur->next(); destructor_t dest = c->getDestructor(); - if (dest) - dest(c); + if (dest) { + try { + dest(c); + } catch(...) { + mvm::Thread::clearException(); + } + } } next = 0; Modified: vmkit/trunk/lib/N3/VMCore/VMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMThread.cpp?rev=57419&r1=57418&r2=57419&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMThread.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMThread.cpp Sun Oct 12 13:45:52 2008 @@ -94,10 +94,9 @@ __cxa_throw(exc, 0, 0); } -void VMThread::clearException() { - VMThread* th = VMThread::get(); - th->pendingException = 0; - th->internalPendingException = 0; +void VMThread::internalClearException() { + pendingException = 0; + internalPendingException = 0; } bool VMThread::compareException(VMClass* cl) { Modified: vmkit/trunk/lib/N3/VMCore/VMThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMThread.h?rev=57419&r1=57418&r2=57419&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMThread.h (original) +++ vmkit/trunk/lib/N3/VMCore/VMThread.h Sun Oct 12 13:45:52 2008 @@ -57,11 +57,13 @@ static VMObject* getCLIException(); static void* getCppException(); static void throwException(VMObject*); - static void clearException(); static bool compareException(VMClass*); llvm::FunctionPassManager* perFunctionPasses; std::vector sjlj_buffers; + +private: + virtual void internalClearException(); }; } // end namespace n3 From nicolas.geoffray at lip6.fr Sun Oct 12 11:55:14 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 12 Oct 2008 18:55:14 -0000 Subject: [vmkit-commits] [vmkit] r57421 - in /vmkit/trunk: include/mvm/Allocator.h lib/JnJVM/Classpath/ClasspathVMObject.cpp lib/JnJVM/Classpath/ClasspathVMThread.cpp lib/JnJVM/VMCore/JavaClass.cpp lib/JnJVM/VMCore/JavaClass.h lib/JnJVM/VMCore/JavaInitialise.cpp lib/JnJVM/VMCore/Jni.cpp lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/Jnjvm.h lib/JnJVM/VMCore/JnjvmClassLoader.cpp lib/JnJVM/VMCore/LockedMap.cpp lib/JnJVM/VMCore/LockedMap.h lib/JnJVM/VMCore/Reader.cpp lib/JnJVM/VMCore/Zip.h Message-ID: <200810121855.m9CItFVB020367@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 12 13:55:13 2008 New Revision: 57421 URL: http://llvm.org/viewvc/llvm-project?rev=57421&view=rev Log: Code cleanup. Inline locks in objects. Modified: vmkit/trunk/include/mvm/Allocator.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp 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/LockedMap.cpp vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp vmkit/trunk/lib/JnJVM/VMCore/Zip.h Modified: vmkit/trunk/include/mvm/Allocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Allocator.h (original) +++ vmkit/trunk/include/mvm/Allocator.h Sun Oct 12 13:55:13 2008 @@ -56,8 +56,8 @@ return allocator->allocatePermanentMemory(sz); } - void operator delete(void* obj, Allocator* allocator) { - allocator->freePermanentMemory(obj); + void operator delete(void* ptr) { + free(ptr); } }; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Sun Oct 12 13:55:13 2008 @@ -41,7 +41,7 @@ size = cl->getVirtualSize(); } JavaObject* res = (JavaObject*) - vm->allocator.allocateManagedObject(size, src->getVirtualTable()); + vm->allocator->allocateManagedObject(size, src->getVirtualTable()); memcpy(res, src, size); res->lock = 0; return (jobject)res; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Sun Oct 12 13:55:13 2008 @@ -59,15 +59,15 @@ UserClass* vmthClass = (UserClass*)vmThread->classOf; Jnjvm* isolate = intern->isolate; JavaObject* thread = isolate->upcalls->assocThread->getObjectField(vmThread); - ThreadSystem* ts = isolate->threadSystem; + ThreadSystem& ts = isolate->threadSystem; bool isDaemon = isolate->upcalls->daemon->getInt8Field(thread); intern->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; if (!isDaemon) { - ts->nonDaemonLock->lock(); - ts->nonDaemonThreads++; - ts->nonDaemonLock->unlock(); + ts.nonDaemonLock->lock(); + ts.nonDaemonThreads++; + ts.nonDaemonLock->unlock(); } #ifdef SERVICE_VM @@ -81,11 +81,11 @@ isolate->upcalls->runVMThread->invokeIntSpecial(isolate, vmthClass, vmThread); if (!isDaemon) { - ts->nonDaemonLock->lock(); - ts->nonDaemonThreads--; - if (ts->nonDaemonThreads == 0) - ts->nonDaemonVar->signal(); - ts->nonDaemonLock->unlock(); + ts.nonDaemonLock->lock(); + ts.nonDaemonThreads--; + if (ts.nonDaemonThreads == 0) + ts.nonDaemonVar->signal(); + ts.nonDaemonLock->unlock(); } #ifdef SERVICE_VM Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sun Oct 12 13:55:13 2008 @@ -340,13 +340,14 @@ return doNew(n, vm->allocator); } -JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator& allocator) { +JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator* allocator) { UserCommonClass* cl = baseClass(); assert(cl && virtualVT && "array class not resolved"); uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize; - JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size, virtualVT); + JavaArray* res = (JavaArray*)allocator->allocateManagedObject(size, + virtualVT); res->initialise(this); res->size = n; return res; @@ -487,8 +488,8 @@ assert(this && "No class when allocating."); assert(this->isReady() && "Uninitialized class when allocating."); JavaObject* res = - (JavaObject*)vm->allocator.allocateManagedObject(getVirtualSize(), - getVirtualVT()); + (JavaObject*)vm->allocator->allocateManagedObject(getVirtualSize(), + getVirtualVT()); res->classOf = this; return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Sun Oct 12 13:55:13 2008 @@ -477,7 +477,7 @@ /// isReady - Has this class been initialized? /// bool isReady() { - return status >= inClinit; + return status >= clinitParent; } /// isResolved - Has this class been resolved? @@ -710,7 +710,7 @@ private: /// doNew - Allocate a new array with the given allocator. /// - JavaArray* doNew(sint32 n, mvm::Allocator& allocator); + JavaArray* doNew(sint32 n, mvm::Allocator* allocator); public: Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sun Oct 12 13:55:13 2008 @@ -9,6 +9,7 @@ #include +#include "mvm/Allocator.h" #include "mvm/VirtualMachine.h" #include "mvm/Threads/Locks.h" #include "mvm/Threads/Thread.h" @@ -240,17 +241,13 @@ #endif } -void Jnjvm::runApplication(int argc, char** argv) { - mvm::Thread::set(this->bootstrapThread); - this->runMain(argc, argv); -} - mvm::VirtualMachine* mvm::VirtualMachine::createJVM() { #ifdef SERVICE_VM ServiceDomain* vm = ServiceDomain::allocateService(); vm->startExecution(); #else - Jnjvm* vm = Jnjvm::allocateIsolate(); + mvm::Allocator* allocator = new mvm::Allocator(); + Jnjvm* vm = gc_new(Jnjvm)(allocator); #endif return vm; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Sun Oct 12 13:55:13 2008 @@ -2206,16 +2206,16 @@ jobject NewGlobalRef(JNIEnv* env, jobject obj) { Jnjvm* vm = NativeUtil::myVM(env); - vm->globalRefsLock->lock(); + vm->globalRefsLock.lock(); vm->globalRefs.push_back((JavaObject*)obj); - vm->globalRefsLock->unlock(); + vm->globalRefsLock.unlock(); return obj; } void DeleteGlobalRef(JNIEnv* env, jobject globalRef) { Jnjvm* vm = NativeUtil::myVM(env); - vm->globalRefsLock->lock(); + vm->globalRefsLock.lock(); for (std::vector >::iterator i = vm->globalRefs.begin(), e = vm->globalRefs.end(); i!= e; ++i) { @@ -2224,7 +2224,7 @@ break; } } - vm->globalRefsLock->unlock(); + vm->globalRefsLock.unlock(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 12 13:55:13 2008 @@ -121,8 +121,8 @@ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", printString()); JavaObject* val = - (JavaObject*)vm->allocator.allocateManagedObject(cl->getStaticSize(), - cl->getStaticVT()); + (JavaObject*)vm->allocator->allocateManagedObject(cl->getStaticSize(), + cl->getStaticVT()); val->initialise(cl); CommonClass::field_map* map = cl->getStaticFields(); for (CommonClass::field_iterator i = map->begin(), e = map->end(); i!= e; @@ -144,7 +144,7 @@ } if (exc) { if (exc->classOf->isAssignableFrom(vm->upcalls->newException)) { - JavaThread::get()->isolate->initializerError(exc); + vm->initializerError(exc); } else { JavaThread::throwException(exc); } @@ -353,23 +353,19 @@ } Jnjvm::~Jnjvm() { -#ifdef MULTIPLE_GC - GC->destroy(); - delete GC; -#endif - - delete hashStr; - delete globalRefsLock; - delete threadSystem; + if (hashStr) { + hashStr->~StringMap(); + allocator->freePermanentMemory(hashStr); + } + if (hashUTF8) { + hashUTF8->~UTF8Map(); + allocator->freePermanentMemory(hashUTF8); + } } Jnjvm::Jnjvm() { -#ifdef MULTIPLE_GC - GC = 0; -#endif + hashUTF8 = 0; hashStr = 0; - globalRefsLock = 0; - threadSystem = 0; } #define PATH_MANIFEST "META-INF/MANIFEST.MF" @@ -446,7 +442,7 @@ ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, jarFile); - ZipArchive archive(bytes, &vm->allocator); + ZipArchive archive(bytes, vm->allocator); if (archive.getOfscd() != -1) { ZipFile* file = archive.getFile(PATH_MANIFEST); if (file) { @@ -643,9 +639,7 @@ void Jnjvm::print(mvm::PrintBuffer* buf) const { - buf->write("Java isolate: "); - buf->write(name); - + buf->write("Java isolate"); } JnjvmClassLoader* Jnjvm::loadAppClassLoader() { @@ -760,18 +754,18 @@ } void Jnjvm::waitForExit() { - threadSystem->nonDaemonLock->lock(); - --(threadSystem->nonDaemonThreads); + threadSystem.nonDaemonLock->lock(); + --(threadSystem.nonDaemonThreads); - while (threadSystem->nonDaemonThreads) { - threadSystem->nonDaemonVar->wait(threadSystem->nonDaemonLock); + while (threadSystem.nonDaemonThreads) { + threadSystem.nonDaemonVar->wait(threadSystem.nonDaemonLock); } - threadSystem->nonDaemonLock->unlock(); + threadSystem.nonDaemonLock->unlock(); return; } -void Jnjvm::runMain(int argc, char** argv) { +void Jnjvm::runApplication(int argc, char** argv) { ClArgumentsInfo info; info.readArgs(argc, argv, this); @@ -781,7 +775,13 @@ // " JnJVM Java Virtual Machine\n"); argv = argv + pos - 1; argc = argc - pos + 1; - + + bootstrapThread = allocator_new(&allocator, JavaThread)(); + bootstrapThread->initialise(0, this); + bootstrapThread->baseSP = mvm::Thread::get()->baseSP; + JavaThread::set(bootstrapThread); + bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; + loadBootstrap(); #ifdef SERVICE_VM ServiceDomain::initialise((ServiceDomain*)this); @@ -809,92 +809,47 @@ } } -void Jnjvm::runIsolate(const char* className, ArrayObject* args) { - int stack; - Jnjvm *isolate = allocateIsolate(&stack); - isolate->loadBootstrap(); - isolate->executeClass(className, args); - isolate->waitForExit(); -} - -Jnjvm* Jnjvm::allocateIsolate(void* sp) { - Jnjvm *isolate= gc_new(Jnjvm)(); - -#ifdef MULTIPLE_GC - isolate->GC = Collector::allocate(); -#endif - isolate->classpath = getenv("CLASSPATH"); - if (!(isolate->classpath)) { - isolate->classpath = "."; - } - - isolate->bootstrapThread = allocator_new(&isolate->allocator, JavaThread)(); - isolate->bootstrapThread->initialise(0, isolate); - void* baseSP = sp ? sp : mvm::Thread::get()->baseSP; - JavaThread::set(isolate->bootstrapThread); - -#ifdef MULTIPLE_GC - isolate->bootstrapThread->GC = isolate->GC; - isolate->GC->inject_my_thread(baseSP); -#else - if (sp) Collector::inject_my_thread(baseSP); -#endif +Jnjvm::Jnjvm(mvm::Allocator* A) { - isolate->bootstrapThread->baseSP = baseSP; - - isolate->bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; - isolate->threadSystem = new ThreadSystem(); - isolate->name = "isolate"; - isolate->appClassLoader = 0; - isolate->jniEnv = &JNI_JNIEnvTable; - isolate->javavmEnv = &JNI_JavaVMTable; + allocator = A; + classpath = getenv("CLASSPATH"); + if (!classpath) classpath = "."; + + appClassLoader = 0; + jniEnv = &JNI_JNIEnvTable; + javavmEnv = &JNI_JavaVMTable; - isolate->hashStr = new StringMap(); - isolate->globalRefsLock = mvm::Lock::allocNormal(); #ifdef ISOLATE_SHARING - isolate->initialiseStatics(); + initialiseStatics(); #endif - isolate->upcalls = isolate->bootstrapLoader->upcalls; + upcalls = bootstrapLoader->upcalls; #ifdef ISOLATE_SHARING - isolate->throwable = isolate->upcalls->newThrowable; + throwable = upcalls->newThrowable; #endif - isolate->arrayClasses[JavaArray::T_BOOLEAN - 4] = - isolate->upcalls->ArrayOfBool; - isolate->arrayClasses[JavaArray::T_BYTE - 4] = - isolate->upcalls->ArrayOfByte; - isolate->arrayClasses[JavaArray::T_CHAR - 4] = - isolate->upcalls->ArrayOfChar; - isolate->arrayClasses[JavaArray::T_SHORT - 4] = - isolate->upcalls->ArrayOfShort; - isolate->arrayClasses[JavaArray::T_INT - 4] = - isolate->upcalls->ArrayOfInt; - isolate->arrayClasses[JavaArray::T_FLOAT - 4] = - isolate->upcalls->ArrayOfFloat; - isolate->arrayClasses[JavaArray::T_LONG - 4] = - isolate->upcalls->ArrayOfLong; - isolate->arrayClasses[JavaArray::T_DOUBLE - 4] = - isolate->upcalls->ArrayOfDouble; - - isolate->primitiveMap[I_VOID] = isolate->upcalls->OfVoid; - isolate->primitiveMap[I_BOOL] = isolate->upcalls->OfBool; - isolate->primitiveMap[I_BYTE] = isolate->upcalls->OfByte; - isolate->primitiveMap[I_CHAR] = isolate->upcalls->OfChar; - isolate->primitiveMap[I_SHORT] = isolate->upcalls->OfShort; - isolate->primitiveMap[I_INT] = isolate->upcalls->OfInt; - isolate->primitiveMap[I_FLOAT] = isolate->upcalls->OfFloat; - isolate->primitiveMap[I_LONG] = isolate->upcalls->OfLong; - isolate->primitiveMap[I_DOUBLE] = isolate->upcalls->OfDouble; + arrayClasses[JavaArray::T_BOOLEAN - 4] = upcalls->ArrayOfBool; + arrayClasses[JavaArray::T_BYTE - 4] = upcalls->ArrayOfByte; + arrayClasses[JavaArray::T_CHAR - 4] = upcalls->ArrayOfChar; + arrayClasses[JavaArray::T_SHORT - 4] = upcalls->ArrayOfShort; + arrayClasses[JavaArray::T_INT - 4] = upcalls->ArrayOfInt; + arrayClasses[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat; + arrayClasses[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong; + arrayClasses[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble; + + primitiveMap[I_VOID] = upcalls->OfVoid; + primitiveMap[I_BOOL] = upcalls->OfBool; + primitiveMap[I_BYTE] = upcalls->OfByte; + primitiveMap[I_CHAR] = upcalls->OfChar; + primitiveMap[I_SHORT] = upcalls->OfShort; + primitiveMap[I_INT] = upcalls->OfInt; + primitiveMap[I_FLOAT] = upcalls->OfFloat; + primitiveMap[I_LONG] = upcalls->OfLong; + primitiveMap[I_DOUBLE] = upcalls->OfDouble; - isolate->upcalls->initialiseClasspath(bootstrapLoader); + upcalls->initialiseClasspath(bootstrapLoader); -#if defined(ISOLATE) || defined(ISOLATE_SHARING) - isolate->hashUTF8 = new UTF8Map(&isolate->allocator, - isolate->upcalls->ArrayOfChar); -#else - isolate->hashUTF8 = isolate->bootstrapLoader->hashUTF8; -#endif - return isolate; + hashStr = new(allocator) StringMap(); + hashUTF8 = new(allocator) UTF8Map(allocator, upcalls->ArrayOfChar); } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sun Oct 12 13:55:13 2008 @@ -90,12 +90,9 @@ /// class Jnjvm : public mvm::VirtualMachine { public: -#ifdef MULTIPLE_GC - /// GC - The garbage collector of this JVM. + /// allocator - Memory allocator of this JVM. /// - Collector* GC; -#endif - + mvm::Allocator* allocator; #ifdef ISOLATE_SHARING UserClass* throwable; #endif @@ -227,12 +224,8 @@ /// threadSystem - The thread system to manage non-daemon threads and /// control the end of the JVM's execution. /// - ThreadSystem* threadSystem; - - /// allocator - Memory allocator of this JVM. - /// - mvm::Allocator allocator; - + ThreadSystem threadSystem; + /// jniEnv - The JNI environment of this JVM. /// void* jniEnv; @@ -259,19 +252,15 @@ /// globalRefsLock - Lock for adding a new global reference. /// - mvm::Lock* globalRefsLock; + mvm::LockNormal globalRefsLock; - /// name - The name of this JVM. - /// - const char* name; - /// appClassLoader - The bootstrap class loader. /// JnjvmClassLoader* appClassLoader; /// hashStr - Hash map of java/lang/String objects allocated by this JVM. /// - StringMap * hashStr; + StringMap* hashStr; /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared /// by all class loaders in a no isolation configuration. @@ -340,15 +329,9 @@ return primitiveMap[id]; } - /// allocateIsolate - Allocates a new JVM. - /// - static Jnjvm* allocateIsolate(void* sp = 0); - - /// runIsolate - Runs an isolate with the given main class and with - /// these Java args. This should be called internaly by the javax.isolate - /// package. + /// Jnjvm - Allocates a new JVM. /// - static void runIsolate(const char* className, ArrayObject* args); + Jnjvm(mvm::Allocator* allocator); /// runApplication - Runs the application with the given command line. /// User-visible function, inherited by the VirtualMachine class. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 12 13:55:13 2008 @@ -47,10 +47,10 @@ JCL->allocator = new mvm::Allocator(); - JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0); - JCL->classes = new ClassMap(); - JCL->javaTypes = new TypeMap(); - JCL->javaSignatures = new SignMap(); + JCL->hashUTF8 = new(JCL->allocator) UTF8Map(JCL->allocator, 0); + JCL->classes = new(JCL->allocator) ClassMap(); + JCL->javaTypes = new(JCL->allocator) TypeMap(); + JCL->javaSignatures = new(JCL->allocator) SignMap(); JCL->bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH"); if (!JCL->bootClasspathEnv) { @@ -74,13 +74,12 @@ TheModule = new JnjvmModule("Applicative loader"); TheModuleProvider = new JnjvmModuleProvider(TheModule); bootstrapLoader = JCL.bootstrapLoader; - allocator = new mvm::Allocator(); - - hashUTF8 = new UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); - classes = new ClassMap(); - javaTypes = new TypeMap(); - javaSignatures = new SignMap(); + + hashUTF8 = new(allocator) UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); + classes = new(allocator) ClassMap(); + javaTypes = new(allocator) TypeMap(); + javaSignatures = new(allocator) SignMap(); javaLoader = loader; isolate = I; @@ -297,7 +296,7 @@ UserClass* JnjvmClassLoader::constructClass(const UTF8* name, ArrayUInt8* bytes) { assert(bytes && "constructing a class without bytes"); - classes->lock->lock(); + classes->lock.lock(); ClassMap::iterator End = classes->map.end(); ClassMap::iterator I = classes->map.find(name); UserClass* res = 0; @@ -307,7 +306,7 @@ } else { res = ((UserClass*)(I->second)); } - classes->lock->unlock(); + classes->lock.unlock(); return res; } @@ -316,7 +315,7 @@ assert(baseClass && "constructing an array class without a base class"); assert(baseClass->classLoader == this && "constructing an array with wrong loader"); - classes->lock->lock(); + classes->lock.lock(); ClassMap::iterator End = classes->map.end(); ClassMap::iterator I = classes->map.find(name); UserClassArray* res = 0; @@ -326,39 +325,29 @@ } else { res = ((UserClassArray*)(I->second)); } - classes->lock->unlock(); + classes->lock.unlock(); return res; } Typedef* JnjvmClassLoader::constructType(const UTF8* name) { + javaTypes->lock.lock(); Typedef* res = javaTypes->lookup(name); if (res == 0) { res = Typedef::constructType(name, hashUTF8, isolate); - javaTypes->lock->lock(); - Typedef* tmp = javaTypes->lookup(name); - if (tmp == 0) javaTypes->hash(name, res); - else { - delete res; - res = tmp; - } - javaTypes->lock->unlock(); + javaTypes->hash(name, res); } + javaTypes->lock.unlock(); return res; } Signdef* JnjvmClassLoader::constructSign(const UTF8* name) { + javaSignatures->lock.lock(); Signdef* res = javaSignatures->lookup(name); if (res == 0) { res = new Signdef(name, this); - javaSignatures->lock->lock(); - Signdef* tmp = javaSignatures->lookup(name); - if (tmp == 0) javaSignatures->hash(name, res); - else { - delete res; - res = tmp; - } - javaSignatures->lock->unlock(); + javaSignatures->hash(name, res); } + javaSignatures->lock.unlock(); return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.cpp Sun Oct 12 13:55:13 2008 @@ -59,7 +59,7 @@ } void UTF8Map::replace(const UTF8* oldUTF8, const UTF8* newUTF8) { - lock->lock(); + lock.lock(); uint32 key = readerHasher(oldUTF8->elements, oldUTF8->size); std::pair p = map.equal_range(key); @@ -70,7 +70,7 @@ } } map.insert(std::make_pair(key, newUTF8)); - lock->unlock(); + lock.unlock(); } @@ -78,7 +78,7 @@ sint32 size = strlen(asciiz); uint32 key = asciizHasher(asciiz, size); const UTF8* res = 0; - lock->lock(); + lock.lock(); std::pair p = map.equal_range(key); @@ -98,7 +98,7 @@ map.insert(std::make_pair(key, res)); } - lock->unlock(); + lock.unlock(); return res; } @@ -106,7 +106,7 @@ sint32 size = (sint32)len; uint32 key = readerHasher(buf, size); const UTF8* res = 0; - lock->lock(); + lock.lock(); std::pair p = map.equal_range(key); @@ -124,7 +124,7 @@ map.insert(std::make_pair(key, res)); } - lock->unlock(); + lock.unlock(); return res; } @@ -132,7 +132,7 @@ sint32 size = strlen(asciiz); uint32 key = asciizHasher(asciiz, size); const UTF8* res = 0; - lock->lock(); + lock.lock(); std::pair p = map.equal_range(key); @@ -143,7 +143,7 @@ } } - lock->unlock(); + lock.unlock(); return res; } @@ -151,7 +151,7 @@ sint32 size = (sint32)len; uint32 key = readerHasher(buf, size); const UTF8* res = 0; - lock->lock(); + lock.lock(); std::pair p = map.equal_range(key); @@ -162,7 +162,7 @@ } } - lock->unlock(); + lock.unlock(); return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Sun Oct 12 13:55:13 2008 @@ -40,48 +40,48 @@ }; template -class LockedMap { +class LockedMap : public mvm::PermanentObject { public: typedef typename std::map::iterator iterator; typedef Container (*funcCreate)(Key& V, Meta meta); - mvm::Lock* lock; + mvm::LockNormal lock; std::map > > map; inline Container lookupOrCreate(Key& V, Meta meta, funcCreate func) { - lock->lock(); + lock.lock(); iterator End = map.end(); iterator I = map.find(V); if (I == End) { Container res = func(V, meta); map.insert(std::make_pair(V, res)); - lock->unlock(); + lock.unlock(); return res; } else { - lock->unlock(); + lock.unlock(); return ((Container)(I->second)); } } inline void remove(Key V) { - lock->lock(); + lock.lock(); map.erase(V); - lock->unlock(); + lock.unlock(); } inline Container lookup(Key V) { - lock->lock(); + lock.lock(); iterator End = map.end(); iterator I = map.find(V); - lock->unlock(); + lock.unlock(); return I != End ? ((Container)(I->second)) : 0; } inline void hash(Key k, Container c) { - lock->lock(); + lock.lock(); map.insert(std::make_pair(k, c)); - lock->unlock(); + lock.unlock(); } @@ -91,11 +91,11 @@ }; -class UTF8Map { +class UTF8Map : public mvm::PermanentObject { public: typedef std::multimap::iterator iterator; - mvm::Lock* lock; + mvm::LockNormal lock; mvm::Allocator* allocator; UserClassArray* array; std::multimap map; @@ -105,13 +105,11 @@ const UTF8* lookupReader(const uint16* buf, uint32 size); UTF8Map(mvm::Allocator* A, UserClassArray* cl) { - lock = mvm::Lock::allocNormal(); allocator = A; array = cl; } ~UTF8Map() { - delete lock; for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { allocator->freePermanentMemory((void*)i->second); } @@ -131,116 +129,75 @@ public LockedMap { public: - ClassMap() { - lock = mvm::Lock::allocNormal(); - } + ClassMap() {} - ~ClassMap() { - delete lock; - } + ~ClassMap() {} }; -class StringMap { +class StringMap : + public LockedMap { public: - mvm::Lock* lock; - typedef std::map::iterator iterator; - std::map map; - - typedef JavaString* (*funcCreate)(const UTF8*& V, Jnjvm *vm); - - StringMap() { - lock = mvm::Lock::allocNormal(); - } + StringMap() {} ~StringMap() { - delete lock; for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { free(i->second); } - } - - inline JavaString* lookupOrCreate(const UTF8*& V, Jnjvm *vm, funcCreate func) { - lock->lock(); - iterator End = map.end(); - iterator I = map.find(V); - if (I == End) { - JavaString* res = func(V, vm); - map.insert(std::make_pair(V, res)); - lock->unlock(); - return res; - } else { - lock->unlock(); - return I->second; - } - } + } }; -class TypeMap { +class TypeMap : public mvm::PermanentObject { public: - mvm::Lock* lock; + mvm::LockNormal lock; std::map map; typedef std::map::iterator iterator; inline Typedef* lookup(const UTF8* V) { - lock->lock(); iterator End = map.end(); iterator I = map.find(V); - lock->unlock(); return I != End ? I->second : 0; } inline void hash(const UTF8* k, Typedef* c) { - lock->lock(); map.insert(std::make_pair(k, c)); - lock->unlock(); } - TypeMap() { - lock = mvm::Lock::allocRecursive(); - } + TypeMap() {} ~TypeMap() { for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { delete i->second; } - delete lock; } }; -class SignMap { +class SignMap : public mvm::PermanentObject { public: - mvm::Lock* lock; + mvm::LockNormal lock; std::map map; typedef std::map::iterator iterator; inline Signdef* lookup(const UTF8* V) { - lock->lock(); iterator End = map.end(); iterator I = map.find(V); - lock->unlock(); return I != End ? I->second : 0; } inline void hash(const UTF8* k, Signdef* c) { - lock->lock(); map.insert(std::make_pair(k, c)); - lock->unlock(); } - SignMap() { - lock = mvm::Lock::allocRecursive(); - } + SignMap() {} ~SignMap() { for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { delete i->second; } - delete lock; } }; Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Sun Oct 12 13:55:13 2008 @@ -33,7 +33,7 @@ long nbb = ftell(fp); fseek(fp, 0, SeekSet); UserClassArray* array = loader->upcalls->ArrayOfByte; - res = (ArrayUInt8*)array->doNew((sint32)nbb, *loader->allocator); + res = (ArrayUInt8*)array->doNew((sint32)nbb, loader->allocator); fread(res->elements, nbb, 1, fp); fclose(fp); } @@ -47,7 +47,7 @@ if (file != 0) { UserClassArray* array = loader->upcalls->ArrayOfByte; ArrayUInt8* res = - (ArrayUInt8*)array->doNew((sint32)file->ucsize, *loader->allocator); + (ArrayUInt8*)array->doNew((sint32)file->ucsize, loader->allocator); if (archive->readFile(res, file) != 0) { ret = res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=57421&r1=57420&r2=57421&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Sun Oct 12 13:55:13 2008 @@ -62,7 +62,8 @@ for (table_iterator I = filetable.begin(), E = filetable.end(); I != E; ++I) { allocator->freePermanentMemory((void*)I->first); - delete(I->second, allocator); + I->second->~ZipFile(); + allocator->freePermanentMemory((void*)I->second); } } From nicolas.geoffray at lip6.fr Mon Oct 13 05:29:02 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 13 Oct 2008 12:29:02 -0000 Subject: [vmkit-commits] [vmkit] r57436 - in /vmkit/trunk: include/mvm/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/ Message-ID: <200810131229.m9DCT3cC008232@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 13 07:29:01 2008 New Revision: 57436 URL: http://llvm.org/viewvc/llvm-project?rev=57436&view=rev Log: Isolate allocation of objects per classloader or per jvm. Modified: vmkit/trunk/include/mvm/Allocator.h vmkit/trunk/include/mvm/JIT.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h 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/JavaInitialise.cpp 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/JavaString.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/include/mvm/Allocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Allocator.h (original) +++ vmkit/trunk/include/mvm/Allocator.h Mon Oct 13 07:29:01 2008 @@ -48,6 +48,14 @@ void freePermanentMemory(void* obj) { return free(obj); } + + void* allocateTemporaryMemory(unsigned int sz) { + return malloc(sz); + } + + void freeTemporaryMemory(void* obj) { + return free(obj); + } }; class PermanentObject { Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Mon Oct 13 07:29:01 2008 @@ -24,6 +24,7 @@ #include "types.h" +#include "mvm/Allocator.h" #include "mvm/Method.h" #include "mvm/MvmMemoryManager.h" #include "mvm/Threads/Locks.h" @@ -35,7 +36,7 @@ /// JITInfo - This class can be derived from to hold private JIT-specific /// information. Objects of type are accessed/created with /// ::getInfo and destroyed when the object is destroyed. -struct JITInfo { +struct JITInfo : public mvm::PermanentObject { virtual ~JITInfo() {} }; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Mon Oct 13 07:29:01 2008 @@ -40,16 +40,11 @@ return (jobject)(JavaThread::currentThread()); } -typedef struct arg_thread_t { - JavaObject* vmThread; - JavaThread* intern; -} arg_thread_t; - -static void start(arg_thread_t* arg) { +static void start(JavaObject* vmThread) { int argc; - JavaObject* vmThread = arg->vmThread; - JavaThread* intern = arg->intern; - free(arg); + Classpath* upcalls = vmThread->classOf->classLoader->bootstrapLoader->upcalls; + JavaThread* intern = (JavaThread*)upcalls->vmdataVMThread->getObjectField(vmThread); + Jnjvm* isolate = intern->isolate; mvm::Thread::set(intern); #ifdef MULTIPLE_GC intern->GC->inject_my_thread(&argc); @@ -57,7 +52,6 @@ Collector::inject_my_thread(&argc); #endif UserClass* vmthClass = (UserClass*)vmThread->classOf; - Jnjvm* isolate = intern->isolate; JavaObject* thread = isolate->upcalls->assocThread->getObjectField(vmThread); ThreadSystem& ts = isolate->threadSystem; bool isDaemon = isolate->upcalls->daemon->getInt8Field(thread); @@ -115,14 +109,11 @@ th->initialise(javaThread, vm); vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)th); int tid = 0; - arg_thread_t* arg = (arg_thread_t*)malloc(sizeof(arg_thread_t)); - arg->intern = th; - arg->vmThread = vmThread; #ifdef MULTIPLE_GC th->GC = mvm::Thread::get()->GC; #endif - mvm::Thread::start(&tid, (int (*)(void *))start, (void*)arg); + mvm::Thread::start(&tid, (int (*)(void *))start, (void*)vmThread); } JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt( Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Mon Oct 13 07:29:01 2008 @@ -38,7 +38,8 @@ #endif jobject throwable) { Jnjvm* vm = JavaThread::get()->isolate; - int** stack = (int**)malloc(sizeof(int*) * 100); + int** stack = + (int**)vm->allocator->allocateTemporaryMemory(sizeof(int*) * 100); int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100); stack[real_size] = 0; JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); @@ -115,7 +116,7 @@ } } jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0); - free(stack); + vm->allocator->freeTemporaryMemory(stack); return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Mon Oct 13 07:29:01 2008 @@ -108,7 +108,6 @@ #endif } -/// Currently, this uses malloc/free. This should use a custom memory pool. void* UTF8::operator new(size_t sz, mvm::Allocator* allocator, sint32 size) { return allocator->allocatePermanentMemory(sz + size * sizeof(uint16)); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Mon Oct 13 07:29:01 2008 @@ -27,7 +27,6 @@ using namespace jnjvm; Enveloppe::~Enveloppe() { - delete cacheLock; CacheNode* cache = firstCache; CacheNode* next = firstCache; while(next) { @@ -41,15 +40,15 @@ lastCible = 0; methPtr = 0; next = 0; + enveloppe = E; #ifdef ISOLATE_SHARING definingCtp = 0; #endif - enveloppe = E; } Enveloppe::Enveloppe(UserConstantPool* ctp, uint32 i) { - firstCache = new CacheNode(this); - cacheLock = mvm::Lock::allocNormal(); + mvm::Allocator* 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=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Mon Oct 13 07:29:01 2008 @@ -21,6 +21,7 @@ #ifndef JNJVM_JAVA_CACHE_H #define JNJVM_JAVA_CACHE_H +#include "mvm/Allocator.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" #include "mvm/Threads/Locks.h" @@ -36,7 +37,7 @@ class UserConstantPool; /// CacheNode - A {class, method pointer} pair. -class CacheNode { +class CacheNode : public mvm::PermanentObject { public: /// methPtr - The method pointer of this cache. @@ -62,7 +63,7 @@ }; /// Enveloppe - A reference to the linked list of CacheNode. -class Enveloppe { +class Enveloppe : public mvm::PermanentObject { public: /// ~Enveloppe - Deletes all CacheNode in the linked list. @@ -79,7 +80,7 @@ /// cacheLock - The linked list may be modified by concurrent thread. This /// lock ensures that the list stays consistent. - mvm::Lock* cacheLock; + mvm::LockNormal cacheLock; /// index - The index in the constant pool of the interface method. uint32 index; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 13 07:29:01 2008 @@ -279,7 +279,8 @@ uint32 nb) : CommonClass(loader, n, false) { - display = new CommonClass*[1]; + display = (CommonClass**) + loader->allocator->allocatePermanentMemory(sizeof(CommonClass*)); display[0] = this; primitive = true; status = ready; @@ -308,7 +309,8 @@ super = ClassArray::SuperArray; interfaces = ClassArray::InterfacesArray; depth = 1; - display = new CommonClass*[2]; + display = (CommonClass**) + loader->allocator->allocatePermanentMemory(2 * sizeof(CommonClass*)); display[0] = ClassArray::SuperArray; display[1] = this; access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC; @@ -625,7 +627,7 @@ method_iterator End = map.end(); method_iterator I = map.find(CC); if (I == End) { - JavaMethod* method = new JavaMethod(); + JavaMethod* method = new(classLoader->allocator) JavaMethod(); method->name = name; method->type = type; method->classDef = (Class*)this; @@ -649,7 +651,7 @@ field_iterator End = map.end(); field_iterator I = map.find(CC); if (I == End) { - JavaField* field = new JavaField(); + JavaField* field = new(classLoader->allocator) JavaField(); field->name = name; field->type = type; field->classDef = (Class*)this; @@ -682,12 +684,15 @@ const UTF8* superUTF8 = getSuperUTF8(); if (superUTF8 == 0) { depth = 0; - display = new UserCommonClass*[1]; + display = (CommonClass**) + classLoader->allocator->allocatePermanentMemory(sizeof(CommonClass*)); display[0] = this; } else { super = classLoader->loadName(superUTF8, true, true); depth = super->depth + 1; - display = new UserCommonClass*[depth + 1]; + mvm::Allocator* allocator = classLoader->allocator; + display = (CommonClass**) + allocator->allocatePermanentMemory(sizeof(CommonClass*) * (depth + 1)); memcpy(display, super->display, depth * sizeof(UserCommonClass*)); display[depth] = this; } @@ -703,7 +708,8 @@ for (int i = 0; i < nba; i++) { const UTF8* attName = ctpInfo->UTF8At(reader.readU2()); uint32 attLen = reader.readU4(); - Attribut* att = new Attribut(attName, attLen, reader.cursor); + Attribut* att = new(classLoader->allocator) Attribut(attName, attLen, + reader.cursor); attr.push_back(att); reader.seek(attLen, Reader::SeekCur); } @@ -749,7 +755,9 @@ } minor = reader.readU2(); major = reader.readU2(); - ctpInfo = new JavaConstantPool(this, reader); + uint32 ctpSize = reader.readU2(); + ctpInfo = new(classLoader->allocator, ctpSize) JavaConstantPool(this, reader, + ctpSize); access = reader.readU2(); if (!isPublic(access)) access |= ACC_PRIVATE; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 13 07:29:01 2008 @@ -63,7 +63,7 @@ /// Attribut - This class represents JVM attributes to Java class, methods and /// fields located in the .class file. /// -class Attribut { +class Attribut : public mvm::PermanentObject { public: /// name - The name of the attribut. These are specified in the JVM book. @@ -521,6 +521,10 @@ ClassPrimitive(JnjvmClassLoader* loader, const UTF8* name, uint32 nb); static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls); + + void* operator new(size_t sz, mvm::Allocator* allocator) { + return allocator->allocatePermanentMemory(sz); + } }; @@ -690,7 +694,7 @@ template Ty *getInfo() { if (!JInfo) { - JInfo = new Ty(this); + JInfo = new(classLoader->allocator) Ty(this); } assert((void*)dynamic_cast(JInfo) == (void*)JInfo && @@ -769,7 +773,7 @@ /// JavaMethod - This class represents Java methods. /// -class JavaMethod { +class JavaMethod : public mvm::PermanentObject { friend class CommonClass; private: @@ -912,7 +916,7 @@ template Ty *getInfo() { if (!JInfo) { - JInfo = new Ty(this); + JInfo = new(classDef->classLoader->allocator) Ty(this); } assert((void*)dynamic_cast(JInfo) == (void*)JInfo && @@ -924,7 +928,7 @@ /// JavaField - This class represents a Java field. /// -class JavaField { +class JavaField : public mvm::PermanentObject { friend class CommonClass; private: /// _signature - The signature of the field. Null if not resolved. @@ -1021,7 +1025,7 @@ template Ty *getInfo() { if (!JInfo) { - JInfo = new Ty(this); + JInfo = new(classDef->classLoader->allocator) Ty(this); } assert((void*)dynamic_cast(JInfo) == (void*)JInfo && Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Oct 13 07:29:01 2008 @@ -185,16 +185,23 @@ return 2; } -JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader) { - ctpSize = reader.readU2(); + +void* JavaConstantPool::operator new(size_t sz, mvm::Allocator* allocator, + uint32 ctpSize) { + uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8)); + return allocator->allocatePermanentMemory(size); +} + +JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader, uint32 size) { + ctpSize = size; classDef = cl; - ctpRes = new void*[ctpSize]; - ctpDef = new sint32[ctpSize]; - ctpType = new uint8[ctpSize]; - memset(ctpRes, 0, sizeof(void**) * ctpSize); - memset(ctpDef, 0, sizeof(sint32) * ctpSize); - memset(ctpType, 0, sizeof(uint8) * ctpSize); + ctpType = (uint8*)((uint64)this + sizeof(JavaConstantPool)); + ctpDef = (sint32*)((uint64)ctpType + ctpSize * sizeof(uint8)); + ctpRes = (void**)((uint64)ctpDef + ctpSize * sizeof(sint32)); + + memset(ctpType, 0, + ctpSize * (sizeof(uint8) + sizeof(sint32) + sizeof(void*))); uint32 cur = 1; while (cur < ctpSize) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Mon Oct 13 07:29:01 2008 @@ -33,7 +33,7 @@ /// JavaConstantPool - This class represents a Java constant pool, a place where /// a Java class makes external references such as classes and methods and /// stores constants such as integers or UTF8s. -class JavaConstantPool { +class JavaConstantPool : public mvm::PermanentObject { public: /// classDef - The owning class of this constant pool. @@ -58,6 +58,10 @@ /// void** ctpRes; + /// operator new - Redefine the operator to allocate the arrays of a + /// constant pool inline. + void* operator new(size_t sz, mvm::Allocator* allocator, uint32 ctpSize); + /// CtpReaderClass - Reads a class entry. static uint32 CtpReaderClass(JavaConstantPool* ctp, Reader& reader, uint32 index); @@ -254,24 +258,16 @@ /// JavaConstantPool - Default constructor. /// - JavaConstantPool() { - ctpRes = 0; - ctpType = 0; - ctpDef = 0; - } + JavaConstantPool() {} /// JavaConstantPool - Reads the bytecode of the class to get /// the initial types and constants definitions. /// - JavaConstantPool(Class*, Reader& reader); + JavaConstantPool(Class*, Reader& reader, uint32 ctpSize); /// ~JavaConstantPool - Delete the constant pool. /// - ~JavaConstantPool() { - delete ctpRes; - delete ctpDef; - delete ctpType; - } + ~JavaConstantPool() {} }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Mon Oct 13 07:29:01 2008 @@ -53,6 +53,7 @@ INIT(Jnjvm); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); + INIT(LockObj); #ifdef ISOLATE_SHARING INIT(JnjvmSharedLoader); INIT(SharedClassByteMap); @@ -85,9 +86,10 @@ JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); } #endif - + + mvm::Allocator* allocator = new mvm::Allocator(); JnjvmBootstrapLoader* JCL = bootstrapLoader = - JnjvmBootstrapLoader::createBootstrapLoader(); + gc_new(JnjvmBootstrapLoader)(allocator); // Create the name of char arrays. const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Oct 13 07:29:01 2008 @@ -2018,7 +2018,9 @@ #ifndef ISOLATE_SHARING // ok now the cache - Enveloppe* enveloppe = new Enveloppe(compilingClass->ctpInfo, index); + mvm::Allocator* allocator = compilingClass->classLoader->allocator; + Enveloppe* enveloppe = + new(allocator) Enveloppe(compilingClass->ctpInfo, index); compilingMethod->caches.push_back(enveloppe); Value* llvmEnv = Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Mon Oct 13 07:29:01 2008 @@ -70,9 +70,11 @@ } LockObj* LockObj::allocate() { +#ifdef USE_GC_BOEHM LockObj* res = new LockObj(); - res->lock = mvm::Lock::allocRecursive(); - res->varcond = 0; +#else + LockObj* res = gc_new(LockObj)(); +#endif return res; } @@ -89,7 +91,7 @@ void JavaObject::overflowThinlock() { LockObj* obj = LockObj::allocate(); - mvm::LockRecursive::my_lock_all(obj->lock, 257); + mvm::LockRecursive::my_lock_all(&obj->lock, 257); lock = ((uint32)obj >> 1) | 0x80000000; } @@ -149,7 +151,7 @@ LockObj* obj = LockObj::allocate(); uint32 val = (((uint32) obj) >> 1) | 0x80000000; uint32 count = lock & 0xFF; - mvm::LockRecursive::my_lock_all(obj->lock, count + 1); + mvm::LockRecursive::my_lock_all(&obj->lock, count + 1); lock = val; return obj; } else { @@ -177,9 +179,9 @@ thread->interruptFlag = 0; thread->isolate->interruptedException(this); } else { - unsigned int recur = mvm::LockRecursive::recursion_count(l->lock); + unsigned int recur = mvm::LockRecursive::recursion_count(&l->lock); bool timeout = false; - mvm::LockRecursive::my_unlock_all(l->lock); + mvm::LockRecursive::my_unlock_all(&l->lock); JavaCond* cond = l->getCond(); cond->wait(thread); thread->state = JavaThread::StateWaiting; @@ -192,7 +194,7 @@ bool interrupted = (thread->interruptFlag != 0); mutexThread->unlock(); - mvm::LockRecursive::my_lock_all(l->lock, recur); + mvm::LockRecursive::my_lock_all(&l->lock, recur); if (interrupted || timeout) { cond->remove(thread); @@ -235,13 +237,3 @@ JavaThread::get()->isolate->illegalMonitorStateException(this); } } - -LockObj::~LockObj() { - if (varcond) delete varcond; - delete lock; -} - -LockObj::LockObj() { - varcond = 0; - lock = 0; -} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.h Mon Oct 13 07:29:01 2008 @@ -58,7 +58,7 @@ /// LockObj - This class represents a Java monitor. /// -class LockObj { +class LockObj : public mvm::Object { friend class JavaObject; @@ -67,11 +67,11 @@ /// lock - The internal lock of this object lock. /// - mvm::Lock *lock; + mvm::LockRecursive lock; /// varcond - The condition variable for wait, notify and notifyAll calls. /// - JavaCond* varcond; + JavaCond varcond; /// allocate - Allocates a lock object. Only the internal lock is allocated. /// @@ -85,32 +85,34 @@ /// acquire - Acquires the lock. /// void acquire() { - lock->lock(); + lock.lock(); } /// release - Releases the lock. /// void release() { - lock->unlock(); + lock.unlock(); } /// owner - Returns if the current thread owns this lock. /// bool owner() { - return mvm::Lock::selfOwner(lock); + return mvm::Lock::selfOwner(&lock); } /// getCond - Returns the conditation variable of this lock, allocating it /// if non-existant. /// JavaCond* getCond() { - if (!varcond) varcond = new JavaCond(); - return varcond; + return &varcond; } public: - ~LockObj(); - LockObj(); + + static VirtualTable* VT; + + ~LockObj() {} + LockObj() {} }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Mon Oct 13 07:29:01 2008 @@ -42,7 +42,7 @@ ctpInfo->resolveMethod(index, cl, utf8, sign); assert(obj->classOf->isReady() && "Class not ready in a virtual lookup."); - enveloppe->cacheLock->lock(); + enveloppe->cacheLock.lock(); CacheNode* rcache = 0; CacheNode* tmp = enveloppe->firstCache; CacheNode* last = tmp; @@ -66,7 +66,8 @@ "Class not ready in a virtual lookup."); #endif if (cache->methPtr) { - rcache = new CacheNode(enveloppe); + JnjvmClassLoader* loader = ctpInfo->classDef->classLoader; + rcache = new(loader->allocator) CacheNode(enveloppe); } else { rcache = cache; } @@ -86,7 +87,7 @@ rcache->next = f; } - enveloppe->cacheLock->unlock(); + enveloppe->cacheLock.unlock(); return rcache->methPtr; } @@ -149,7 +150,8 @@ #ifdef ISOLATE_SHARING extern "C" void* enveloppeLookup(UserClass* cl, uint32 index) { UserConstantPool* ctpInfo = cl->getConstantPool(); - Enveloppe* enveloppe = new Enveloppe(ctpInfo, index); + mvm::Allocator* allocator = cl->classLoader->allocator; + Enveloppe* enveloppe = new(allocator) Enveloppe(ctpInfo, index); ctpInfo->ctpRes[index] = enveloppe; return (void*)enveloppe; } @@ -275,7 +277,8 @@ extern "C" void* getSJLJBuffer() { JavaThread* th = JavaThread::get(); - void** buf = (void**)malloc(sizeof(jmp_buf)); + mvm::Allocator* allocator = th->isolate->allocator; + void** buf = (void**)allocator->allocatePermanentMemory(sizeof(jmp_buf)); th->sjlj_buffers.push_back((jmp_buf*)buf); return (void*)buf; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Mon Oct 13 07:29:01 2008 @@ -18,7 +18,8 @@ JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) { UserClass* cl = vm->upcalls->newString; - JavaString* res = (JavaString*)malloc(cl->getVirtualSize()); + JavaString* res = + (JavaString*)vm->allocator->allocatePermanentMemory(cl->getVirtualSize()); #ifdef ISOLATE_SHARING /// Do this for now, but we will have to change it to duplicate the UTF8. /// UTF8 that dont have a class are shared UTF8. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Mon Oct 13 07:29:01 2008 @@ -189,25 +189,6 @@ } -Typedef* Typedef::constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm) { - short int cur = name->elements[0]; - Typedef* res = 0; - switch (cur) { - case I_TAB : - res = new ArrayTypedef(name); - break; - case I_REF : - res = new ObjectTypedef(name, map); - break; - default : - UserClassPrimitive* cl = vm->getPrimitiveClass((char)name->elements[0]); - assert(cl && "No primitive"); - bool unsign = (cl == vm->upcalls->OfChar || cl == vm->upcalls->OfBool); - res = new PrimitiveTypedef(name, cl, unsign, cur); - } - return res; -} - ObjectTypedef::ObjectTypedef(const UTF8* name, UTF8Map* map) { keyName = name; pseudoAssocClassName = name->extract(map, 1, name->size - 1); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h Mon Oct 13 07:29:01 2008 @@ -12,9 +12,12 @@ #include "types.h" +#include "mvm/Allocator.h" #include "mvm/JIT.h" #include "mvm/Object.h" +#include "JnjvmClassLoader.h" + namespace jnjvm { class Classpath; @@ -65,7 +68,7 @@ /// which has not been loaded yet. Typedefs are hashed on the name of the class. /// Hashing is for memory purposes, not for comparison. /// -class Typedef { +class Typedef : public mvm::PermanentObject { public: /// keyName - The name of the Typedef. It is the representation of a class @@ -91,10 +94,6 @@ /// virtual UserCommonClass* assocClass(JnjvmClassLoader* loader) const = 0; - /// Typedef - Create a new Typedef. - /// - static Typedef* constructType(const UTF8* name, UTF8Map* map, Jnjvm* vm); - virtual bool trace() const = 0; virtual bool isPrimitive() const { @@ -195,22 +194,6 @@ return charId == I_DOUBLE; } - /// JInfo - Holds info useful for the JIT. - /// - mvm::JITInfo* JInfo; - - /// getInfo - Get the JIT info of this signature. The info is created lazely. - /// - template - Ty *getInfo() { - if (!JInfo) { - JInfo = new Ty(this); - } - - assert((void*)dynamic_cast(JInfo) == (void*)JInfo && - "Invalid concrete type or multiple inheritence for getInfo"); - return static_cast(JInfo); - } }; class ArrayTypedef : public Typedef { @@ -262,7 +245,7 @@ /// Java signature. Signdefs are hashed for memory purposes, not equality /// purposes. /// -class Signdef { +class Signdef : public mvm::PermanentObject { private: /// _staticCallBuf - A dynamically generated method which calls a static Java @@ -384,7 +367,7 @@ template Ty *getInfo() { if (!JInfo) { - JInfo = new Ty(this); + JInfo = new(initialLoader->allocator) Ty(this); } assert((void*)dynamic_cast(JInfo) == (void*)JInfo && Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Mon Oct 13 07:29:01 2008 @@ -10,13 +10,16 @@ #ifndef JNJVM_JAVA_UPCALLS_H #define JNJVM_JAVA_UPCALLS_H +#include "mvm/Allocator.h" + #include "JnjvmConfig.h" #define UPCALL_CLASS(vm, name) \ vm->loadName(vm->asciizConstructUTF8(name), false, false) #define UPCALL_PRIMITIVE_CLASS(loader, name, nb) \ - new UserClassPrimitive(loader, loader->asciizConstructUTF8(name), nb) + new(loader->allocator) \ + UserClassPrimitive(loader, loader->asciizConstructUTF8(name), nb) \ #define UPCALL_FIELD(vm, cl, name, type, acc) \ UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \ @@ -54,7 +57,7 @@ class Class; class ClassArray; -class Classpath { +class Classpath : public mvm::PermanentObject { public: ISOLATE_STATIC UserClass* newClassLoader; ISOLATE_STATIC JavaMethod* getSystemClassLoader; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 13 07:29:01 2008 @@ -411,7 +411,8 @@ } -static char* findInformation(ArrayUInt8* manifest, const char* entry, uint32 len) { +static char* findInformation(Jnjvm* vm, ArrayUInt8* manifest, const char* entry, + uint32 len) { uint8* ptr = manifest->elements; sint32 index = sys_strnstr((char*)ptr, entry); if (index != -1) { @@ -421,7 +422,7 @@ else end += index; sint32 length = end - index - 1; - char* name = (char*)malloc(length + 1); + char* name = (char*)vm->allocator->allocatePermanentMemory(length + 1); memcpy(name, &(ptr[index]), length); name[length] = 0; return name; @@ -433,14 +434,13 @@ void ClArgumentsInfo::extractClassFromJar(Jnjvm* vm, int argc, char** argv, int i) { char* jarFile = argv[i]; - char* temp = - (char*)malloc(2 + strlen(vm->classpath) + strlen(jarFile)); + uint32 size = 2 + strlen(vm->classpath) + strlen(jarFile); + char* temp = (char*)vm->allocator->allocatePermanentMemory(size); sprintf(temp, "%s:%s", vm->classpath, jarFile); vm->setClasspath(temp); - ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, - jarFile); + ArrayUInt8* bytes = Reader::openFile(vm->bootstrapLoader, jarFile); ZipArchive archive(bytes, vm->allocator); if (archive.getOfscd() != -1) { @@ -450,7 +450,7 @@ ArrayUInt8* res = (ArrayUInt8*)array->doNew(file->ucsize, vm); int ok = archive.readFile(res, file); if (ok) { - char* mainClass = findInformation(res, MAIN_CLASS, LENGTH_MAIN_CLASS); + char* mainClass = findInformation(vm, res, MAIN_CLASS, LENGTH_MAIN_CLASS); if (mainClass) { className = mainClass; } else { @@ -776,13 +776,14 @@ argv = argv + pos - 1; argc = argc - pos + 1; - bootstrapThread = allocator_new(&allocator, JavaThread)(); + bootstrapThread = allocator_new(allocator, JavaThread)(); bootstrapThread->initialise(0, this); bootstrapThread->baseSP = mvm::Thread::get()->baseSP; JavaThread::set(bootstrapThread); bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; loadBootstrap(); + #ifdef SERVICE_VM ServiceDomain::initialise((ServiceDomain*)this); #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 13 07:29:01 2008 @@ -38,35 +38,32 @@ extern const char* GNUClasspathGlibj; extern const char* GNUClasspathLibs; -JnjvmBootstrapLoader* JnjvmBootstrapLoader::createBootstrapLoader() { +JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::Allocator* A) { - JnjvmBootstrapLoader* JCL = gc_new(JnjvmBootstrapLoader)(); + allocator = A; JnjvmModule::initialise(); - JCL->TheModule = new JnjvmModule("Bootstrap JnJVM"); - JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule); - - JCL->allocator = new mvm::Allocator(); + TheModule = new JnjvmModule("Bootstrap JnJVM"); + TheModuleProvider = new JnjvmModuleProvider(TheModule); - JCL->hashUTF8 = new(JCL->allocator) UTF8Map(JCL->allocator, 0); - JCL->classes = new(JCL->allocator) ClassMap(); - JCL->javaTypes = new(JCL->allocator) TypeMap(); - JCL->javaSignatures = new(JCL->allocator) SignMap(); + hashUTF8 = new(allocator) UTF8Map(allocator, 0); + classes = new(allocator) ClassMap(); + javaTypes = new(allocator) TypeMap(); + javaSignatures = new(allocator) SignMap(); - JCL->bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH"); - if (!JCL->bootClasspathEnv) { - JCL->bootClasspathEnv = GNUClasspathGlibj; + bootClasspathEnv = getenv("JNJVM_BOOTCLASSPATH"); + if (!bootClasspathEnv) { + bootClasspathEnv = GNUClasspathGlibj; } - JCL->libClasspathEnv = getenv("JNJVM_LIBCLASSPATH"); - if (!JCL->libClasspathEnv) { - JCL->libClasspathEnv = GNUClasspathLibs; + libClasspathEnv = getenv("JNJVM_LIBCLASSPATH"); + if (!libClasspathEnv) { + libClasspathEnv = GNUClasspathLibs; } - JCL->analyseClasspathEnv(JCL->bootClasspathEnv); + analyseClasspathEnv(bootClasspathEnv); - JCL->upcalls = new Classpath(); - JCL->bootstrapLoader = JCL; - return JCL; + upcalls = new(allocator) Classpath(); + bootstrapLoader = this; } JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, @@ -76,7 +73,8 @@ bootstrapLoader = JCL.bootstrapLoader; allocator = new mvm::Allocator(); - hashUTF8 = new(allocator) UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); + hashUTF8 = new(allocator) UTF8Map(allocator, + bootstrapLoader->upcalls->ArrayOfChar); classes = new(allocator) ClassMap(); javaTypes = new(allocator) TypeMap(); javaSignatures = new(allocator) SignMap(); @@ -168,10 +166,11 @@ UserClass* cl = internalLoad(name); if (!cl && doThrow) { + Jnjvm* vm = JavaThread::get()->isolate; if (!(name->equals(Jnjvm::NoClassDefFoundError))) { - JavaThread::get()->isolate->unknownError("Unable to load NoClassDefFoundError"); + vm->unknownError("Unable to load NoClassDefFoundError"); } - JavaThread::get()->isolate->noClassDefFoundError("unable to load %s", name->printString()); + vm->noClassDefFoundError("unable to load %s", name->printString()); } if (cl && doResolve) cl->resolveClass(); @@ -243,8 +242,9 @@ } } -UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, - bool doResolve, bool doThrow) { +UserCommonClass* +JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, + bool doResolve, bool doThrow) { const UTF8* name = 0; @@ -294,7 +294,8 @@ return ld->constructArray(name, cl); } -UserClass* JnjvmClassLoader::constructClass(const UTF8* name, ArrayUInt8* bytes) { +UserClass* JnjvmClassLoader::constructClass(const UTF8* name, + ArrayUInt8* bytes) { assert(bytes && "constructing a class without bytes"); classes->lock.lock(); ClassMap::iterator End = classes->map.end(); @@ -329,11 +330,33 @@ return res; } +Typedef* JnjvmClassLoader::internalConstructType(const UTF8* name) { + short int cur = name->elements[0]; + Typedef* res = 0; + switch (cur) { + case I_TAB : + res = new(allocator) ArrayTypedef(name); + break; + case I_REF : + res = new(allocator) ObjectTypedef(name, hashUTF8); + break; + default : + UserClassPrimitive* cl = + isolate->getPrimitiveClass((char)name->elements[0]); + assert(cl && "No primitive"); + bool unsign = (cl == isolate->upcalls->OfChar || + cl == isolate->upcalls->OfBool); + res = new(allocator) PrimitiveTypedef(name, cl, unsign, cur); + } + return res; +} + + Typedef* JnjvmClassLoader::constructType(const UTF8* name) { javaTypes->lock.lock(); Typedef* res = javaTypes->lookup(name); if (res == 0) { - res = Typedef::constructType(name, hashUTF8, isolate); + res = internalConstructType(name); javaTypes->hash(name, res); } javaTypes->lock.unlock(); @@ -344,7 +367,7 @@ javaSignatures->lock.lock(); Signdef* res = javaSignatures->lookup(name); if (res == 0) { - res = new Signdef(name, this); + res = new(allocator) Signdef(name, this); javaSignatures->hash(name, res); } javaSignatures->lock.unlock(); @@ -352,7 +375,8 @@ } -JnjvmClassLoader* JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader, Jnjvm* vm) { +JnjvmClassLoader* +JnjvmClassLoader::getJnjvmLoaderFromJavaObject(JavaObject* loader, Jnjvm* vm) { if (loader == 0) return vm->bootstrapLoader; @@ -362,7 +386,7 @@ (JnjvmClassLoader*)(upcalls->vmdataClassLoader->getObjectField(loader)); if (!JCL) { - JCL = gc_new(JnjvmClassLoader)(*vm->bootstrapLoader, loader, JavaThread::get()->isolate); + JCL = gc_new(JnjvmClassLoader)(*vm->bootstrapLoader, loader, vm); (upcalls->vmdataClassLoader->setObjectField(loader, (JavaObject*)JCL)); } @@ -373,7 +397,8 @@ return hashUTF8->lookupOrCreateAsciiz(asciiz); } -const UTF8* JnjvmClassLoader::readerConstructUTF8(const uint16* buf, uint32 size) { +const UTF8* JnjvmClassLoader::readerConstructUTF8(const uint16* buf, + uint32 size) { return hashUTF8->lookupOrCreateReader(buf, size); } @@ -407,7 +432,7 @@ stat(rp, &st); if ((st.st_mode & S_IFMT) == S_IFDIR) { unsigned int len = strlen(rp); - char* temp = (char*)malloc(len + 2); + char* temp = (char*)allocator->allocatePermanentMemory(len + 2); memcpy(temp, rp, len); temp[len] = Jnjvm::dirSeparator[0]; temp[len + 1] = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Oct 13 07:29:01 2008 @@ -66,6 +66,11 @@ /// virtual UserClass* internalLoad(const UTF8* utf8); + /// internalConstructType - Hashes a Typedef, an internal representation of + /// a class still not loaded. + /// + Typedef* internalConstructType(const UTF8 * name); + /// JnjvmClassLoader - Allocate a user-defined class loader. Called on /// first use of a Java class loader. /// @@ -268,7 +273,8 @@ /// createBootstrapLoader - Creates the bootstrap loader, first thing /// to do before any execution of a JVM. /// - static JnjvmBootstrapLoader* createBootstrapLoader(); + JnjvmBootstrapLoader(mvm::Allocator*); + JnjvmBootstrapLoader() {} /// upcalls - Upcall classes, fields and methods so that C++ code can call /// Java code. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Mon Oct 13 07:29:01 2008 @@ -197,7 +197,9 @@ CommonClass::method_iterator meths) { if (meths == cl->virtualMethods.end()) { uint64 size = cl->virtualTableSize; - VirtualTable* VT = (VirtualTable*)malloc(size * sizeof(void*)); + mvm::Allocator* allocator = cl->classLoader->allocator; + VirtualTable* VT = (VirtualTable*) + allocator->allocatePermanentMemory(size * sizeof(void*)); if (!VT) JavaThread::get()->isolate->outOfMemoryError(size * sizeof(void*)); if (cl->super) { Class* super = (Class*)cl->super; @@ -263,7 +265,8 @@ #ifndef WITHOUT_VTABLE if (stat) { #endif - res = (VirtualTable*)malloc(VT_SIZE); + mvm::Allocator* allocator = cl->classLoader->allocator; + res = (VirtualTable*)allocator->allocatePermanentMemory(VT_SIZE); memcpy(res, JavaObject::VT, VT_SIZE); #ifndef WITHOUT_VTABLE } else { Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57436&r1=57435&r2=57436&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Mon Oct 13 07:29:01 2008 @@ -39,6 +39,7 @@ INIT(Jnjvm); INIT(JnjvmBootstrapLoader); INIT(JnjvmClassLoader); + INIT(LockObj); #if defined(ISOLATE_SHARING) INIT(JnjvmSharedLoader); INIT(SharedClassByteMap); @@ -57,6 +58,8 @@ for (sint32 i = 0; i < size; i++) { if (elements[i]) elements[i]->MARK_AND_TRACE; } + LockObj* l = lockObj(); + if (l) l->MARK_AND_TRACE; } void JavaArray::TRACER {} @@ -91,6 +94,8 @@ void JavaObject::TRACER { classOf->MARK_AND_TRACE; + LockObj* l = lockObj(); + if (l) l->MARK_AND_TRACE; } #ifdef MULTIPLE_GC @@ -99,6 +104,8 @@ extern "C" void JavaObjectTracer(JavaObject* obj) { #endif obj->classOf->MARK_AND_TRACE; + LockObj* l = obj->lockObj(); + if (l) l->MARK_AND_TRACE; } From nicolas.geoffray at lip6.fr Mon Oct 13 06:06:21 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 13 Oct 2008 13:06:21 -0000 Subject: [vmkit-commits] [vmkit] r57439 - in /vmkit/trunk: include/mvm/JIT.h lib/Mvm/Runtime/JIT.cpp tools/vmkit/Launcher.cpp Message-ID: <200810131306.m9DD6MO6009516@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 13 08:06:21 2008 New Revision: 57439 URL: http://llvm.org/viewvc/llvm-project?rev=57439&view=rev Log: Add support for the -fast option. Modified: vmkit/trunk/include/mvm/JIT.h vmkit/trunk/lib/Mvm/Runtime/JIT.cpp vmkit/trunk/tools/vmkit/Launcher.cpp Modified: vmkit/trunk/include/mvm/JIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/JIT.h?rev=57439&r1=57438&r2=57439&view=diff ============================================================================== --- vmkit/trunk/include/mvm/JIT.h (original) +++ vmkit/trunk/include/mvm/JIT.h Mon Oct 13 08:06:21 2008 @@ -117,7 +117,7 @@ static uint64 getTypeSize(const llvm::Type* type); static void AddStandardCompilePasses(llvm::FunctionPassManager*); static void runPasses(llvm::Function* func, llvm::FunctionPassManager*); - static void initialise(); + static void initialise(bool Fast = false); static llvm::ConstantInt* constantInt8Zero; static llvm::ConstantInt* constantZero; Modified: vmkit/trunk/lib/Mvm/Runtime/JIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/JIT.cpp?rev=57439&r1=57438&r2=57439&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/JIT.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/JIT.cpp Mon Oct 13 08:06:21 2008 @@ -53,7 +53,7 @@ } } -void MvmModule::initialise() { +void MvmModule::initialise(bool Fast) { llvm::NoFramePointerElim = true; llvm::ExceptionHandling = true; globalModule = new llvm::Module("bootstrap module"); @@ -61,7 +61,7 @@ memoryManager = new MvmMemoryManager(); executionEngine = ExecutionEngine::createJIT(globalModuleProvider, 0, - memoryManager); + memoryManager, Fast); Module module("unused"); mvm::llvm_runtime::makeLLVMModuleContents(&module); Modified: vmkit/trunk/tools/vmkit/Launcher.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/Launcher.cpp?rev=57439&r1=57438&r2=57439&view=diff ============================================================================== --- vmkit/trunk/tools/vmkit/Launcher.cpp (original) +++ vmkit/trunk/tools/vmkit/Launcher.cpp Mon Oct 13 08:06:21 2008 @@ -32,6 +32,11 @@ clEnumValN(RunNet, "net", "Run the CLI VM"), clEnumValEnd)); +static llvm::cl::opt Fast("fast", + cl::desc("Generate code quickly, " + "potentially sacrificing code quality"), + cl::init(false)); + int found(char** argv, int argc, const char* name) { int i = 1; for (; i < argc; i++) { @@ -43,12 +48,7 @@ int main(int argc, char** argv) { llvm::llvm_shutdown_obj X; int base; - - mvm::MvmModule::initialise(); - mvm::Object::initialise(); - mvm::Thread::initialise(); - Collector::initialise(0, &base); - Collector::enable(0); + int pos = found(argv, argc, "-java"); if (pos) { llvm::cl::ParseCommandLineOptions(pos, argv); @@ -61,6 +61,12 @@ } } + mvm::MvmModule::initialise(Fast); + mvm::Object::initialise(); + mvm::Thread::initialise(); + Collector::initialise(0, &base); + Collector::enable(0); + if (VMToRun == RunJava) { #if WITH_JNJVM mvm::VirtualMachine::initialiseJVM(); From nicolas.geoffray at lip6.fr Mon Oct 13 07:16:43 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 13 Oct 2008 14:16:43 -0000 Subject: [vmkit-commits] [vmkit] r57441 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMThread.cpp VMCore/JavaClass.cpp VMCore/JavaClass.h VMCore/JavaObject.cpp VMCore/JavaThread.cpp VMCore/JavaThread.h VMCore/Jnjvm.cpp VMCore/Jnjvm.h Message-ID: <200810131416.m9DEGhuY011717@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 13 09:16:42 2008 New Revision: 57441 URL: http://llvm.org/viewvc/llvm-project?rev=57441&view=rev Log: Inline locks and conds in objects. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JavaObject.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 Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Mon Oct 13 09:16:42 2008 @@ -59,9 +59,9 @@ if (!isDaemon) { - ts.nonDaemonLock->lock(); + ts.nonDaemonLock.lock(); ts.nonDaemonThreads++; - ts.nonDaemonLock->unlock(); + ts.nonDaemonLock.unlock(); } #ifdef SERVICE_VM @@ -75,11 +75,11 @@ isolate->upcalls->runVMThread->invokeIntSpecial(isolate, vmthClass, vmThread); if (!isDaemon) { - ts.nonDaemonLock->lock(); + ts.nonDaemonLock.lock(); ts.nonDaemonThreads--; if (ts.nonDaemonThreads == 0) - ts.nonDaemonVar->signal(); - ts.nonDaemonLock->unlock(); + ts.nonDaemonVar.signal(); + ts.nonDaemonLock.unlock(); } #ifdef SERVICE_VM @@ -129,16 +129,16 @@ JavaField* field = vm->upcalls->vmdataVMThread; JavaThread* th = (JavaThread*)field->getObjectField(vmthread); - th->lock->lock(); + 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->varcond.signal(); } - th->lock->unlock(); + th->lock.unlock(); } JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted( Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 13 09:16:42 2008 @@ -91,14 +91,10 @@ CommonClass::~CommonClass() { delete display; - delete lockVar; - delete condVar; } CommonClass::CommonClass() { display = 0; - lockVar = 0; - condVar = 0; virtualVT = 0; } @@ -264,8 +260,6 @@ bool isArray) { name = n; this->virtualVT = 0; - this->lockVar = mvm::Lock::allocRecursive(); - this->condVar = mvm::Cond::allocCond(); this->status = loaded; this->classLoader = loader; this->array = isArray; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 13 09:16:42 2008 @@ -296,11 +296,11 @@ /// lockVar - When multiple threads want to load/resolve/initialize a class, /// they must be synchronized so that these steps are only performed once /// for a given class. - mvm::Lock* lockVar; + mvm::LockRecursive lockVar; /// condVar - Used to wake threads waiting on the load/resolve/initialize /// process of this class, done by another thread. - mvm::Cond* condVar; + mvm::Cond condVar; /// classLoader - The Jnjvm class loader that loaded the class. /// @@ -364,32 +364,32 @@ /// acquire - Acquire this class lock. /// void acquire() { - lockVar->lock(); + lockVar.lock(); } /// release - Release this class lock. /// void release() { - lockVar->unlock(); + lockVar.unlock(); } /// waitClass - Wait for the class to be loaded/initialized/resolved. /// void waitClass() { - condVar->wait(lockVar); + condVar.wait(&lockVar); } /// broadcastClass - Unblock threads that were waiting on the class being /// loaded/initialized/resolved. /// void broadcastClass() { - condVar->broadcast(); + condVar.broadcast(); } /// ownerClass - Is the current thread the owner of this thread? /// bool ownerClass() { - return mvm::Lock::selfOwner(lockVar); + return mvm::Lock::selfOwner(&lockVar); } /// lookupMethodDontThrow - Lookup a method in the method map of this class. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaObject.cpp Mon Oct 13 09:16:42 2008 @@ -27,14 +27,14 @@ for (std::vector::iterator i = threads.begin(), e = threads.end(); i!= e;) { JavaThread* cur = *i; - cur->lock->lock(); + cur->lock.lock(); if (cur->interruptFlag != 0) { - cur->lock->unlock(); + cur->lock.unlock(); ++i; continue; } else if (cur->javaThread != 0) { - cur->varcond->signal(); - cur->lock->unlock(); + cur->varcond.signal(); + cur->lock.unlock(); threads.erase(i); break; } else { // dead thread @@ -48,9 +48,9 @@ for (std::vector::iterator i = threads.begin(), e = threads.end(); i!= e; ++i) { JavaThread* cur = *i; - cur->lock->lock(); - cur->varcond->signal(); - cur->lock->unlock(); + cur->lock.lock(); + cur->varcond.signal(); + cur->lock.unlock(); } threads.clear(); } @@ -170,12 +170,12 @@ if (owner()) { LockObj * l = changeToFatlock(); JavaThread* thread = JavaThread::get(); - mvm::Lock* mutexThread = thread->lock; - mvm::Cond* varcondThread = thread->varcond; + mvm::Lock& mutexThread = thread->lock; + mvm::Cond& varcondThread = thread->varcond; - mutexThread->lock(); + mutexThread.lock(); if (thread->interruptFlag != 0) { - mutexThread->unlock(); + mutexThread.unlock(); thread->interruptFlag = 0; thread->isolate->interruptedException(this); } else { @@ -187,13 +187,13 @@ thread->state = JavaThread::StateWaiting; if (timed) { - timeout = varcondThread->timed_wait(mutexThread, info); + timeout = varcondThread.timed_wait(&mutexThread, info); } else { - varcondThread->wait(mutexThread); + varcondThread.wait(&mutexThread); } bool interrupted = (thread->interruptFlag != 0); - mutexThread->unlock(); + mutexThread.unlock(); mvm::LockRecursive::my_lock_all(&l->lock, recur); if (interrupted || timeout) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Mon Oct 13 09:16:42 2008 @@ -29,13 +29,3 @@ buf->write("Thread:"); javaThread->print(buf); } - -JavaThread::~JavaThread() { - delete lock; - delete varcond; -} - -JavaThread::JavaThread() { - lock = 0; - varcond = 0; -} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Mon Oct 13 09:16:42 2008 @@ -34,8 +34,8 @@ static VirtualTable *VT; JavaObject* javaThread; Jnjvm* isolate; - mvm::Lock* lock; - mvm::Cond* varcond; + mvm::LockNormal lock; + mvm::Cond varcond; JavaObject* pendingException; void* internalPendingException; uint32 interruptFlag; @@ -48,14 +48,12 @@ virtual void print(mvm::PrintBuffer *buf) const; virtual void TRACER; - ~JavaThread(); - JavaThread(); + ~JavaThread() {} + JavaThread() {} void initialise(JavaObject* thread, Jnjvm* isolate) { this->javaThread = thread; this->isolate = isolate; - this->lock = mvm::Lock::allocNormal(); - this->varcond = mvm::Cond::allocCond(); this->interruptFlag = 0; this->state = StateRunning; this->pendingException = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 13 09:16:42 2008 @@ -754,14 +754,14 @@ } void Jnjvm::waitForExit() { - threadSystem.nonDaemonLock->lock(); + threadSystem.nonDaemonLock.lock(); --(threadSystem.nonDaemonThreads); while (threadSystem.nonDaemonThreads) { - threadSystem.nonDaemonVar->wait(threadSystem.nonDaemonLock); + threadSystem.nonDaemonVar.wait(&threadSystem.nonDaemonLock); } - threadSystem.nonDaemonLock->unlock(); + threadSystem.nonDaemonLock.unlock(); return; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57441&r1=57440&r2=57441&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Oct 13 09:16:42 2008 @@ -57,14 +57,14 @@ /// nonDaemonLock - Protection lock for the nonDaemonThreads variable. /// - mvm::Lock* nonDaemonLock; + mvm::LockNormal nonDaemonLock; /// nonDaemonVar - Condition variable to wake up the initial thread when it /// waits for other non-daemon threads to end. The non-daemon thread that /// decrements the nonDaemonThreads variable to zero wakes up the initial /// thread. /// - mvm::Cond* nonDaemonVar; + mvm::Cond nonDaemonVar; /// ThreadSystem - Allocates a thread system management, initializing the /// lock, the condition variable and setting the initial number of non @@ -72,17 +72,12 @@ /// ThreadSystem() { nonDaemonThreads = 1; - nonDaemonLock = mvm::Lock::allocNormal(); - nonDaemonVar = mvm::Cond::allocCond(); } /// ~ThreadSystem - Destroys the thread system manager. Destroys the lock and /// the condition variable. /// - ~ThreadSystem() { - delete nonDaemonLock; - delete nonDaemonVar; - } + ~ThreadSystem() {} }; From nicolas.geoffray at lip6.fr Mon Oct 13 09:39:00 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 13 Oct 2008 16:39:00 -0000 Subject: [vmkit-commits] [vmkit] r57443 - in /vmkit/trunk: include/mvm/ include/mvm/Threads/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/ Message-ID: <200810131639.m9DGd1Rc016863@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 13 11:38:59 2008 New Revision: 57443 URL: http://llvm.org/viewvc/llvm-project?rev=57443&view=rev Log: Use LLVM's BumpPtrAllocator to allocate memory for a class loader. Modified: vmkit/trunk/include/mvm/Allocator.h vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp 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/JavaInitialise.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaString.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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp vmkit/trunk/lib/JnJVM/VMCore/Zip.h Modified: vmkit/trunk/include/mvm/Allocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Allocator.h (original) +++ vmkit/trunk/include/mvm/Allocator.h Mon Oct 13 11:38:59 2008 @@ -12,7 +12,10 @@ #include +#include "llvm/Support/Allocator.h" + #include "MvmGC.h" +#include "mvm/Threads/Locks.h" #ifdef MULTIPLE_GC #define allocator_new(alloc, cl) collector_new(cl, alloc.GC) @@ -58,10 +61,26 @@ } }; +class BumpPtrAllocator { +private: + LockNormal TheLock; + llvm::BumpPtrAllocator Allocator; +public: + void* Allocate(size_t sz) { + TheLock.lock(); + void* res = Allocator.Allocate(sz, sz % 4 ? sizeof(void*) : 1); + TheLock.unlock(); + return res; + } + + void Deallocate(void* obj) {} +}; + + class PermanentObject { public: - void* operator new(size_t sz, Allocator* allocator) { - return allocator->allocatePermanentMemory(sz); + void* operator new(size_t sz, BumpPtrAllocator& allocator) { + return allocator.Allocate(sz); } void operator delete(void* ptr) { Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Mon Oct 13 11:38:59 2008 @@ -13,11 +13,11 @@ #include "types.h" #include "MvmGC.h" -#include "mvm/Allocator.h" #include "mvm/JIT.h" #include "mvm/Threads/Key.h" +class Allocator; class Collector; namespace mvm { Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMObject.cpp Mon Oct 13 11:38:59 2008 @@ -41,7 +41,7 @@ size = cl->getVirtualSize(); } JavaObject* res = (JavaObject*) - vm->allocator->allocateManagedObject(size, src->getVirtualTable()); + vm->gcAllocator.allocateManagedObject(size, src->getVirtualTable()); memcpy(res, src, size); res->lock = 0; return (jobject)res; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Mon Oct 13 11:38:59 2008 @@ -39,7 +39,7 @@ jobject throwable) { Jnjvm* vm = JavaThread::get()->isolate; int** stack = - (int**)vm->allocator->allocateTemporaryMemory(sizeof(int*) * 100); + (int**)vm->gcAllocator.allocateTemporaryMemory(sizeof(int*) * 100); int real_size = mvm::MvmModule::getBacktrace((void**)stack, 100); stack[real_size] = 0; JavaObject* vmThrowable = vm->upcalls->newVMThrowable->doNew(vm); @@ -116,7 +116,7 @@ } } jobject res = (jobject)recGetStackTrace((int**)(uint32**)stack, first, 0); - vm->allocator->freeTemporaryMemory(stack); + vm->gcAllocator.freeTemporaryMemory(stack); return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Mon Oct 13 11:38:59 2008 @@ -108,12 +108,8 @@ #endif } -void* UTF8::operator new(size_t sz, mvm::Allocator* allocator, sint32 size) { - return allocator->allocatePermanentMemory(sz + size * sizeof(uint16)); -} - const UTF8* UTF8::acons(sint32 n, UserClassArray* cl, - mvm::Allocator* allocator) { + mvm::BumpPtrAllocator& allocator) { assert(n >= 0 && "Creating an UTF8 with a size < 0"); assert(n <= JavaArray::MaxArraySize && "Creating an UTF8 with a size too big"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Mon Oct 13 11:38:59 2008 @@ -117,7 +117,7 @@ /// acons - Allocates an UTF8 in permanent memory. The class argument must be /// JavaArray::ofChar. static const UTF8* acons(sint32 n, UserClassArray* cl, - mvm::Allocator* allocator); + mvm::BumpPtrAllocator& allocator); /// internalToJava - Creates a copy of the UTF8 at its given offset and size /// woth all its '.' replaced by '/'. The JVM bytecode reference classes in @@ -165,7 +165,10 @@ /// operator new - Redefines the new operator of this class to allocate /// its objects in permanent memory, not with the garbage collector. - void* operator new(size_t sz, mvm::Allocator* allocator, sint32 size); + void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, + sint32 size) { + return allocator.Allocate(sz + size * sizeof(uint16)); + } }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Mon Oct 13 11:38:59 2008 @@ -29,9 +29,11 @@ Enveloppe::~Enveloppe() { CacheNode* cache = firstCache; CacheNode* next = firstCache; + mvm::BumpPtrAllocator& allocator = ctpInfo->classDef->classLoader->allocator; while(next) { next = cache->next; - delete cache; + cache->~CacheNode(); + allocator.Deallocate(cache); cache = next; } } @@ -47,7 +49,7 @@ } Enveloppe::Enveloppe(UserConstantPool* ctp, uint32 i) { - mvm::Allocator* allocator = ctp->classDef->classLoader->allocator; + mvm::BumpPtrAllocator& allocator = ctp->classDef->classLoader->allocator; firstCache = new(allocator) CacheNode(this); ctpInfo = ctp; index = i; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 13 11:38:59 2008 @@ -90,7 +90,7 @@ CommonClass::~CommonClass() { - delete display; + classLoader->allocator.Deallocate(display); } CommonClass::CommonClass() { @@ -110,47 +110,57 @@ for (std::vector::iterator i = attributs.begin(), e = attributs.end(); i!= e; ++i) { Attribut* cur = *i; - delete cur; + cur->~Attribut(); + classLoader->allocator.Deallocate(cur); } for (field_iterator i = staticFields.begin(), e = staticFields.end(); i!= e; ++i) { JavaField* cur = i->second; - delete cur; + cur->~JavaField(); + classLoader->allocator.Deallocate(cur); } for (field_iterator i = virtualFields.begin(), e = virtualFields.end(); i!= e; ++i) { JavaField* cur = i->second; - delete cur; + cur->~JavaField(); + classLoader->allocator.Deallocate(cur); } for (method_iterator i = virtualMethods.begin(), e = virtualMethods.end(); i!= e; ++i) { JavaMethod* cur = i->second; - delete cur; + cur->~JavaMethod(); + classLoader->allocator.Deallocate(cur); } for (method_iterator i = staticMethods.begin(), e = staticMethods.end(); i!= e; ++i) { JavaMethod* cur = i->second; - delete cur; + cur->~JavaMethod(); + classLoader->allocator.Deallocate(cur); } - - delete ctpInfo; - free(staticVT); + + if (ctpInfo) { + ctpInfo->~JavaConstantPool(); + classLoader->allocator.Deallocate(ctpInfo); + } + + classLoader->allocator.Deallocate(staticVT); // Currently, only regular classes have a heap allocated virtualVT. // Array classes have a C++ allocated virtualVT and primitive classes // do not have a virtualVT. - free(virtualVT); + classLoader->allocator.Deallocate(virtualVT); } JavaField::~JavaField() { for (std::vector::iterator i = attributs.begin(), e = attributs.end(); i!= e; ++i) { Attribut* cur = *i; - delete cur; + cur->~Attribut(); + classDef->classLoader->allocator.Deallocate(cur); } } @@ -159,13 +169,15 @@ for (std::vector::iterator i = attributs.begin(), e = attributs.end(); i!= e; ++i) { Attribut* cur = *i; - delete cur; + cur->~Attribut(); + classDef->classLoader->allocator.Deallocate(cur); } for (std::vector::iterator i = caches.begin(), e = caches.end(); i!= e; ++i) { Enveloppe* cur = *i; - delete cur; + cur->~Enveloppe(); + classDef->classLoader->allocator.Deallocate(cur); } } @@ -273,8 +285,7 @@ uint32 nb) : CommonClass(loader, n, false) { - display = (CommonClass**) - loader->allocator->allocatePermanentMemory(sizeof(CommonClass*)); + display = (CommonClass**)loader->allocator.Allocate(sizeof(CommonClass*)); display[0] = this; primitive = true; status = ready; @@ -303,8 +314,7 @@ super = ClassArray::SuperArray; interfaces = ClassArray::InterfacesArray; depth = 1; - display = (CommonClass**) - loader->allocator->allocatePermanentMemory(2 * sizeof(CommonClass*)); + display = (CommonClass**)loader->allocator.Allocate(2 * sizeof(CommonClass*)); display[0] = ClassArray::SuperArray; display[1] = this; access = ACC_FINAL | ACC_ABSTRACT | ACC_PUBLIC; @@ -333,17 +343,30 @@ else if (n > JavaArray::MaxArraySize) vm->outOfMemoryError(n); - return doNew(n, vm->allocator); + return doNew(n, vm->gcAllocator); +} + +JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator& allocator) { + UserCommonClass* cl = baseClass(); + assert(cl && virtualVT && "array class not resolved"); + + uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); + uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize; + JavaArray* res = (JavaArray*)allocator.allocateManagedObject(size, + virtualVT); + res->initialise(this); + res->size = n; + return res; } -JavaArray* UserClassArray::doNew(sint32 n, mvm::Allocator* allocator) { +JavaArray* UserClassArray::doNew(sint32 n, mvm::BumpPtrAllocator& allocator) { UserCommonClass* cl = baseClass(); assert(cl && virtualVT && "array class not resolved"); uint32 primSize = cl->isPrimitive() ? cl->virtualSize : sizeof(JavaObject*); uint32 size = sizeof(JavaObject) + sizeof(sint32) + n * primSize; - JavaArray* res = (JavaArray*)allocator->allocateManagedObject(size, - virtualVT); + JavaArray* res = (JavaArray*)allocator.Allocate(size); + ((void**)res)[0] = virtualVT; res->initialise(this); res->size = n; return res; @@ -484,8 +507,8 @@ assert(this && "No class when allocating."); assert(this->isReady() && "Uninitialized class when allocating."); JavaObject* res = - (JavaObject*)vm->allocator->allocateManagedObject(getVirtualSize(), - getVirtualVT()); + (JavaObject*)vm->gcAllocator.allocateManagedObject(getVirtualSize(), + getVirtualVT()); res->classOf = this; return res; } @@ -679,14 +702,14 @@ if (superUTF8 == 0) { depth = 0; display = (CommonClass**) - classLoader->allocator->allocatePermanentMemory(sizeof(CommonClass*)); + classLoader->allocator.Allocate(sizeof(CommonClass*)); display[0] = this; } else { super = classLoader->loadName(superUTF8, true, true); depth = super->depth + 1; - mvm::Allocator* allocator = classLoader->allocator; + mvm::BumpPtrAllocator& allocator = classLoader->allocator; display = (CommonClass**) - allocator->allocatePermanentMemory(sizeof(CommonClass*) * (depth + 1)); + allocator.Allocate(sizeof(CommonClass*) * (depth + 1)); memcpy(display, super->display, depth * sizeof(UserCommonClass*)); display[depth] = this; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 13 11:38:59 2008 @@ -522,8 +522,8 @@ static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls); - void* operator new(size_t sz, mvm::Allocator* allocator) { - return allocator->allocatePermanentMemory(sz); + void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator) { + return allocator.Allocate(sz); } }; @@ -714,7 +714,8 @@ private: /// doNew - Allocate a new array with the given allocator. /// - JavaArray* doNew(sint32 n, mvm::Allocator* allocator); + JavaArray* doNew(sint32 n, mvm::BumpPtrAllocator& allocator); + JavaArray* doNew(sint32 n, mvm::Allocator& allocator); public: Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Oct 13 11:38:59 2008 @@ -186,10 +186,11 @@ } -void* JavaConstantPool::operator new(size_t sz, mvm::Allocator* allocator, - uint32 ctpSize) { +void* +JavaConstantPool::operator new(size_t sz, mvm::BumpPtrAllocator& allocator, + uint32 ctpSize) { uint32 size = sz + ctpSize * (sizeof(void*) + sizeof(sint32) + sizeof(uint8)); - return allocator->allocatePermanentMemory(size); + return allocator.Allocate(size); } JavaConstantPool::JavaConstantPool(Class* cl, Reader& reader, uint32 size) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.h Mon Oct 13 11:38:59 2008 @@ -60,7 +60,8 @@ /// operator new - Redefine the operator to allocate the arrays of a /// constant pool inline. - void* operator new(size_t sz, mvm::Allocator* allocator, uint32 ctpSize); + void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, + uint32 ctpSize); /// CtpReaderClass - Reads a class entry. static uint32 CtpReaderClass(JavaConstantPool* ctp, Reader& reader, Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Mon Oct 13 11:38:59 2008 @@ -87,9 +87,7 @@ } #endif - mvm::Allocator* allocator = new mvm::Allocator(); - JnjvmBootstrapLoader* JCL = bootstrapLoader = - gc_new(JnjvmBootstrapLoader)(allocator); + JnjvmBootstrapLoader* JCL = bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); // Create the name of char arrays. const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C"); @@ -248,8 +246,7 @@ ServiceDomain* vm = ServiceDomain::allocateService(); vm->startExecution(); #else - mvm::Allocator* allocator = new mvm::Allocator(); - Jnjvm* vm = gc_new(Jnjvm)(allocator); + Jnjvm* vm = gc_new(Jnjvm)(0); #endif return vm; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Oct 13 11:38:59 2008 @@ -2018,7 +2018,7 @@ #ifndef ISOLATE_SHARING // ok now the cache - mvm::Allocator* allocator = compilingClass->classLoader->allocator; + mvm::BumpPtrAllocator& allocator = compilingClass->classLoader->allocator; Enveloppe* enveloppe = new(allocator) Enveloppe(compilingClass->ctpInfo, index); compilingMethod->caches.push_back(enveloppe); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Mon Oct 13 11:38:59 2008 @@ -269,7 +269,8 @@ JavaThread* th = JavaThread::get(); jmp_buf* buf = th->sjlj_buffers.back(); th->sjlj_buffers.pop_back(); - free(buf); + mvm::Allocator& allocator = th->isolate->gcAllocator; + allocator.freeTemporaryMemory(buf); if (JavaThread::get()->pendingException) { th->throwPendingException(); } @@ -277,8 +278,8 @@ extern "C" void* getSJLJBuffer() { JavaThread* th = JavaThread::get(); - mvm::Allocator* allocator = th->isolate->allocator; - void** buf = (void**)allocator->allocatePermanentMemory(sizeof(jmp_buf)); + mvm::Allocator& allocator = th->isolate->gcAllocator; + void** buf = (void**)allocator.allocateTemporaryMemory(sizeof(jmp_buf)); th->sjlj_buffers.push_back((jmp_buf*)buf); return (void*)buf; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Mon Oct 13 11:38:59 2008 @@ -18,8 +18,7 @@ JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) { UserClass* cl = vm->upcalls->newString; - JavaString* res = - (JavaString*)vm->allocator->allocatePermanentMemory(cl->getVirtualSize()); + JavaString* res = (JavaString*)vm->allocator.Allocate(cl->getVirtualSize()); #ifdef ISOLATE_SHARING /// Do this for now, but we will have to change it to duplicate the UTF8. /// UTF8 that dont have a class are shared UTF8. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 13 11:38:59 2008 @@ -121,8 +121,8 @@ PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "%s\n", printString()); JavaObject* val = - (JavaObject*)vm->allocator->allocateManagedObject(cl->getStaticSize(), - cl->getStaticVT()); + (JavaObject*)vm->gcAllocator.allocateManagedObject(cl->getStaticSize(), + cl->getStaticVT()); val->initialise(cl); CommonClass::field_map* map = cl->getStaticFields(); for (CommonClass::field_iterator i = map->begin(), e = map->end(); i!= e; @@ -355,11 +355,11 @@ Jnjvm::~Jnjvm() { if (hashStr) { hashStr->~StringMap(); - allocator->freePermanentMemory(hashStr); + allocator.Deallocate(hashStr); } if (hashUTF8) { hashUTF8->~UTF8Map(); - allocator->freePermanentMemory(hashUTF8); + allocator.Deallocate(hashUTF8); } } @@ -422,7 +422,7 @@ else end += index; sint32 length = end - index - 1; - char* name = (char*)vm->allocator->allocatePermanentMemory(length + 1); + char* name = (char*)vm->allocator.Allocate(length + 1); memcpy(name, &(ptr[index]), length); name[length] = 0; return name; @@ -435,7 +435,7 @@ int i) { char* jarFile = argv[i]; uint32 size = 2 + strlen(vm->classpath) + strlen(jarFile); - char* temp = (char*)vm->allocator->allocatePermanentMemory(size); + char* temp = (char*)vm->allocator.Allocate(size); sprintf(temp, "%s:%s", vm->classpath, jarFile); vm->setClasspath(temp); @@ -810,9 +810,8 @@ } } -Jnjvm::Jnjvm(mvm::Allocator* A) { +Jnjvm::Jnjvm(uint32 memLimit) { - allocator = A; classpath = getenv("CLASSPATH"); if (!classpath) classpath = "."; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Oct 13 11:38:59 2008 @@ -87,7 +87,8 @@ public: /// allocator - Memory allocator of this JVM. /// - mvm::Allocator* allocator; + mvm::BumpPtrAllocator allocator; + mvm::Allocator gcAllocator; #ifdef ISOLATE_SHARING UserClass* throwable; #endif @@ -326,7 +327,7 @@ /// Jnjvm - Allocates a new JVM. /// - Jnjvm(mvm::Allocator* allocator); + Jnjvm(uint32 memLimit); /// runApplication - Runs the application with the given command line. /// User-visible function, inherited by the VirtualMachine class. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 13 11:38:59 2008 @@ -38,9 +38,8 @@ extern const char* GNUClasspathGlibj; extern const char* GNUClasspathLibs; -JnjvmBootstrapLoader::JnjvmBootstrapLoader(mvm::Allocator* A) { +JnjvmBootstrapLoader::JnjvmBootstrapLoader(uint32 memLimit) { - allocator = A; JnjvmModule::initialise(); TheModule = new JnjvmModule("Bootstrap JnJVM"); TheModuleProvider = new JnjvmModuleProvider(TheModule); @@ -71,7 +70,6 @@ TheModule = new JnjvmModule("Applicative loader"); TheModuleProvider = new JnjvmModuleProvider(TheModule); bootstrapLoader = JCL.bootstrapLoader; - allocator = new mvm::Allocator(); hashUTF8 = new(allocator) UTF8Map(allocator, bootstrapLoader->upcalls->ArrayOfChar); @@ -403,10 +401,27 @@ } JnjvmClassLoader::~JnjvmClassLoader() { - delete classes; - delete hashUTF8; - delete javaTypes; - delete javaSignatures; + + if (classes) { + classes->~ClassMap(); + allocator.Deallocate(classes); + } + + if (hashUTF8) { + hashUTF8->~UTF8Map(); + allocator.Deallocate(hashUTF8); + } + + if (javaTypes) { + javaTypes->~TypeMap(); + allocator.Deallocate(javaTypes); + } + + if (javaSignatures) { + javaSignatures->~SignMap(); + allocator.Deallocate(javaSignatures); + } + delete TheModuleProvider; } @@ -432,7 +447,7 @@ stat(rp, &st); if ((st.st_mode & S_IFMT) == S_IFDIR) { unsigned int len = strlen(rp); - char* temp = (char*)allocator->allocatePermanentMemory(len + 2); + char* temp = (char*)allocator.Allocate(len + 2); memcpy(temp, rp, len); temp[len] = Jnjvm::dirSeparator[0]; temp[len + 1] = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Oct 13 11:38:59 2008 @@ -101,7 +101,7 @@ /// allocator - Reference to the memory allocator, which will allocate UTF8s, /// signatures and types. /// - mvm::Allocator* allocator; + mvm::BumpPtrAllocator allocator; /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared @@ -273,7 +273,7 @@ /// createBootstrapLoader - Creates the bootstrap loader, first thing /// to do before any execution of a JVM. /// - JnjvmBootstrapLoader(mvm::Allocator*); + JnjvmBootstrapLoader(uint32 memLimit); JnjvmBootstrapLoader() {} /// upcalls - Upcall classes, fields and methods so that C++ code can call Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Mon Oct 13 11:38:59 2008 @@ -197,9 +197,8 @@ CommonClass::method_iterator meths) { if (meths == cl->virtualMethods.end()) { uint64 size = cl->virtualTableSize; - mvm::Allocator* allocator = cl->classLoader->allocator; - VirtualTable* VT = (VirtualTable*) - allocator->allocatePermanentMemory(size * sizeof(void*)); + mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator; + VirtualTable* VT = (VirtualTable*)allocator.Allocate(size * sizeof(void*)); if (!VT) JavaThread::get()->isolate->outOfMemoryError(size * sizeof(void*)); if (cl->super) { Class* super = (Class*)cl->super; @@ -265,8 +264,8 @@ #ifndef WITHOUT_VTABLE if (stat) { #endif - mvm::Allocator* allocator = cl->classLoader->allocator; - res = (VirtualTable*)allocator->allocatePermanentMemory(VT_SIZE); + mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator; + res = (VirtualTable*)allocator.Allocate(VT_SIZE); memcpy(res, JavaObject::VT, VT_SIZE); #ifndef WITHOUT_VTABLE } else { Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Mon Oct 13 11:38:59 2008 @@ -6,6 +6,12 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// +// +// This file defines thread-safe maps that must be deallocated by the owning +// object. For example a class loader is responsible for deallocating the +// types stored in a TypeMap. +// +//===----------------------------------------------------------------------===// #ifndef JNJVM_LOCKED_MAP_H #define JNJVM_LOCKED_MAP_H @@ -96,7 +102,7 @@ typedef std::multimap::iterator iterator; mvm::LockNormal lock; - mvm::Allocator* allocator; + mvm::BumpPtrAllocator& allocator; UserClassArray* array; std::multimap map; const UTF8* lookupOrCreateAsciiz(const char* asciiz); @@ -104,14 +110,13 @@ const UTF8* lookupAsciiz(const char* asciiz); const UTF8* lookupReader(const uint16* buf, uint32 size); - UTF8Map(mvm::Allocator* A, UserClassArray* cl) { - allocator = A; + UTF8Map(mvm::BumpPtrAllocator& A, UserClassArray* cl) : allocator(A) { array = cl; } ~UTF8Map() { for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - allocator->freePermanentMemory((void*)i->second); + allocator.Deallocate((void*)i->second); } } @@ -126,26 +131,11 @@ }; class ClassMap : - public LockedMap { -public: - - ClassMap() {} - - ~ClassMap() {} - + public LockedMap { }; class StringMap : public LockedMap { -public: - - StringMap() {} - - ~StringMap() { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - free(i->second); - } - } }; class TypeMap : public mvm::PermanentObject { @@ -164,15 +154,6 @@ inline void hash(const UTF8* k, Typedef* c) { map.insert(std::make_pair(k, c)); } - - TypeMap() {} - - ~TypeMap() { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - delete i->second; - } - } - }; class SignMap : public mvm::PermanentObject { @@ -192,14 +173,6 @@ map.insert(std::make_pair(k, c)); } - SignMap() {} - - ~SignMap() { - for (iterator i = map.begin(), e = map.end(); i!= e; ++i) { - delete i->second; - } - } - }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Zip.cpp Mon Oct 13 11:38:59 2008 @@ -17,9 +17,8 @@ using namespace jnjvm; -ZipArchive::ZipArchive(ArrayUInt8* bytes, mvm::Allocator* allocator) { +ZipArchive::ZipArchive(ArrayUInt8* bytes, mvm::BumpPtrAllocator& A) : allocator(A) { this->bytes = bytes; - this->allocator = allocator, findOfscd(); if (ofscd > -1) addFiles(); } @@ -146,8 +145,7 @@ (reader.max - temp) < ptr->filenameLength) return; - ptr->filename = - (char*)allocator->allocatePermanentMemory(ptr->filenameLength + 1); + ptr->filename = (char*)allocator.Allocate(ptr->filenameLength + 1); memcpy(ptr->filename, &(reader.bytes->elements[temp]), ptr->filenameLength); ptr->filename[ptr->filenameLength] = 0; Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=57443&r1=57442&r2=57443&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Mon Oct 13 11:38:59 2008 @@ -36,7 +36,7 @@ friend class JnjvmBootstrapLoader; private: - mvm::Allocator* allocator; + mvm::BumpPtrAllocator& allocator; struct ltstr { @@ -61,14 +61,14 @@ ~ZipArchive() { for (table_iterator I = filetable.begin(), E = filetable.end(); I != E; ++I) { - allocator->freePermanentMemory((void*)I->first); + allocator.Deallocate((void*)I->first); I->second->~ZipFile(); - allocator->freePermanentMemory((void*)I->second); + allocator.Deallocate((void*)I->second); } } int getOfscd() { return ofscd; } - ZipArchive(ArrayUInt8* bytes, mvm::Allocator* allocator); + ZipArchive(ArrayUInt8* bytes, mvm::BumpPtrAllocator& allocator); ZipFile* getFile(const char* filename); int readFile(ArrayUInt8* array, const ZipFile* file); From nicolas.geoffray at lip6.fr Tue Oct 14 08:00:20 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 15:00:20 -0000 Subject: [vmkit-commits] [vmkit] r57488 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaTypes.h LockedMap.h Message-ID: <200810141500.m9EF0KJY012412@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 10:00:19 2008 New Revision: 57488 URL: http://llvm.org/viewvc/llvm-project?rev=57488&view=rev Log: Fix warning on Apple gcc 4.0.1. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h?rev=57488&r1=57487&r2=57488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.h Tue Oct 14 10:00:19 2008 @@ -115,7 +115,8 @@ const UTF8* getKey() const { return keyName; } - + + virtual ~Typedef() {} }; class PrimitiveTypedef : public Typedef { Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57488&r1=57487&r2=57488&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Tue Oct 14 10:00:19 2008 @@ -94,7 +94,8 @@ virtual void print(mvm::PrintBuffer* buf) const { buf->write("Hashtable<>"); } - + + virtual ~LockedMap() {} }; class UTF8Map : public mvm::PermanentObject { From nicolas.geoffray at lip6.fr Tue Oct 14 08:12:17 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 15:12:17 -0000 Subject: [vmkit-commits] [vmkit] r57489 - in /vmkit/trunk: Makefile.common.in autoconf/configure.ac configure Message-ID: <200810141512.m9EFCIlF012834@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 10:12:16 2008 New Revision: 57489 URL: http://llvm.org/viewvc/llvm-project?rev=57489&view=rev Log: Fix compilation when OBJ != SRC. Modified: vmkit/trunk/Makefile.common.in vmkit/trunk/autoconf/configure.ac vmkit/trunk/configure Modified: vmkit/trunk/Makefile.common.in URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.common.in?rev=57489&r1=57488&r2=57489&view=diff ============================================================================== --- vmkit/trunk/Makefile.common.in (original) +++ vmkit/trunk/Makefile.common.in Tue Oct 14 10:12:16 2008 @@ -38,4 +38,4 @@ LIBS += -lgc endif -include $(LEVEL)/Makefile.rules +include $(PROJ_SRC_ROOT)/Makefile.rules Modified: vmkit/trunk/autoconf/configure.ac URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=57489&r1=57488&r2=57489&view=diff ============================================================================== --- vmkit/trunk/autoconf/configure.ac (original) +++ vmkit/trunk/autoconf/configure.ac Tue Oct 14 10:12:16 2008 @@ -31,7 +31,7 @@ dnl===-----------------------------------------------------------------------=== dnl Initialize autoconf and define the package name, version number and dnl email address for reporting bugs. -AC_INIT([vmkit],[0.0.1],[nicolas.geoffray at lip6.fr]) +AC_INIT([vmkit],[0.24],[nicolas.geoffray at lip6.fr]) dnl Provide a copyright substitution and ensure the copyright notice is included dnl in the output of --version option of the generated configure script. @@ -180,24 +180,24 @@ ) if test "x$gc" = "xboehm"; then - GC_FLAGS="-I$PWD/lib/Mvm/BoehmGC -DGC_THREADS" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/BoehmGC -DGC_THREADS" AC_DEFINE([USE_GC_BOEHM], [1], [Using the boehm gc]) AC_SUBST(GC_MMAP2, [0]) AC_SUBST(GC_BOEHM, [1]) GC_LIBS=BoehmGC case $target_os in *linux*) - GC_FLAGS="-I$PWD/lib/Mvm/BoehmGC -DGC_THREADS -DGC_LINUX_THREADS" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/BoehmGC -DGC_THREADS -DGC_LINUX_THREADS" ;; esac else GC_LIBS=GCMmap2 if test "x$gc" = "xmulti-mmap"; then - GC_FLAGS="-I$PWD/lib/Mvm/GCMmap2 -DWITH_TRACER -DMULTIPLE_GC" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/GCMmap2 -DWITH_TRACER -DMULTIPLE_GC" AC_SUBST([GC_MULTI_MMAP], [1]) AC_SUBST([GC_SINGLE_MMAP], [0]) else - GC_FLAGS="-I$PWD/lib/Mvm/GCMmap2 -DWITH_TRACER" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/GCMmap2 -DWITH_TRACER" AC_SUBST([GC_MULTI_MMAP], [0]) AC_SUBST([GC_SINGLE_MMAP], [1]) fi @@ -226,7 +226,7 @@ ISOLATE_BUILD=1 else if test "x$vmtype" = "xservice"; then - VM_FLAGS="-DMULTIPLE_VM -DSERVICE_GC -DMULTIPLE_GC -DSERVICE_VM -I$PWD/lib/Mvm/Allocator" + VM_FLAGS="-DMULTIPLE_VM -DSERVICE_GC -DMULTIPLE_GC -DSERVICE_VM -I\$(PROJ_SRC_ROOT)/lib/Mvm/Allocator" SERVICE_BUILD=1 fi fi Modified: vmkit/trunk/configure URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=57489&r1=57488&r2=57489&view=diff ============================================================================== --- vmkit/trunk/configure (original) +++ vmkit/trunk/configure Tue Oct 14 10:12:16 2008 @@ -1,6 +1,6 @@ #! /bin/sh # Guess values for system-dependent variables and create Makefiles. -# Generated by GNU Autoconf 2.61 for vmkit 0.0.1. +# Generated by GNU Autoconf 2.61 for vmkit 0.24. # # Report bugs to . # @@ -576,8 +576,8 @@ # Identity of this package. PACKAGE_NAME='vmkit' PACKAGE_TARNAME='vmkit' -PACKAGE_VERSION='0.0.1' -PACKAGE_STRING='vmkit 0.0.1' +PACKAGE_VERSION='0.24' +PACKAGE_STRING='vmkit 0.24' PACKAGE_BUGREPORT='nicolas.geoffray at lip6.fr' ac_unique_file="lib/Mvm/Object.cpp" @@ -1243,7 +1243,7 @@ # Omit some internal or obsolete options to make the list less imposing. # This message is too long to be a string in the A/UX 3.1 sh. cat <<_ACEOF -\`configure' configures vmkit 0.0.1 to adapt to many kinds of systems. +\`configure' configures vmkit 0.24 to adapt to many kinds of systems. Usage: $0 [OPTION]... [VAR=VALUE]... @@ -1309,7 +1309,7 @@ if test -n "$ac_init_help"; then case $ac_init_help in - short | recursive ) echo "Configuration of vmkit 0.0.1:";; + short | recursive ) echo "Configuration of vmkit 0.24:";; esac cat <<\_ACEOF @@ -1412,7 +1412,7 @@ test -n "$ac_init_help" && exit $ac_status if $ac_init_version; then cat <<\_ACEOF -vmkit configure 0.0.1 +vmkit configure 0.24 generated by GNU Autoconf 2.61 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001, @@ -1428,7 +1428,7 @@ This file contains any messages produced by compilers while running configure, to aid debugging if configure makes a mistake. -It was created by vmkit $as_me 0.0.1, which was +It was created by vmkit $as_me 0.24, which was generated by GNU Autoconf 2.61. Invocation command line was $ $0 $@ @@ -3885,7 +3885,7 @@ if test "x$gc" = "xboehm"; then - GC_FLAGS="-I$PWD/lib/Mvm/BoehmGC -DGC_THREADS" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/BoehmGC -DGC_THREADS" cat >>confdefs.h <<\_ACEOF #define USE_GC_BOEHM 1 @@ -3898,19 +3898,19 @@ GC_LIBS=BoehmGC case $target_os in *linux*) - GC_FLAGS="-I$PWD/lib/Mvm/BoehmGC -DGC_THREADS -DGC_LINUX_THREADS" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/BoehmGC -DGC_THREADS -DGC_LINUX_THREADS" ;; esac else GC_LIBS=GCMmap2 if test "x$gc" = "xmulti-mmap"; then - GC_FLAGS="-I$PWD/lib/Mvm/GCMmap2 -DWITH_TRACER -DMULTIPLE_GC" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/GCMmap2 -DWITH_TRACER -DMULTIPLE_GC" GC_MULTI_MMAP=1 GC_SINGLE_MMAP=0 else - GC_FLAGS="-I$PWD/lib/Mvm/GCMmap2 -DWITH_TRACER" + GC_FLAGS="-I\$(PROJ_SRC_ROOT)/lib/Mvm/GCMmap2 -DWITH_TRACER" GC_MULTI_MMAP=0 GC_SINGLE_MMAP=1 @@ -3947,7 +3947,7 @@ ISOLATE_BUILD=1 else if test "x$vmtype" = "xservice"; then - VM_FLAGS="-DMULTIPLE_VM -DSERVICE_GC -DMULTIPLE_GC -DSERVICE_VM -I$PWD/lib/Mvm/Allocator" + VM_FLAGS="-DMULTIPLE_VM -DSERVICE_GC -DMULTIPLE_GC -DSERVICE_VM -I\$(PROJ_SRC_ROOT)/lib/Mvm/Allocator" SERVICE_BUILD=1 fi fi @@ -7545,7 +7545,7 @@ # report actual input values of CONFIG_FILES etc. instead of their # values after options handling. ac_log=" -This file was extended by vmkit $as_me 0.0.1, which was +This file was extended by vmkit $as_me 0.24, which was generated by GNU Autoconf 2.61. Invocation command line was CONFIG_FILES = $CONFIG_FILES @@ -7598,7 +7598,7 @@ _ACEOF cat >>$CONFIG_STATUS <<_ACEOF ac_cs_version="\\ -vmkit config.status 0.0.1 +vmkit config.status 0.24 configured by $0, generated by GNU Autoconf 2.61, with options \\"`echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\" From nicolas.geoffray at lip6.fr Tue Oct 14 08:29:27 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 15:29:27 -0000 Subject: [vmkit-commits] [vmkit] r57491 - /vmkit/trunk/lib/Mvm/GCMmap2/Makefile Message-ID: <200810141529.m9EFTRCd013442@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 10:29:26 2008 New Revision: 57491 URL: http://llvm.org/viewvc/llvm-project?rev=57491&view=rev Log: Continue fixing make when OBJ != SRC. Modified: vmkit/trunk/lib/Mvm/GCMmap2/Makefile Modified: vmkit/trunk/lib/Mvm/GCMmap2/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/Makefile?rev=57491&r1=57490&r2=57491&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/Makefile (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/Makefile Tue Oct 14 10:29:26 2008 @@ -11,4 +11,4 @@ LIBRARYNAME = GCMmap2 include $(LEVEL)/Makefile.common -CXX.Flags += -I../CommonThread -I../Allocator +CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/Mvm/CommonThread -I(PROJ_SRC_ROOT)/lib/Mvm/Allocator From nicolas.geoffray at lip6.fr Tue Oct 14 08:30:55 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 15:30:55 -0000 Subject: [vmkit-commits] [vmkit] r57492 - /vmkit/trunk/lib/Mvm/GCMmap2/Makefile Message-ID: <200810141530.m9EFUted013508@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 10:30:55 2008 New Revision: 57492 URL: http://llvm.org/viewvc/llvm-project?rev=57492&view=rev Log: Ouups. Modified: vmkit/trunk/lib/Mvm/GCMmap2/Makefile Modified: vmkit/trunk/lib/Mvm/GCMmap2/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/Makefile?rev=57492&r1=57491&r2=57492&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/Makefile (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/Makefile Tue Oct 14 10:30:55 2008 @@ -11,4 +11,4 @@ LIBRARYNAME = GCMmap2 include $(LEVEL)/Makefile.common -CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/Mvm/CommonThread -I(PROJ_SRC_ROOT)/lib/Mvm/Allocator +CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/Mvm/CommonThread -I$(PROJ_SRC_ROOT)/lib/Mvm/Allocator From nicolas.geoffray at lip6.fr Tue Oct 14 10:05:34 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 17:05:34 -0000 Subject: [vmkit-commits] [vmkit] r57504 - in /vmkit/trunk: Makefile.common.in lib/JnJVM/Classpath/Makefile lib/JnJVM/LLVMRuntime/Makefile lib/JnJVM/VMCore/Makefile lib/Mvm/GCMmap2/Makefile lib/Mvm/Runtime/Makefile lib/N3/LLVMRuntime/Makefile lib/N3/Mono/Makefile lib/N3/PNetLib/Makefile lib/N3/VMCore/Makefile Message-ID: <200810141705.m9EH5ZQB017299@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 12:05:34 2008 New Revision: 57504 URL: http://llvm.org/viewvc/llvm-project?rev=57504&view=rev Log: Use PROJ_SRC_DIR instead of PROJ_SRC_ROOT Modified: vmkit/trunk/Makefile.common.in vmkit/trunk/lib/JnJVM/Classpath/Makefile vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile vmkit/trunk/lib/JnJVM/VMCore/Makefile vmkit/trunk/lib/Mvm/GCMmap2/Makefile vmkit/trunk/lib/Mvm/Runtime/Makefile vmkit/trunk/lib/N3/LLVMRuntime/Makefile vmkit/trunk/lib/N3/Mono/Makefile vmkit/trunk/lib/N3/PNetLib/Makefile vmkit/trunk/lib/N3/VMCore/Makefile Modified: vmkit/trunk/Makefile.common.in URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/Makefile.common.in?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/Makefile.common.in (original) +++ vmkit/trunk/Makefile.common.in Tue Oct 14 12:05:34 2008 @@ -1,6 +1,6 @@ # Set the name of the project here -PROJECT_NAME := vmkit -PROJ_VERSION := 0.1 +PROJECT_NAME := @PACKAGE_NAME@ +PROJ_VERSION := @PACKAGE_VERSION@ # Set this variable to the top of the LLVM source tree. LLVM_SRC_ROOT = @LLVM_SRC@ Modified: vmkit/trunk/lib/JnJVM/Classpath/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Makefile (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Makefile Tue Oct 14 12:05:34 2008 @@ -13,8 +13,8 @@ include $(LEVEL)/Makefile.config include $(LEVEL)/Makefile.common -CXX.Flags += -I../VMCore $(CLASSPATH_FLAGS) +CXX.Flags += -I$(PROJ_SRC_DIR)/../VMCore $(CLASSPATH_FLAGS) ifeq ($(ISOLATE_BUILD), 1) - CXX.Flags += -I../Isolate + CXX.Flags += -I$(PROJ_SRC_DIR)/../Isolate endif Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/Makefile Tue Oct 14 12:05:34 2008 @@ -10,23 +10,23 @@ include $(LEVEL)/Makefile.config -VMKIT_RUNTIME = runtime-default.ll +VMKIT_RUNTIME = $(PROJ_SRC_DIR)/runtime-default.ll ifeq ($(ISOLATE_BUILD), 1) -VMKIT_RUNTIME += runtime-isolate.ll +VMKIT_RUNTIME += $(PROJ_SRC_DIR)/runtime-isolate.ll endif ifeq ($(SERVICE_BUILD), 1) -VMKIT_RUNTIME += runtime-service.ll runtime-isolate.ll runtime-multi-mmap.ll +VMKIT_RUNTIME += $(PROJ_SRC_DIR)/runtime-service.ll $(PROJ_SRC_DIR)/runtime-isolate.ll $(PROJ_SRC_DIR)/runtime-multi-mmap.ll else ifeq ($(GC_MULTI_MMAP), 1) -VMKIT_RUNTIME += runtime-multi-mmap.ll +VMKIT_RUNTIME += $(PROJ_SRC_DIR)/runtime-multi-mmap.ll else ifeq ($(GC_SINGLE_MMAP), 1) -VMKIT_RUNTIME += runtime-single-mmap.ll +VMKIT_RUNTIME += $(PROJ_SRC_DIR)/runtime-single-mmap.ll else ifeq ($(GC_BOEHM), 1) -VMKIT_RUNTIME += runtime-boehm.ll +VMKIT_RUNTIME += $(PROJ_SRC_DIR)/runtime-boehm.ll endif endif endif Modified: vmkit/trunk/lib/JnJVM/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Makefile (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Makefile Tue Oct 14 12:05:34 2008 @@ -14,8 +14,8 @@ include $(LEVEL)/Makefile.common -CXX.Flags += -I../LLVMRuntime $(CLASSPATH_FLAGS) +CXX.Flags += -I$(PROJ_SRC_DIR)/../LLVMRuntime $(CLASSPATH_FLAGS) ifeq ($(ISOLATE_BUILD), 1) - CXX.Flags += -I../Isolate + CXX.Flags += -I$(PROJ_SRC_DIR)/../Isolate endif Modified: vmkit/trunk/lib/Mvm/GCMmap2/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/Makefile (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/Makefile Tue Oct 14 12:05:34 2008 @@ -11,4 +11,4 @@ LIBRARYNAME = GCMmap2 include $(LEVEL)/Makefile.common -CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/Mvm/CommonThread -I$(PROJ_SRC_ROOT)/lib/Mvm/Allocator +CXX.Flags += -I$(PROJ_SRC_DIR)/../CommonThread -I$(PROJ_SRC_DIR)/../Allocator Modified: vmkit/trunk/lib/Mvm/Runtime/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/Makefile (original) +++ vmkit/trunk/lib/Mvm/Runtime/Makefile Tue Oct 14 12:05:34 2008 @@ -11,7 +11,7 @@ include $(LEVEL)/Makefile.config LIBRARYNAME = Mvm -VMKIT_RUNTIME = LLVMRuntime.ll +VMKIT_RUNTIME = $(PROJ_SRC_DIR)/LLVMRuntime.ll BUILT_SOURCES = LLVMRuntime.inc include $(LEVEL)/Makefile.common Modified: vmkit/trunk/lib/N3/LLVMRuntime/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/LLVMRuntime/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/N3/LLVMRuntime/Makefile (original) +++ vmkit/trunk/lib/N3/LLVMRuntime/Makefile Tue Oct 14 12:05:34 2008 @@ -10,7 +10,7 @@ include $(LEVEL)/Makefile.config -VMKIT_RUNTIME = runtime.ll +VMKIT_RUNTIME = $(PROJ_SRC_ROOT)/lib/N3/LLVMRuntime/runtime.ll BUILT_SOURCES = LLVMRuntime.inc include $(LEVEL)/Makefile.common Modified: vmkit/trunk/lib/N3/Mono/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Mono/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/N3/Mono/Makefile (original) +++ vmkit/trunk/lib/N3/Mono/Makefile Tue Oct 14 12:05:34 2008 @@ -10,7 +10,7 @@ LIBRARYNAME = Mono include $(LEVEL)/Makefile.common -CXX.Flags += -I../VMCore +CXX.Flags += -I$(PROJ_SRC_DIR)/../VMCore CXX.Flags += `pkg-config --cflags glib-2.0 gthread-2.0` CXX.Flags += `pkg-config --cflags gmodule-2.0` Modified: vmkit/trunk/lib/N3/PNetLib/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/PNetLib/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/N3/PNetLib/Makefile (original) +++ vmkit/trunk/lib/N3/PNetLib/Makefile Tue Oct 14 12:05:34 2008 @@ -10,4 +10,4 @@ LIBRARYNAME = PNetLib include $(LEVEL)/Makefile.common -CXX.Flags += -I../VMCore +CXX.Flags += -I$(PROJ_SRC_DIR)/../VMCore Modified: vmkit/trunk/lib/N3/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/Makefile?rev=57504&r1=57503&r2=57504&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/Makefile (original) +++ vmkit/trunk/lib/N3/VMCore/Makefile Tue Oct 14 12:05:34 2008 @@ -1,4 +1,4 @@ -##===- lib/JnJVM/VMCore/Makefile ---------------------------*- Makefile -*-===## +##===- lib/N3/VMCore/Makefile ------------------------------*- Makefile -*-===## # # The vmkit project # @@ -11,4 +11,4 @@ LIBRARYNAME = N3 include $(LEVEL)/Makefile.common -CXX.Flags += -I../LLVMRuntime +CXX.Flags += -I$(PROJ_SRC_DIR)/../LLVMRuntime From nicolas.geoffray at lip6.fr Tue Oct 14 10:17:31 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 17:17:31 -0000 Subject: [vmkit-commits] [vmkit] r57509 - in /vmkit/trunk/lib: JnJVM/VMCore/Makefile N3/VMCore/Makefile Message-ID: <200810141717.m9EHHVZB017682@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 12:17:31 2008 New Revision: 57509 URL: http://llvm.org/viewvc/llvm-project?rev=57509&view=rev Log: Fix location of generated files. Modified: vmkit/trunk/lib/JnJVM/VMCore/Makefile vmkit/trunk/lib/N3/VMCore/Makefile Modified: vmkit/trunk/lib/JnJVM/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Makefile?rev=57509&r1=57508&r2=57509&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Makefile (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Makefile Tue Oct 14 12:17:31 2008 @@ -14,7 +14,7 @@ include $(LEVEL)/Makefile.common -CXX.Flags += -I$(PROJ_SRC_DIR)/../LLVMRuntime $(CLASSPATH_FLAGS) +CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime $(CLASSPATH_FLAGS) ifeq ($(ISOLATE_BUILD), 1) CXX.Flags += -I$(PROJ_SRC_DIR)/../Isolate Modified: vmkit/trunk/lib/N3/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/Makefile?rev=57509&r1=57508&r2=57509&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/Makefile (original) +++ vmkit/trunk/lib/N3/VMCore/Makefile Tue Oct 14 12:17:31 2008 @@ -11,4 +11,4 @@ LIBRARYNAME = N3 include $(LEVEL)/Makefile.common -CXX.Flags += -I$(PROJ_SRC_DIR)/../LLVMRuntime +CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime From nicolas.geoffray at lip6.fr Tue Oct 14 11:11:00 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 18:11:00 -0000 Subject: [vmkit-commits] [vmkit] r57512 - in /vmkit/trunk: autoconf/configure.ac configure lib/N3/Mono/Mono.cpp lib/N3/Mono/MonoPath.cpp.in lib/N3/Mono/MonoPath.inc.in lib/N3/PNetLib/PNetLib.cpp lib/N3/PNetLib/PNetPath.cpp.in lib/N3/PNetLib/PNetPath.inc.in Message-ID: <200810141811.m9EIB0hg020013@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 13:10:59 2008 New Revision: 57512 URL: http://llvm.org/viewvc/llvm-project?rev=57512&view=rev Log: Fix compilation of N3 when OBJ != SRC. Added: vmkit/trunk/lib/N3/Mono/MonoPath.inc.in - copied unchanged from r57488, vmkit/trunk/lib/N3/Mono/MonoPath.cpp.in vmkit/trunk/lib/N3/PNetLib/PNetPath.inc.in - copied unchanged from r57488, vmkit/trunk/lib/N3/PNetLib/PNetPath.cpp.in Removed: vmkit/trunk/lib/N3/Mono/MonoPath.cpp.in vmkit/trunk/lib/N3/PNetLib/PNetPath.cpp.in Modified: vmkit/trunk/autoconf/configure.ac vmkit/trunk/configure vmkit/trunk/lib/N3/Mono/Mono.cpp vmkit/trunk/lib/N3/PNetLib/PNetLib.cpp Modified: vmkit/trunk/autoconf/configure.ac URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=57512&r1=57511&r2=57512&view=diff ============================================================================== --- vmkit/trunk/autoconf/configure.ac (original) +++ vmkit/trunk/autoconf/configure.ac Tue Oct 14 13:10:59 2008 @@ -511,8 +511,8 @@ AC_CONFIG_FILES(Makefile.common) AC_CONFIG_FILES(Makefile.config) AC_CONFIG_FILES([lib/JnJVM/Classpath/Classpath.h]) -AC_CONFIG_FILES([lib/N3/PNetLib/PNetPath.cpp]) -AC_CONFIG_FILES([lib/N3/Mono/MonoPath.cpp]) +AC_CONFIG_FILES([lib/N3/PNetLib/PNetPath.inc]) +AC_CONFIG_FILES([lib/N3/Mono/MonoPath.inc]) dnl Do special configuration of Makefiles AC_CONFIG_MAKEFILE(Makefile) Modified: vmkit/trunk/configure URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=57512&r1=57511&r2=57512&view=diff ============================================================================== --- vmkit/trunk/configure (original) +++ vmkit/trunk/configure Tue Oct 14 13:10:59 2008 @@ -7136,9 +7136,9 @@ ac_config_files="$ac_config_files lib/JnJVM/Classpath/Classpath.h" -ac_config_files="$ac_config_files lib/N3/PNetLib/PNetPath.cpp" +ac_config_files="$ac_config_files lib/N3/PNetLib/PNetPath.inc" -ac_config_files="$ac_config_files lib/N3/Mono/MonoPath.cpp" +ac_config_files="$ac_config_files lib/N3/Mono/MonoPath.inc" ac_config_commands="$ac_config_commands Makefile" @@ -7716,8 +7716,8 @@ "Makefile.common") CONFIG_FILES="$CONFIG_FILES Makefile.common" ;; "Makefile.config") CONFIG_FILES="$CONFIG_FILES Makefile.config" ;; "lib/JnJVM/Classpath/Classpath.h") CONFIG_FILES="$CONFIG_FILES lib/JnJVM/Classpath/Classpath.h" ;; - "lib/N3/PNetLib/PNetPath.cpp") CONFIG_FILES="$CONFIG_FILES lib/N3/PNetLib/PNetPath.cpp" ;; - "lib/N3/Mono/MonoPath.cpp") CONFIG_FILES="$CONFIG_FILES lib/N3/Mono/MonoPath.cpp" ;; + "lib/N3/PNetLib/PNetPath.inc") CONFIG_FILES="$CONFIG_FILES lib/N3/PNetLib/PNetPath.inc" ;; + "lib/N3/Mono/MonoPath.inc") CONFIG_FILES="$CONFIG_FILES lib/N3/Mono/MonoPath.inc" ;; "Makefile") CONFIG_COMMANDS="$CONFIG_COMMANDS Makefile" ;; "lib/Makefile") CONFIG_COMMANDS="$CONFIG_COMMANDS lib/Makefile" ;; Modified: vmkit/trunk/lib/N3/Mono/Mono.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Mono/Mono.cpp?rev=57512&r1=57511&r2=57512&view=diff ============================================================================== --- vmkit/trunk/lib/N3/Mono/Mono.cpp (original) +++ vmkit/trunk/lib/N3/Mono/Mono.cpp Tue Oct 14 13:10:59 2008 @@ -23,6 +23,8 @@ #include "number-formatter.h" +#include "MonoPath.inc" + using namespace n3; extern "C" int System_Environment_get_Platform (void) { Removed: vmkit/trunk/lib/N3/Mono/MonoPath.cpp.in URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/Mono/MonoPath.cpp.in?rev=57511&view=auto ============================================================================== --- vmkit/trunk/lib/N3/Mono/MonoPath.cpp.in (original) +++ vmkit/trunk/lib/N3/Mono/MonoPath.cpp.in (removed) @@ -1,15 +0,0 @@ -//===------ MonoPath.cpp - mscorlib.dll location for mono -----------------===// -// -// N3 -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "MSCorlib.h" - -using namespace n3; - -const char* MSCorlib::libsPath = "@monopath@/"; - Modified: vmkit/trunk/lib/N3/PNetLib/PNetLib.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/PNetLib/PNetLib.cpp?rev=57512&r1=57511&r2=57512&view=diff ============================================================================== --- vmkit/trunk/lib/N3/PNetLib/PNetLib.cpp (original) +++ vmkit/trunk/lib/N3/PNetLib/PNetLib.cpp Tue Oct 14 13:10:59 2008 @@ -28,6 +28,8 @@ #include "VMObject.h" #include "VMThread.h" +#include "PNetPath.inc" + using namespace n3; #define IL_CONSOLE_NORMAL 0 Removed: vmkit/trunk/lib/N3/PNetLib/PNetPath.cpp.in URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/PNetLib/PNetPath.cpp.in?rev=57511&view=auto ============================================================================== --- vmkit/trunk/lib/N3/PNetLib/PNetPath.cpp.in (original) +++ vmkit/trunk/lib/N3/PNetLib/PNetPath.cpp.in (removed) @@ -1,15 +0,0 @@ -//===---------- PNetPath.h - Configuration for pnetlib --------------------===// -// -// N3 -// -// This file is distributed under the University of Illinois Open Source -// License. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#include "MSCorlib.h" - -using namespace n3; - -const char* MSCorlib::libsPath = "@pnetlibpath@/"; - From nicolas.geoffray at lip6.fr Tue Oct 14 07:08:50 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 14 Oct 2008 14:08:50 -0000 Subject: [vmkit-commits] [vmkit] r57487 - in /vmkit/trunk: include/mvm/Allocator.h include/mvm/Threads/Thread.h lib/JnJVM/Classpath/ClasspathVMRuntime.cpp lib/JnJVM/Classpath/ClasspathVMThread.cpp lib/JnJVM/VMCore/JavaThread.cpp lib/JnJVM/VMCore/JavaThread.h lib/JnJVM/VMCore/Jnjvm.cpp lib/Mvm/Runtime/Object.cpp lib/N3/VMCore/VMThread.cpp lib/N3/VMCore/VMThread.h Message-ID: <200810141408.m9EE8ouP010487@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 14 09:08:49 2008 New Revision: 57487 URL: http://llvm.org/viewvc/llvm-project?rev=57487&view=rev Log: Code cleanup for thread creation. Add two new constructors for STL containers. The first allocator is vm-specific, the second is class-loader specific, ie it is set by the current class loader in Java. Modified: vmkit/trunk/include/mvm/Allocator.h vmkit/trunk/include/mvm/Threads/Thread.h vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.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/Mvm/Runtime/Object.cpp vmkit/trunk/lib/N3/VMCore/VMThread.cpp vmkit/trunk/lib/N3/VMCore/VMThread.h Modified: vmkit/trunk/include/mvm/Allocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Allocator.h (original) +++ vmkit/trunk/include/mvm/Allocator.h Tue Oct 14 09:08:49 2008 @@ -11,6 +11,7 @@ #define MVM_ALLOCATOR_H #include +#include #include "llvm/Support/Allocator.h" @@ -25,7 +26,6 @@ namespace mvm { - class Allocator { private: #ifdef MULTIPLE_GC @@ -74,8 +74,154 @@ } void Deallocate(void* obj) {} + + static void* ThreadAllocate(size_t sz); + static void* VMAllocate(size_t sz); +}; + +template +class STLVMAllocator { +public: + // type definitions + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + // rebind allocator to type U + template + struct rebind { + typedef STLVMAllocator other; + }; + + // return address of values + pointer address (reference value) const { + return &value; + } + const_pointer address (const_reference value) const { + return &value; + } + + + STLVMAllocator() {} + template STLVMAllocator(STLVMAllocator&) {} + + ~STLVMAllocator() {} + + size_type max_size () const { + return std::numeric_limits::max() / sizeof(T); + } + + // allocate but don't initialize num elements of type T + pointer allocate (size_type num, const void* = 0) { + pointer ret = (pointer)mvm::BumpPtrAllocator::VMAllocate(num*sizeof(T)); + return ret; + } + + // initialize elements of allocated storage p with value value + void construct (pointer p, const T& value) { + // initialize memory with placement new + new((void*)p)T(value); + } + + // destroy elements of initialized storage p + void destroy (pointer p) { + // destroy objects by calling their destructor + p->~T(); + } + + // deallocate storage p of deleted elements + void deallocate (pointer p, size_type num) {} }; +// return that all specializations of this allocator are interchangeable +template +bool operator== (const STLVMAllocator&, + const STLVMAllocator&) { + return true; +} + +template +bool operator!= (const STLVMAllocator&, + const STLVMAllocator&) { + return false; +} + +template +class STLThreadAllocator { +public: + // type definitions + typedef T value_type; + typedef T* pointer; + typedef const T* const_pointer; + typedef T& reference; + typedef const T& const_reference; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + // rebind allocator to type U + template + struct rebind { + typedef STLThreadAllocator other; + }; + + // return address of values + pointer address (reference value) const { + return &value; + } + const_pointer address (const_reference value) const { + return &value; + } + + + STLThreadAllocator() {} + template STLThreadAllocator(STLThreadAllocator&) {} + + ~STLThreadAllocator() {} + + size_type max_size () const { + return std::numeric_limits::max() / sizeof(T); + } + + // allocate but don't initialize num elements of type T + pointer allocate (size_type num, const void* = 0) { + pointer ret = (pointer)mvm::BumpPtrAllocator::ThreadAllocate(num*sizeof(T)); + return ret; + } + + // initialize elements of allocated storage p with value value + void construct (pointer p, const T& value) { + // initialize memory with placement new + new((void*)p)T(value); + } + + // destroy elements of initialized storage p + void destroy (pointer p) { + // destroy objects by calling their destructor + p->~T(); + } + + // deallocate storage p of deleted elements + void deallocate (pointer p, size_type num) {} +}; + +// return that all specializations of this allocator are interchangeable +template +bool operator== (const STLThreadAllocator&, + const STLThreadAllocator&) { + return true; +} + +template +bool operator!= (const STLThreadAllocator&, + const STLThreadAllocator&) { + return false; +} + + class PermanentObject { public: Modified: vmkit/trunk/include/mvm/Threads/Thread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Threads/Thread.h?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Threads/Thread.h (original) +++ vmkit/trunk/include/mvm/Threads/Thread.h Tue Oct 14 09:08:49 2008 @@ -14,18 +14,20 @@ #include "MvmGC.h" #include "mvm/JIT.h" +#include "mvm/Object.h" #include "mvm/Threads/Key.h" -class Allocator; class Collector; namespace mvm { +class BumpPtrAllocator; + /// 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. -class Thread : public gc { +class Thread : public Object { public: /// yield - Yield the processor to another thread. @@ -65,7 +67,14 @@ static mvm::Key* threadKey; public: - Allocator* allocator; + + /// vmAllocator - Virtual machine specific allocator. + /// + mvm::BumpPtrAllocator* vmAllocator; + + /// threadAllocator - Current allocator for the thread. Useful for things + /// like class loaders which do not allocate per-vm. + mvm::BumpPtrAllocator* threadAllocator; /// baseSP - The base stack pointer. /// @@ -98,8 +107,7 @@ private: /// internalClearException - Clear any pending exception. - virtual void internalClearException() { - } + virtual void internalClearException() {} public: Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Tue Oct 14 09:08:49 2008 @@ -21,6 +21,7 @@ #include "JavaTypes.h" #include "JavaThread.h" #include "Jnjvm.h" +#include "LockedMap.h" #include "NativeUtil.h" @@ -54,8 +55,7 @@ memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, lgPost * sizeof(uint16)); - // TODO: find a better place to store the UTF8 - const UTF8* res = vm->bootstrapLoader->readerConstructUTF8(elements, size); + const UTF8* res = vm->hashUTF8->lookupOrCreateReader(elements, size); return (jobject)(vm->UTF8ToStr(res)); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp Tue Oct 14 09:08:49 2008 @@ -41,22 +41,30 @@ } static void start(JavaObject* vmThread) { - int argc; + // Get the classpath Classpath* upcalls = vmThread->classOf->classLoader->bootstrapLoader->upcalls; - JavaThread* intern = (JavaThread*)upcalls->vmdataVMThread->getObjectField(vmThread); - Jnjvm* isolate = intern->isolate; - mvm::Thread::set(intern); -#ifdef MULTIPLE_GC - intern->GC->inject_my_thread(&argc); -#else - Collector::inject_my_thread(&argc); -#endif - UserClass* vmthClass = (UserClass*)vmThread->classOf; - JavaObject* thread = isolate->upcalls->assocThread->getObjectField(vmThread); - ThreadSystem& ts = isolate->threadSystem; - bool isDaemon = isolate->upcalls->daemon->getInt8Field(thread); - intern->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; + // When starting the thread, the creator placed the vm object in the vmThread + Jnjvm* vm = (Jnjvm*)upcalls->vmdataVMThread->getObjectField(vmThread); + assert(vm && "Thread Creator did not put the vm"); + + // Classpath has set this field. + JavaObject* javaThread = upcalls->assocThread->getObjectField(vmThread); + assert(javaThread && "VMThread with no Java equivalent"); + + // Create the Java thread.Allocating it on stack will make it call the + // destructor when the function exists. + JavaThread th(javaThread, vm, &upcalls); + + // Ok, now we can set the real value of vmdata, which is the JavaThread + // object. + vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)(void*)&th); + + UserClass* vmthClass = (UserClass*)vmThread->classOf; + ThreadSystem& ts = vm->threadSystem; + + + bool isDaemon = vm->upcalls->daemon->getInt8Field(javaThread); if (!isDaemon) { ts.nonDaemonLock.lock(); @@ -64,15 +72,7 @@ ts.nonDaemonLock.unlock(); } -#ifdef SERVICE_VM - ServiceDomain* vm = (ServiceDomain*)isolate; - vm->startExecution(); - vm->lock->lock(); - vm->numThreads++; - vm->lock->unlock(); -#endif - - isolate->upcalls->runVMThread->invokeIntSpecial(isolate, vmthClass, vmThread); + upcalls->runVMThread->invokeIntSpecial(vm, vmthClass, vmThread); if (!isDaemon) { ts.nonDaemonLock.lock(); @@ -81,18 +81,6 @@ ts.nonDaemonVar.signal(); ts.nonDaemonLock.unlock(); } - -#ifdef SERVICE_VM - vm->lock->lock(); - vm->numThreads--; - vm->lock->unlock(); -#endif - -#ifdef MULTIPLE_GC - intern->GC->remove_my_thread(); -#else - Collector::remove_my_thread(); -#endif } JNIEXPORT void JNICALL Java_java_lang_VMThread_start( @@ -102,16 +90,13 @@ jobject _vmThread, sint64 stackSize) { Jnjvm* vm = JavaThread::get()->isolate; JavaObject* vmThread = (JavaObject*)_vmThread; - JavaObject* javaThread = vm->upcalls->assocThread->getObjectField(vmThread); - assert(javaThread); + + // Set the vm in the vmData. We do this to give the vm to the created + // thread. The created thread will change the field to its JavaThread + // object. + vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)vm); - JavaThread* th = allocator_new(vm->allocator, JavaThread)(); - th->initialise(javaThread, vm); - vm->upcalls->vmdataVMThread->setObjectField(vmThread, (JavaObject*)th); int tid = 0; -#ifdef MULTIPLE_GC - th->GC = mvm::Thread::get()->GC; -#endif mvm::Thread::start(&tid, (int (*)(void *))start, (void*)vmThread); } @@ -123,11 +108,12 @@ jobject _vmthread) { Jnjvm* vm = JavaThread::get()->isolate; JavaObject* vmthread = (JavaObject*)_vmthread; - - while (vm->upcalls->vmdataVMThread->getObjectField(vmthread) == 0) + JavaField* field = vm->upcalls->vmdataVMThread; + // It's possible that the thread to be interrupted has not finished + // its initialization. Wait until the initialization is done. + while (field->getObjectField(vmthread) == 0) mvm::Thread::yield(); - JavaField* field = vm->upcalls->vmdataVMThread; JavaThread* th = (JavaThread*)field->getObjectField(vmthread); th->lock.lock(); th->interruptFlag = 1; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Tue Oct 14 09:08:49 2008 @@ -27,5 +27,54 @@ void JavaThread::print(mvm::PrintBuffer* buf) const { buf->write("Thread:"); - javaThread->print(buf); + if (javaThread) javaThread->print(buf); +} + +JavaThread::JavaThread(JavaObject* thread, Jnjvm* vm, void* sp) { + if (!thread) bootstrap = true; + else bootstrap = false; + javaThread = thread; + isolate = vm; + interruptFlag = 0; + state = StateRunning; + pendingException = 0; + vmAllocator = &isolate->allocator; + baseSP = sp; + mvm::Thread::set(this); + threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; + + if (!bootstrap) { +#ifdef MULTIPLE_GC + GC = isolate->GC; + GC->inject_my_thread(sp); +#else + Collector::inject_my_thread(sp); +#endif + +#ifdef SERVICE_VM + ServiceDomain* domain = (ServiceDomain*)vm; + domain->startExecution(); + domain->lock->lock(); + domain->numThreads++; + domain->lock->unlock(); +#endif + } + + +} + +JavaThread::~JavaThread() { + if (!bootstrap) { +#ifdef MULTIPLE_GC + GC->remove_my_thread(); +#else + Collector::remove_my_thread(); +#endif +#ifdef SERVICE_VM + ServiceDomain* vm = (ServiceDomain*)isolate; + vm->lock->lock(); + vm->numThreads--; + vm->lock->unlock(); +#endif + } } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Tue Oct 14 09:08:49 2008 @@ -41,6 +41,7 @@ uint32 interruptFlag; uint32 state; std::vector sjlj_buffers; + bool bootstrap; static const unsigned int StateRunning; static const unsigned int StateWaiting; @@ -48,16 +49,10 @@ virtual void print(mvm::PrintBuffer *buf) const; virtual void TRACER; - ~JavaThread() {} - JavaThread() {} + JavaThread() { bootstrap = true; } + ~JavaThread(); - void initialise(JavaObject* thread, Jnjvm* isolate) { - this->javaThread = thread; - this->isolate = isolate; - this->interruptFlag = 0; - this->state = StateRunning; - this->pendingException = 0; - } + JavaThread(JavaObject* thread, Jnjvm* isolate, void* sp); static JavaThread* get() { return (JavaThread*)mvm::Thread::get(); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Oct 14 09:08:49 2008 @@ -776,11 +776,7 @@ argv = argv + pos - 1; argc = argc - pos + 1; - bootstrapThread = allocator_new(allocator, JavaThread)(); - bootstrapThread->initialise(0, this); - bootstrapThread->baseSP = mvm::Thread::get()->baseSP; - JavaThread::set(bootstrapThread); - bootstrapThread->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00; + bootstrapThread = gc_new(JavaThread)(0, this, mvm::Thread::get()->baseSP); loadBootstrap(); Modified: vmkit/trunk/lib/Mvm/Runtime/Object.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Object.cpp?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/Object.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/Object.cpp Tue Oct 14 09:08:49 2008 @@ -10,6 +10,7 @@ #include #include "MvmGC.h" +#include "mvm/Allocator.h" #include "mvm/Method.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" @@ -114,3 +115,13 @@ } buf->write("\""); } + +void* mvm::BumpPtrAllocator::VMAllocate(size_t sz) { + mvm::BumpPtrAllocator* allocator = mvm::Thread::get()->vmAllocator; + return allocator->Allocate(sz); +} + +void* mvm::BumpPtrAllocator::ThreadAllocate(size_t sz) { + mvm::BumpPtrAllocator* allocator = mvm::Thread::get()->threadAllocator; + return allocator->Allocate(sz); +} Modified: vmkit/trunk/lib/N3/VMCore/VMThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMThread.cpp?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMThread.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/VMThread.cpp Tue Oct 14 09:08:49 2008 @@ -29,7 +29,7 @@ const unsigned int VMThread::StateWaiting = 1; const unsigned int VMThread::StateInterrupted = 2; -void VMThread::print(mvm::PrintBuffer* buf) { +void VMThread::print(mvm::PrintBuffer* buf) const { buf->write("Thread:"); vmThread->print(buf); } Modified: vmkit/trunk/lib/N3/VMCore/VMThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VMThread.h?rev=57487&r1=57486&r2=57487&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VMThread.h (original) +++ vmkit/trunk/lib/N3/VMCore/VMThread.h Tue Oct 14 09:08:49 2008 @@ -45,7 +45,7 @@ static const unsigned int StateWaiting; static const unsigned int StateInterrupted; - virtual void print(mvm::PrintBuffer *buf); + virtual void print(mvm::PrintBuffer *buf) const; virtual void TRACER; ~VMThread(); VMThread(); From nicolas.geoffray at lip6.fr Wed Oct 15 14:38:14 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 15 Oct 2008 21:38:14 -0000 Subject: [vmkit-commits] [vmkit] r57601 - /vmkit/trunk/CREDITS.TXT Message-ID: <200810152138.m9FLcEXp023928@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 15 16:38:13 2008 New Revision: 57601 URL: http://llvm.org/viewvc/llvm-project?rev=57601&view=rev Log: Add Tilmann in credits. Modified: vmkit/trunk/CREDITS.TXT Modified: vmkit/trunk/CREDITS.TXT URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/CREDITS.TXT?rev=57601&r1=57600&r2=57601&view=diff ============================================================================== --- vmkit/trunk/CREDITS.TXT (original) +++ vmkit/trunk/CREDITS.TXT Wed Oct 15 16:38:13 2008 @@ -23,6 +23,9 @@ E: sylvain.marechal at lip6.fr D: Original autoconf support +N: Tilmann Scheller +D: Generics support in N3. + N: Gael Thomas E: gael.thomas at lip6.fr W: http://www-src.lip6.fr/homepages/Gael.Thomas/ From nicolas.geoffray at lip6.fr Wed Oct 15 14:45:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 15 Oct 2008 21:45:29 -0000 Subject: [vmkit-commits] [vmkit] r57602 - in /vmkit/trunk/www: get_involved.html get_started.html Message-ID: <200810152145.m9FLjTj8024155@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 15 16:45:28 2008 New Revision: 57602 URL: http://llvm.org/viewvc/llvm-project?rev=57602&view=rev Log: VMKit works on macosx/x86. Modified: vmkit/trunk/www/get_involved.html vmkit/trunk/www/get_started.html Modified: vmkit/trunk/www/get_involved.html URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/www/get_involved.html?rev=57602&r1=57601&r2=57602&view=diff ============================================================================== --- vmkit/trunk/www/get_involved.html (original) +++ vmkit/trunk/www/get_involved.html Wed Oct 15 16:45:28 2008 @@ -77,10 +77,9 @@
  • Write a test-suite and nightly tester for vmkit: vmkit needs it!
    • -
  • Port vmkit to new architectures: currently, vmkit runs on linux/x86 -and has some floating point issues on linux/powerpc -See PR642. A port to -darwin/x86 would be nice. +
  • Port vmkit to new architectures: currently, vmkit runs on linux/x86, +MacOSX/x86 and has some floating point issues on linux/powerpc . +See PR642.
  • Implement a generational GC in llvm/vmkit: llvm has the interface Modified: vmkit/trunk/www/get_started.html URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/www/get_started.html?rev=57602&r1=57601&r2=57602&view=diff ============================================================================== --- vmkit/trunk/www/get_started.html (original) +++ vmkit/trunk/www/get_started.html Wed Oct 15 16:45:28 2008 @@ -60,7 +60,6 @@

    Some of the more notable missing pieces in the CLI runtime are:

      -
    1. Support for generics.
    2. Support for arithmetic overflow.
    3. Support for CLI object finalization semantics.
    4. Thread support.
      5. @@ -69,7 +68,7 @@

      Some of the common missing pieces in vmkit/llvm are:

        -
      1. Support for other platforms than linux/x86.
        2. +
      2. A generational Garbage collector.
      3. Hotspot-like virtual machine (e.g mixed interpretation/compilation).
      From nicolas.geoffray at lip6.fr Thu Oct 16 07:04:41 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 16 Oct 2008 14:04:41 -0000 Subject: [vmkit-commits] [vmkit] r57637 - in /vmkit/trunk/lib: JnJVM/Classpath/ JnJVM/VMCore/ Mvm/Runtime/ Message-ID: <200810161404.m9GE4gx9005880@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 16 09:04:41 2008 New Revision: 57637 URL: http://llvm.org/viewvc/llvm-project?rev=57637&view=rev Log: A JVM does not hash its utf8s, but use the GC to allocate them. This helps in not having class loaders that creates lots of utf8s and keeping them eternally in memory. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaString.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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp vmkit/trunk/lib/Mvm/Runtime/Object.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Thu Oct 16 09:04:41 2008 @@ -56,7 +56,7 @@ Jnjvm* vm = JavaThread::get()->isolate; JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); - UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, + UserCommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str, vm, true, false); if (cl != 0) { if (clinit) { @@ -130,7 +130,7 @@ // TODO: check parameter types UserClass* Meth = vm->upcalls->newMethod; JavaObject* tmp = Meth->doNew(vm); - JavaString* str = vm->UTF8ToStr(meth->name); + JavaString* str = vm->internalUTF8ToStr(meth->name); upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, Cl, str, meth); ret->elements[index] = tmp; } @@ -162,7 +162,7 @@ (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); const UTF8* iname = cl->getName(); - const UTF8* res = iname->internalToJava(vm->hashUTF8, 0, iname->size); + const UTF8* res = iname->internalToJava(vm, 0, iname->size); return (jobject)(vm->UTF8ToStr(res)); } @@ -293,8 +293,8 @@ // TODO: check parameter types UserClass* Field = vm->upcalls->newField; JavaObject* tmp = Field->doNew(vm); - vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, - vm->UTF8ToStr(field->name), field); + JavaString* name = vm->internalUTF8ToStr(field->name); + vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, Cl, name, field); ret->elements[index] = tmp; } return (jobject)ret; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp Thu Oct 16 09:04:41 2008 @@ -73,7 +73,8 @@ JavaString* str = (JavaString*)_str; JnjvmClassLoader* JCL = vm->bootstrapLoader; - UserCommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false); + UserCommonClass* cl = JCL->lookupClassFromJavaString(str, vm, doResolve, + false); if (cl != 0) return (jclass)cl->getClassDelegatee(vm); @@ -98,8 +99,7 @@ JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader, vm); JavaString* str = (JavaString*)_str; - const UTF8* name = str->value->javaToInternal(vm->hashUTF8, str->offset, - str->count); + 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)); Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Thu Oct 16 09:04:41 2008 @@ -20,6 +20,7 @@ #include "JavaString.h" #include "JavaTypes.h" #include "JavaThread.h" +#include "JavaUpcalls.h" #include "Jnjvm.h" #include "LockedMap.h" #include "NativeUtil.h" @@ -47,7 +48,8 @@ sint32 lgPost = vm->postlib->size; uint32 size = (uint32)(lgPre + lgLib + lgPost); - uint16* elements = (uint16*)alloca(size * sizeof(uint16)); + ArrayUInt16* array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm); + uint16* elements = array->elements; memmove(elements, vm->prelib->elements, lgPre * sizeof(uint16)); memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]), @@ -55,9 +57,7 @@ memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, lgPost * sizeof(uint16)); - const UTF8* res = vm->hashUTF8->lookupOrCreateReader(elements, size); - - return (jobject)(vm->UTF8ToStr(res)); + return (jobject)(vm->UTF8ToStr((const UTF8*)array)); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp Thu Oct 16 09:04:41 2008 @@ -51,10 +51,9 @@ JavaObject* consStackElement(JavaMethod* meth, int* ip) { Jnjvm* vm = JavaThread::get()->isolate; - JavaObject* methodName = vm->UTF8ToStr(meth->name); + JavaObject* methodName = vm->internalUTF8ToStr(meth->name); Class* cl = meth->classDef; - const UTF8* internal = cl->name->internalToJava(vm->hashUTF8, 0, - cl->name->size); + const UTF8* internal = cl->name->internalToJava(vm, 0, cl->name->size); JavaObject* className = vm->UTF8ToStr(internal); JavaObject* sourceName = 0; @@ -63,7 +62,7 @@ if (sourceAtt) { Reader reader(sourceAtt, cl->getBytes()); uint16 index = reader.readU2(); - sourceName = vm->UTF8ToStr(cl->getConstantPool()->UTF8At(index)); + sourceName = vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index)); } bool native = isNative(meth->access); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.cpp Thu Oct 16 09:04:41 2008 @@ -16,6 +16,7 @@ #include "JavaTypes.h" #include "Jnjvm.h" #include "JavaThread.h" +#include "JavaUpcalls.h" #include "LockedMap.h" @@ -39,23 +40,25 @@ buf->writeChar((char)elements[i]); } -const UTF8* UTF8::javaToInternal(UTF8Map* map, unsigned int start, +const UTF8* UTF8::javaToInternal(Jnjvm* vm, unsigned int start, unsigned int len) const { - uint16* java = (uint16*) alloca(len * sizeof(uint16)); + UTF8* array = (UTF8*)vm->upcalls->ArrayOfChar->doNew(len, vm); + uint16* java = array->elements; for (uint32 i = 0; i < len; i++) { uint16 cur = elements[start + i]; if (cur == '.') java[i] = '/'; else java[i] = cur; } - return map->lookupOrCreateReader(java, len); + return (const UTF8*)array; } // We also define a checked java to internal function to disallow // users to load classes with '/'. -const UTF8* UTF8::checkedJavaToInternal(UTF8Map* map, unsigned int start, +const UTF8* UTF8::checkedJavaToInternal(Jnjvm* vm, unsigned int start, unsigned int len) const { - uint16* java = (uint16*) alloca(len * sizeof(uint16)); + UTF8* array = (UTF8*)vm->upcalls->ArrayOfChar->doNew(len, vm); + uint16* java = array->elements; for (uint32 i = 0; i < len; i++) { uint16 cur = elements[start + i]; if (cur == '.') java[i] = '/'; @@ -63,19 +66,20 @@ else java[i] = cur; } - return map->lookupOrCreateReader(java, len); + return (const UTF8*)array; } -const UTF8* UTF8::internalToJava(UTF8Map* map, unsigned int start, +const UTF8* UTF8::internalToJava(Jnjvm* vm, unsigned int start, unsigned int len) const { - uint16* java = (uint16*) alloca(len * sizeof(uint16)); + UTF8* array = (UTF8*)vm->upcalls->ArrayOfChar->doNew(len, vm); + uint16* java = array->elements; for (uint32 i = 0; i < len; i++) { uint16 cur = elements[start + i]; if (cur == '/') java[i] = '.'; else java[i] = cur; } - return map->lookupOrCreateReader(java, len); + return (const UTF8*)array; } const UTF8* UTF8::extract(UTF8Map* map, uint32 start, uint32 end) const { @@ -89,6 +93,18 @@ return map->lookupOrCreateReader(buf, len); } +const UTF8* UTF8::extract(Jnjvm* vm, uint32 start, uint32 end) const { + uint32 len = end - start; + UTF8* array = (UTF8*) vm->upcalls->ArrayOfChar->doNew(len, vm); + uint16* buf = array->elements; + + for (uint32 i = 0; i < len; i++) { + buf[i] = elements[i + start]; + } + + return (const UTF8*)array; +} + char* UTF8::UTF8ToAsciiz() const { #ifndef DEBUG mvm::NativeString* buf = mvm::NativeString::alloc(size + 1); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaArray.h Thu Oct 16 09:04:41 2008 @@ -112,30 +112,49 @@ /// instance hashes UTF8. UTF8 are not allocated by the application's garbage /// collector, but resides in permanent memory (e.g malloc). class UTF8 : public ArrayUInt16 { -public: + friend class UTF8Map; +private: + + /// operator new - Redefines the new operator of this class to allocate + /// its objects in permanent memory, not with the garbage collector. + void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, + sint32 size) { + return allocator.Allocate(sz + size * sizeof(uint16)); + } /// acons - Allocates an UTF8 in permanent memory. The class argument must be /// JavaArray::ofChar. static const UTF8* acons(sint32 n, UserClassArray* cl, mvm::BumpPtrAllocator& allocator); +public: + /// internalToJava - Creates a copy of the UTF8 at its given offset and size /// woth all its '.' replaced by '/'. The JVM bytecode reference classes in /// packages with the '.' as the separating character. The JVM language uses /// the '/' character. - const UTF8* internalToJava(UTF8Map* map, unsigned int start, + /// + const UTF8* internalToJava(Jnjvm* vm, unsigned int start, unsigned int len) const; /// javaToInternal - Replaces all '/' into '.'. - const UTF8* javaToInternal(UTF8Map* map, unsigned int start, + const UTF8* javaToInternal(Jnjvm* vm, unsigned int start, unsigned int len) const; /// checkedJavaToInternal - Replaces all '/' into '.'. Returns null if the /// UTF8 contains a '/', as Java does not allow things like /// Class.forName("java/lang/Object") - const UTF8* checkedJavaToInternal(UTF8Map* map, unsigned int start, + const UTF8* checkedJavaToInternal(Jnjvm* vm, unsigned int start, unsigned int len) const; + /// extract - Creates an UTF8 by extracting the contents at the given size + /// of this. + const UTF8* extract(Jnjvm* vm, uint32 start, uint32 len) const; + + /// extract - Similar, but creates it in the map. + const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const; + + /// UTF8ToAsciiz - Allocates a C string with the contents of this UTF8. char* UTF8ToAsciiz() const; @@ -143,10 +162,6 @@ return UTF8ToAsciiz(); } - /// extract - Creates an UTF8 by extracting the contents at the given size - /// of this. - const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const; - bool equals(const UTF8* other) const { if (other == this) return true; else if (size != other->size) return false; @@ -163,13 +178,6 @@ /// print - Prints the UTF8 for debugging purposes. virtual void print(mvm::PrintBuffer* buf) const; - /// operator new - Redefines the new operator of this class to allocate - /// its objects in permanent memory, not with the garbage collector. - void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator, - sint32 size) { - return allocator.Allocate(sz + size * sizeof(uint16)); - } - }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Thu Oct 16 09:04:41 2008 @@ -546,8 +546,7 @@ } return (Tname->elements[prof] == I_REF) && - (res && curS->inheritName(Tname->extract(vm->hashUTF8, prof + 1, - len - 1))); + (res && curS->inheritName(Tname->extract(vm, prof + 1, len - 1))); } else { return false; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Thu Oct 16 09:04:41 2008 @@ -80,40 +80,9 @@ uint32 JavaConstantPool::CtpReaderUTF8(JavaConstantPool* ctp, Reader& reader, uint32 index) { + ctp->ctpDef[index] = reader.cursor; uint16 len = reader.readU2(); - uint16* buf = (uint16*)alloca(len * sizeof(uint16)); - uint32 n = 0; - uint32 i = 0; - - while (i < len) { - uint32 cur = reader.readU1(); - if (cur & 0x80) { - uint32 y = reader.readU1(); - if (cur & 0x20) { - uint32 z = reader.readU1(); - cur = ((cur & 0x0F) << 12) + - ((y & 0x3F) << 6) + - (z & 0x3F); - i += 3; - } else { - cur = ((cur & 0x1F) << 6) + - (y & 0x3F); - i += 2; - } - } else { - ++i; - } - buf[n] = ((uint16)cur); - ++n; - } - - Class* cl = ctp->classDef; - const UTF8* utf8 = cl->classLoader->hashUTF8->lookupOrCreateReader(buf, n); - ctp->ctpRes[index] = (UTF8*)utf8; - - PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] \t\t\"%s\"\n", index, - utf8->printString()); - + reader.cursor += len; return 1; } @@ -218,6 +187,44 @@ JavaThread::get()->isolate->classFormatError( "bad constant pool number for utf8 at entry %d", entry); } + + if (!ctpRes[entry]) { + Reader reader(classDef->bytes, ctpDef[entry]); + uint32 len = reader.readU2(); + uint16* buf = (uint16*)alloca(len * sizeof(uint16)); + uint32 n = 0; + uint32 i = 0; + + while (i < len) { + uint32 cur = reader.readU1(); + if (cur & 0x80) { + uint32 y = reader.readU1(); + if (cur & 0x20) { + uint32 z = reader.readU1(); + cur = ((cur & 0x0F) << 12) + + ((y & 0x3F) << 6) + + (z & 0x3F); + i += 3; + } else { + cur = ((cur & 0x1F) << 6) + + (y & 0x3F); + i += 2; + } + } else { + ++i; + } + buf[n] = ((uint16)cur); + ++n; + } + + JnjvmClassLoader* loader = classDef->classLoader; + const UTF8* utf8 = loader->hashUTF8->lookupOrCreateReader(buf, n); + ctpRes[entry] = (UTF8*)utf8; + + PRINT_DEBUG(JNJVM_LOAD, 3, COLOR_NORMAL, "; [%5d] \t\t\"%s\"\n", entry, + utf8->printString()); + + } return (const UTF8*)ctpRes[entry]; } @@ -487,7 +494,8 @@ } JavaString* JavaConstantPool::resolveString(const UTF8* utf8, uint16 index) { - JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); + Jnjvm* vm = JavaThread::get()->isolate; + JavaString* str = vm->internalUTF8ToStr(utf8); return str; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Thu Oct 16 09:04:41 2008 @@ -1155,7 +1155,8 @@ push(val, false); #else const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); - JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); + JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8); + Value* val = module->getString(str, this); push(val, false); #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Thu Oct 16 09:04:41 2008 @@ -140,7 +140,7 @@ extern "C" void* stringLookup(UserClass* cl, uint32 index) { UserConstantPool* ctpInfo = cl->getConstantPool(); const UTF8* utf8 = ctpInfo->UTF8AtForString(index); - JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8); + JavaString* str = JavaThread::get()->isolate->internalUTF8ToStr(utf8); #ifdef ISOLATE_SHARING ctpInfo->ctpRes[index] = str; #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Thu Oct 16 09:04:41 2008 @@ -10,22 +10,17 @@ #include "JavaArray.h" #include "JavaClass.h" #include "JavaString.h" +#include "JavaThread.h" #include "JavaUpcalls.h" #include "Jnjvm.h" +#include "LockedMap.h" using namespace jnjvm; JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) { UserClass* cl = vm->upcalls->newString; - JavaString* res = (JavaString*)vm->allocator.Allocate(cl->getVirtualSize()); -#ifdef ISOLATE_SHARING - /// Do this for now, but we will have to change it to duplicate the UTF8. - /// UTF8 that dont have a class are shared UTF8. - if (!utf8->classOf) ((UTF8*)utf8)->classOf = vm->upcalls->ArrayOfChar; -#endif - ((void**)res)[0] = cl->getVirtualVT(); - res->classOf = cl; + JavaString* res = (JavaString*)cl->doNew(vm); // No need to call the Java function: both the Java function and // this function do the same thing. @@ -48,8 +43,14 @@ const UTF8* JavaString::strToUTF8(Jnjvm* vm) { const UTF8* utf8 = this->value; if (offset || (offset + count <= utf8->size)) { - return utf8->extract(vm->hashUTF8, offset, offset + count); + return utf8->extract(vm, offset, offset + count); } else { return utf8; } } + +void JavaString::stringDestructor(JavaString* str) { + Jnjvm* vm = JavaThread::get()->isolate; + assert(vm && "No vm when destroying a string"); + if (str->value) vm->hashStr->remove(str->value, str); +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.h?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.h Thu Oct 16 09:04:41 2008 @@ -29,6 +29,7 @@ sint32 offset; static JavaString* stringDup(const UTF8*& utf8, Jnjvm* vm); + static void stringDestructor(JavaString*); char* strToAsciiz(); const UTF8* strToUTF8(Jnjvm* vm); }; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Thu Oct 16 09:04:41 2008 @@ -87,11 +87,9 @@ if (currentClass) loader = currentClass->classLoader; else loader = vm->bootstrapLoader; - const UTF8* utf8 = loader->asciizConstructUTF8(asciiz); - sint32 len = utf8->size; + const UTF8* utf8 = vm->asciizToInternalUTF8(asciiz); - const UTF8* internal = utf8->javaToInternal(vm->hashUTF8, 0, len); - UserCommonClass* cl = loader->lookupClassFromUTF8(internal, true, true); + UserCommonClass* cl = loader->lookupClassFromUTF8(utf8, vm, true, true); cl->initialiseClass(vm); return (jclass)(cl->getClassDelegatee(vm)); @@ -329,13 +327,10 @@ Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); - const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); - const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); + const UTF8* name = vm->asciizToInternalUTF8(aname); + const UTF8* type = vm->asciizToInternalUTF8(atype); UserClass* methodCl = 0; - JavaMethod* meth = cl->lookupMethod( - name->javaToInternal(vm->hashUTF8, 0, name->size), - type->javaToInternal(vm->hashUTF8, 0, type->size), false, - true, methodCl); + JavaMethod* meth = cl->lookupMethod(name, type, false, true, methodCl); return (jmethodID)meth; @@ -1121,13 +1116,10 @@ Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); - const UTF8* name = cl->classLoader->asciizConstructUTF8(aname); - const UTF8* type = cl->classLoader->asciizConstructUTF8(atype); + const UTF8* name = vm->asciizToInternalUTF8(aname); + const UTF8* type = vm->asciizToInternalUTF8(atype); UserClass* methodCl = 0; - JavaMethod* meth = cl->lookupMethod( - name->javaToInternal(vm->hashUTF8, 0, name->size), - type->javaToInternal(vm->hashUTF8, 0, type->size), true, - true, methodCl); + JavaMethod* meth = cl->lookupMethod(name, type, true, true, methodCl); return (jmethodID)meth; Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Oct 16 09:04:41 2008 @@ -318,15 +318,30 @@ fmt); } +JavaString* Jnjvm::internalUTF8ToStr(const UTF8* utf8) { + JavaString* res = hashStr->lookup(utf8); + if (!res) { + uint32 size = utf8->size; + UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this); + uint16* buf = tmp->elements; + + for (uint32 i = 0; i < size; i++) { + buf[i] = utf8->elements[i]; + } + + const UTF8* newUTF8 = (const UTF8*)tmp; + res = hashStr->lookupOrCreate(newUTF8, this, JavaString::stringDup); + } + return res; +} + JavaString* Jnjvm::UTF8ToStr(const UTF8* utf8) { JavaString* res = hashStr->lookupOrCreate(utf8, this, JavaString::stringDup); return res; } JavaString* Jnjvm::asciizToStr(const char* asciiz) { - // asciizToStr is called by jnjvm code, so utf8s created - // by this method are stored in the bootstrap class loader - const UTF8* var = bootstrapLoader->asciizConstructUTF8(asciiz); + const UTF8* var = asciizToUTF8(asciiz); return UTF8ToStr(var); } @@ -357,14 +372,9 @@ hashStr->~StringMap(); allocator.Deallocate(hashStr); } - if (hashUTF8) { - hashUTF8->~UTF8Map(); - allocator.Deallocate(hashUTF8); - } } Jnjvm::Jnjvm() { - hashUTF8 = 0; hashStr = 0; } @@ -666,6 +676,8 @@ LOAD_CLASS(upcalls->newClass); LOAD_CLASS(upcalls->newConstructor); LOAD_CLASS(upcalls->newString); + uintptr_t* ptr = ((uintptr_t*)upcalls->newString->getVirtualVT()); + ptr[0] = (uintptr_t)JavaString::stringDestructor; LOAD_CLASS(upcalls->newMethod); LOAD_CLASS(upcalls->newField); LOAD_CLASS(upcalls->newStackTraceElement); @@ -847,5 +859,28 @@ upcalls->initialiseClasspath(bootstrapLoader); hashStr = new(allocator) StringMap(); - hashUTF8 = new(allocator) UTF8Map(allocator, upcalls->ArrayOfChar); +} + +const UTF8* Jnjvm::asciizToInternalUTF8(const char* asciiz) { + uint32 size = strlen(asciiz); + UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this); + uint16* buf = tmp->elements; + + for (uint32 i = 0; i < size; i++) { + if (asciiz[i] == '.') buf[i] = '/'; + else buf[i] = asciiz[i]; + } + return (const UTF8*)tmp; + +} + +const UTF8* Jnjvm::asciizToUTF8(const char* asciiz) { + uint32 size = strlen(asciiz); + UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this); + uint16* buf = tmp->elements; + + for (uint32 i = 0; i < size; i++) { + buf[i] = asciiz[i]; + } + return (const UTF8*)tmp; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Thu Oct 16 09:04:41 2008 @@ -258,11 +258,6 @@ /// StringMap* hashStr; - /// hashUTF8 - Tables of UTF8s defined by this class loader. Shared - /// by all class loaders in a no isolation configuration. - /// - UTF8Map* hashUTF8; - public: /// Exceptions - These are the only exceptions VMKit will make. /// @@ -298,6 +293,22 @@ /// JavaString* UTF8ToStr(const UTF8* utf8); + /// UTF8ToStr - Constructs a java/lang/String object from the given internal + /// UTF8, thus duplicating the UTF8. + /// + JavaString* internalUTF8ToStr(const UTF8* utf8); + + + + /// asciizToInternalUTF8 - Constructs an UTF8 out of the asciiz and changes + /// '.' into '/'. + /// + const UTF8* asciizToInternalUTF8(const char* asciiz); + + /// asciizToUTF8 - Constructs an UTF8 out of the asciiz. + /// + const UTF8* asciizToUTF8(const char* asciiz); + /// ~Jnjvm - Destroy the JVM. /// ~Jnjvm(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Oct 16 09:04:41 2008 @@ -138,7 +138,7 @@ UserCommonClass* cl = lookupClass(name); if (!cl) { - const UTF8* javaName = name->internalToJava(hashUTF8, 0, name->size); + const UTF8* javaName = name->internalToJava(isolate, 0, name->size); JavaString* str = isolate->UTF8ToStr(javaName); Classpath* upcalls = bootstrapLoader->upcalls; UserClass* forCtp = 0; @@ -177,6 +177,7 @@ } UserCommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* name, + Jnjvm* vm, bool doResolve, bool doThrow) { uint32 len = name->size; @@ -203,8 +204,7 @@ (name->elements[origLen - 1] != I_END_REF)) { doLoop = false; } else { - const UTF8* componentName = name->javaToInternal(hashUTF8, - start + 1, + const UTF8* componentName = name->javaToInternal(vm, start + 1, len - 2); if (loadName(componentName, doResolve, doThrow)) { ret = constructArray(name); @@ -241,19 +241,18 @@ } UserCommonClass* -JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, +JnjvmClassLoader::lookupClassFromJavaString(JavaString* str, Jnjvm* vm, bool doResolve, bool doThrow) { const UTF8* name = 0; if (str->value->elements[str->offset] != I_TAB) - name = str->value->checkedJavaToInternal(hashUTF8, str->offset, - str->count); + name = str->value->checkedJavaToInternal(vm, str->offset, str->count); else - name = str->value->javaToInternal(hashUTF8, str->offset, str->count); + name = str->value->javaToInternal(vm, str->offset, str->count); if (name) - return lookupClassFromUTF8(name, doResolve, doThrow); + return lookupClassFromUTF8(name, vm, doResolve, doThrow); return 0; } @@ -300,8 +299,9 @@ ClassMap::iterator I = classes->map.find(name); UserClass* res = 0; if (I == End) { - res = allocator_new(allocator, UserClass)(this, name, bytes); - classes->map.insert(std::make_pair(name, res)); + const UTF8* internalName = readerConstructUTF8(name->elements, name->size); + res = allocator_new(allocator, UserClass)(this, internalName, bytes); + classes->map.insert(std::make_pair(internalName, res)); } else { res = ((UserClass*)(I->second)); } @@ -319,8 +319,10 @@ ClassMap::iterator I = classes->map.find(name); UserClassArray* res = 0; if (I == End) { - res = allocator_new(allocator, UserClassArray)(this, name, baseClass); - classes->map.insert(std::make_pair(name, res)); + const UTF8* internalName = readerConstructUTF8(name->elements, name->size); + res = allocator_new(allocator, UserClassArray)(this, internalName, + baseClass); + classes->map.insert(std::make_pair(internalName, res)); } else { res = ((UserClassArray*)(I->second)); } @@ -425,6 +427,19 @@ delete TheModuleProvider; } +JavaString* JnjvmClassLoader::UTF8ToStr(const UTF8* val) { + JavaString* res = isolate->internalUTF8ToStr(val); + strings.push_back(res); + return res; +} + +JavaString* JnjvmBootstrapLoader::UTF8ToStr(const UTF8* val) { + Jnjvm* vm = JavaThread::get()->isolate; + JavaString* res = vm->internalUTF8ToStr(val); + strings.push_back(res); + return res; +} + void JnjvmBootstrapLoader::analyseClasspathEnv(const char* str) { if (str != 0) { unsigned int len = strlen(str); @@ -470,6 +485,9 @@ } } +// constructArrayName can allocate the UTF8 directly in the classloader +// memory because it is called by safe places, ie only valid names are +// created. const UTF8* JnjvmClassLoader::constructArrayName(uint32 steps, const UTF8* className) { uint32 len = className->size; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Thu Oct 16 09:04:41 2008 @@ -145,13 +145,13 @@ /// lookupClassFromUTF8 - Lookup a class from an UTF8 name and load it. /// - UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, bool doResolve, - bool doThrow); + UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, Jnjvm* vm, + bool doResolve, bool doThrow); /// lookupClassFromJavaString - Lookup a class from a Java String and load it. /// - UserCommonClass* lookupClassFromJavaString(JavaString* str, bool doResolve, - bool doThrow); + UserCommonClass* lookupClassFromJavaString(JavaString* str, Jnjvm* vm, + bool doResolve, bool doThrow); /// lookupClass - Finds the class of th given name in the class loader's /// table. @@ -217,6 +217,11 @@ #endif const UTF8* constructArrayName(uint32 steps, const UTF8* className); + + virtual JavaString* UTF8ToStr(const UTF8* utf8); + + /// Strings hashed by this classloader. + std::vector > strings; }; /// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which @@ -275,6 +280,9 @@ /// JnjvmBootstrapLoader(uint32 memLimit); JnjvmBootstrapLoader() {} + + virtual JavaString* UTF8ToStr(const UTF8* utf8); + /// upcalls - Upcall classes, fields and methods so that C++ code can call /// Java code. Modified: vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LockedMap.h Thu Oct 16 09:04:41 2008 @@ -75,6 +75,17 @@ map.erase(V); lock.unlock(); } + + inline void remove(Key V, Container C) { + lock.lock(); + iterator End = map.end(); + iterator I = map.find(V); + + if (I != End && I->second == C) + map.erase(I); + + lock.unlock(); + } inline Container lookup(Key V) { lock.lock(); Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Thu Oct 16 09:04:41 2008 @@ -135,6 +135,7 @@ javaLoader->MARK_AND_TRACE; traceClassMap(classes); isolate->MARK_AND_TRACE; + TRACE_VECTOR(JavaString*, gc_allocator, strings); } void JnjvmBootstrapLoader::TRACER { @@ -157,6 +158,7 @@ TRACE_DELEGATEE(upcalls->OfLong); TRACE_DELEGATEE(upcalls->OfDouble); #undef TRACE_DELEGATEE + TRACE_VECTOR(JavaString*, gc_allocator, strings); } #if defined(ISOLATE_SHARING) Modified: vmkit/trunk/lib/Mvm/Runtime/Object.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/Object.cpp?rev=57637&r1=57636&r2=57637&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/Runtime/Object.cpp (original) +++ vmkit/trunk/lib/Mvm/Runtime/Object.cpp Thu Oct 16 09:04:41 2008 @@ -118,10 +118,12 @@ void* mvm::BumpPtrAllocator::VMAllocate(size_t sz) { mvm::BumpPtrAllocator* allocator = mvm::Thread::get()->vmAllocator; + assert(allocator && "No allocator when vm allocating"); return allocator->Allocate(sz); } void* mvm::BumpPtrAllocator::ThreadAllocate(size_t sz) { mvm::BumpPtrAllocator* allocator = mvm::Thread::get()->threadAllocator; + assert(allocator && "No allocator when thread allocating"); return allocator->Allocate(sz); } From nicolas.geoffray at lip6.fr Thu Oct 16 07:40:27 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 16 Oct 2008 14:40:27 -0000 Subject: [vmkit-commits] [vmkit] r57638 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200810161440.m9GEeRFm007176@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 16 09:40:27 2008 New Revision: 57638 URL: http://llvm.org/viewvc/llvm-project?rev=57638&view=rev Log: 80-col violation fix. 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=57638&r1=57637&r2=57638&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Thu Oct 16 09:40:27 2008 @@ -399,7 +399,8 @@ StructType* structType = StructType::get(fields, false); virtualType = PointerType::getUnqual(structType); - const TargetData* targetData = mvm::MvmModule::executionEngine->getTargetData(); + ExecutionEngine* engine = mvm::MvmModule::executionEngine; + const TargetData* targetData = engine->getTargetData(); const StructLayout* sl = targetData->getStructLayout(structType); for (CommonClass::field_iterator i = classDef->virtualFields.begin(), @@ -445,7 +446,8 @@ StructType* structType = StructType::get(fields, false); staticType = PointerType::getUnqual(structType); - const TargetData* targetData = mvm::MvmModule::executionEngine->getTargetData(); + ExecutionEngine* engine = mvm::MvmModule::executionEngine; + const TargetData* targetData = engine->getTargetData(); const StructLayout* sl = targetData->getStructLayout(structType); for (CommonClass::field_iterator i = classDef->staticFields.begin(), @@ -503,7 +505,8 @@ const FunctionType* LLVMMethodInfo::getFunctionType() { if (!functionType) { - LLVMSignatureInfo* LSI = JnjvmModule::getSignatureInfo(methodDef->getSignature()); + Signdef* sign = methodDef->getSignature(); + LLVMSignatureInfo* LSI = JnjvmModule::getSignatureInfo(sign); assert(LSI); if (isStatic(methodDef->access)) { functionType = LSI->getStaticType(); @@ -665,7 +668,8 @@ Args.push_back(ctp); #endif - Value* val = CallInst::Create(func, Args.begin(), Args.end(), "", currentBlock); + Value* val = CallInst::Create(func, Args.begin(), Args.end(), "", + currentBlock); if (res->getFunctionType()->getReturnType() != Type::VoidTy) ReturnInst::Create(val, currentBlock); else @@ -680,9 +684,9 @@ Function* res = Function::Create(virt ? getVirtualBufType() : getStaticBufType(), - GlobalValue::ExternalLinkage, - signature->printString(), - signature->initialLoader->TheModule); + GlobalValue::ExternalLinkage, + signature->printString(), + signature->initialLoader->TheModule); BasicBlock* currentBlock = BasicBlock::Create("enter", res); Function::arg_iterator i = res->arg_begin(); @@ -715,7 +719,8 @@ Args.push_back(ctp); #endif - Value* val = CallInst::Create(func, Args.begin(), Args.end(), "", currentBlock); + Value* val = CallInst::Create(func, Args.begin(), Args.end(), "", + currentBlock); if (res->getFunctionType()->getReturnType() != Type::VoidTy) ReturnInst::Create(val, currentBlock); else @@ -950,7 +955,8 @@ } } -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, JavaObject* val) { +void +JnjvmModule::InitField(JavaField* field, JavaObject* obj, JavaObject* val) { ((JavaObject**)((uint64)obj + field->ptrOffset))[0] = val; } From nicolas.geoffray at lip6.fr Thu Oct 16 07:44:06 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 16 Oct 2008 14:44:06 -0000 Subject: [vmkit-commits] [vmkit] r57639 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Message-ID: <200810161444.m9GEi6PG007310@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 16 09:44:06 2008 New Revision: 57639 URL: http://llvm.org/viewvc/llvm-project?rev=57639&view=rev Log: Avoid useless copy. 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=57639&r1=57638&r2=57639&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Thu Oct 16 09:44:06 2008 @@ -296,7 +296,7 @@ #ifdef WITH_TRACER LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl); const Type* type = stat ? LCI->getStaticType() : LCI->getVirtualType(); - CommonClass::field_map fields = stat ? cl->staticFields : cl->virtualFields; + CommonClass::field_map& fields = stat ? cl->staticFields : cl->virtualFields; Function* func = Function::Create(JnjvmModule::MarkAndTraceType, GlobalValue::ExternalLinkage, From nicolas.geoffray at lip6.fr Thu Oct 16 13:03:18 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Thu, 16 Oct 2008 20:03:18 -0000 Subject: [vmkit-commits] [vmkit] r57648 - in /vmkit/trunk/lib: JnJVM/Classpath/ClasspathReflect.h JnJVM/Classpath/ClasspathVMClass.cpp JnJVM/Classpath/ClasspathVMStackWalker.cpp JnJVM/VMCore/JavaUpcalls.cpp JnJVM/VMCore/Jnjvm.cpp JnJVM/VMCore/JnjvmClassLoader.cpp JnJVM/VMCore/Makefile JnJVM/VMCore/NativeUtil.cpp Mvm/BoehmGC/MvmGC.h Mvm/GCMmap2/MvmGC.h Message-ID: <200810162003.m9GK3IAT020358@zion.cs.uiuc.edu> Author: geoffray Date: Thu Oct 16 15:03:17 2008 New Revision: 57648 URL: http://llvm.org/viewvc/llvm-project?rev=57648&view=rev Log: Change the tracer functions of reflection classes so that they trace the classloader instead of the class/field/method. Added: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/Makefile vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/Mvm/BoehmGC/MvmGC.h vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h Added: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h?rev=57648&view=auto ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h (added) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Thu Oct 16 15:03:17 2008 @@ -0,0 +1,97 @@ +//===------ ClasspathReflect.h - GNU classpath definitions of ----------------// +// java/lang/Class, java/lang/reflect/Field, java/lang/reflect/Method and ----// +// java/lang/reflect/Constructor as compiled by JnJVM. -----------------------// +// +// JnJVM +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef JNJVM_CLASSPATH_REFLECT_H +#define JNJVM_CLASSPATH_REFLECT_H + +#include "MvmGC.h" + +#include +#include + +namespace jnjvm { + +class JavaObjectClass : public JavaObject { +private: + JavaObject* signers; + JavaObject* pd; + UserCommonClass* vmdata; + JavaObject* constructor; + +public: + + UserCommonClass* getClass() { + return vmdata; + } + + static void STATIC_TRACER(JavaObjectClass) { + obj->JavaObject::CALL_TRACER; + obj->pd->MARK_AND_TRACE; + obj->signers->MARK_AND_TRACE; + obj->constructor->MARK_AND_TRACE; + obj->vmdata->classLoader->MARK_AND_TRACE; + } +}; + +class JavaObjectField : public JavaObject { +private: + uint8 flag; + JavaObject* declaringClass; + JavaObject* name; + JavaField* slot; + +public: + + static void STATIC_TRACER(JavaObjectField) { + obj->JavaObject::CALL_TRACER; + obj->name->MARK_AND_TRACE; + obj->declaringClass->MARK_AND_TRACE; + obj->slot->classDef->classLoader->MARK_AND_TRACE; + } + +}; + +class JavaObjectMethod : public JavaObject { +private: + uint8 flag; + JavaObject* declaringClass; + JavaObject* name; + JavaMethod* slot; + +public: + + static void STATIC_TRACER(JavaObjectMethod) { + obj->JavaObject::CALL_TRACER; + obj->name->MARK_AND_TRACE; + obj->declaringClass->MARK_AND_TRACE; + obj->slot->classDef->classLoader->MARK_AND_TRACE; + } + +}; + +class JavaObjectConstructor : public JavaObject { +private: + uint8 flag; + JavaObject* clazz; + JavaMethod* slot; + +public: + static void STATIC_TRACER(JavaObjectConstructor) { + obj->JavaObject::CALL_TRACER; + obj->clazz->MARK_AND_TRACE; + obj->slot->classDef->classLoader->MARK_AND_TRACE; + } + +}; + +} + +#endif Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Thu Oct 16 15:03:17 2008 @@ -11,6 +11,7 @@ #include "types.h" +#include "ClasspathReflect.h" #include "JavaAccess.h" #include "JavaArray.h" #include "JavaClass.h" @@ -35,10 +36,7 @@ #endif jobject klass) { - Jnjvm* vm = JavaThread::get()->isolate; - JavaField* field = vm->upcalls->vmdataClass; - UserCommonClass* cl = - (UserCommonClass*)field->getObjectField((JavaObject*)klass); + UserCommonClass* cl = ((JavaObjectClass*)klass)->getClass(); return cl->isArray(); @@ -158,8 +156,7 @@ #endif jobject Cl) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); const UTF8* iname = cl->getName(); const UTF8* res = iname->internalToJava(vm, 0, iname->size); @@ -173,9 +170,7 @@ jclass clazz, #endif jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); return cl->isPrimitive(); } @@ -199,8 +194,7 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); if (cl->isArray()) { UserCommonClass* bc = ((UserClassArray*)cl)->baseClass(); @@ -216,9 +210,7 @@ jclass clazz, #endif jclass Cl) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); return (jobject)cl->classLoader->getJavaClassLoader(); } @@ -228,11 +220,8 @@ jclass clazz, #endif jclass Cl1, jclass Cl2) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl1 = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl1); - UserCommonClass* cl2 = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl2); + UserCommonClass* cl1 = ((JavaObjectClass*)Cl1)->getClass(); + UserCommonClass* cl2 = ((JavaObjectClass*)Cl2)->getClass(); cl2->resolveClass(); return cl2->isAssignableFrom(cl1); @@ -246,8 +235,7 @@ #endif jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); if (cl->isInterface()) return 0; else { @@ -263,9 +251,7 @@ jclass clazz, #endif jclass Cl, jobject obj) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField((JavaObject*)Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); return ((JavaObject*)obj)->instanceOf(cl); } Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp Thu Oct 16 15:03:17 2008 @@ -14,6 +14,7 @@ #include "mvm/JIT.h" +#include "ClasspathReflect.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaJIT.h" @@ -138,10 +139,8 @@ jclass clazz, #endif jclass _Cl) { - Jnjvm* vm = JavaThread::get()->isolate; JavaObject* Cl = (JavaObject*)_Cl; - JavaField* field = vm->upcalls->vmdataClass; - UserCommonClass* cl = (UserCommonClass*)field->getObjectField(Cl); + UserCommonClass* cl = ((JavaObjectClass*)Cl)->getClass(); return (jobject)cl->classLoader->getJavaClassLoader(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Thu Oct 16 15:03:17 2008 @@ -11,6 +11,7 @@ #include "mvm/JIT.h" +#include "ClasspathReflect.h" #include "JavaAccess.h" #include "JavaClass.h" #include "JavaJIT.h" @@ -613,9 +614,6 @@ } extern "C" uint8 isArray(JavaObject* klass) { - Jnjvm* vm = JavaThread::get()->isolate; - UserCommonClass* cl = - (UserCommonClass*)((vm->upcalls->vmdataClass->getObjectField(klass))); - + UserCommonClass* cl = ((JavaObjectClass*)klass)->getClass(); return (uint8)cl->isArray(); } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Thu Oct 16 15:03:17 2008 @@ -20,6 +20,7 @@ #include "mvm/JIT.h" #include "mvm/Threads/Thread.h" +#include "ClasspathReflect.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaConstantPool.h" @@ -672,14 +673,35 @@ #define LOAD_CLASS(cl) \ cl->resolveClass(); \ cl->initialiseClass(this); - - LOAD_CLASS(upcalls->newClass); - LOAD_CLASS(upcalls->newConstructor); + + // 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[0] = (uintptr_t)JavaString::stringDestructor; + ptr[VT_DESTRUCTOR_OFFSET] = (uintptr_t)JavaString::stringDestructor; + + // 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()); + ptr[VT_TRACER_OFFSET] = (uintptr_t)JavaObjectClass::staticTracer; + + LOAD_CLASS(upcalls->newConstructor); + ptr = ((uintptr_t*)upcalls->newConstructor->getVirtualVT()); + ptr[VT_TRACER_OFFSET] = (uintptr_t)JavaObjectConstructor::staticTracer; + + LOAD_CLASS(upcalls->newMethod); + ptr = ((uintptr_t*)upcalls->newMethod->getVirtualVT()); + ptr[VT_TRACER_OFFSET] = (uintptr_t)JavaObjectMethod::staticTracer; + LOAD_CLASS(upcalls->newField); + ptr = ((uintptr_t*)upcalls->newField->getVirtualVT()); + ptr[VT_TRACER_OFFSET] = (uintptr_t)JavaObjectField::staticTracer; + LOAD_CLASS(upcalls->newStackTraceElement); LOAD_CLASS(upcalls->newVMThrowable); LOAD_CLASS(upcalls->boolClass); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Thu Oct 16 15:03:17 2008 @@ -15,6 +15,7 @@ #include "mvm/Allocator.h" +#include "ClasspathReflect.h" #include "JavaClass.h" #include "JavaConstantPool.h" #include "JavaThread.h" @@ -150,7 +151,7 @@ JavaObject* obj = (JavaObject*) upcalls->loadInClassLoader->invokeJavaObjectVirtual(isolate, forCtp, javaLoader, str); - cl = (UserCommonClass*)(upcalls->vmdataClass->getObjectField(obj)); + cl = (UserCommonClass*)((JavaObjectClass*)obj)->getClass(); } if (cl) assert(!cl->isArray()); Modified: vmkit/trunk/lib/JnJVM/VMCore/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Makefile?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Makefile (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Makefile Thu Oct 16 15:03:17 2008 @@ -14,7 +14,7 @@ include $(LEVEL)/Makefile.common -CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime $(CLASSPATH_FLAGS) +CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime -I$(PROJ_SRC_DIR)/../Classpath $(CLASSPATH_FLAGS) ifeq ($(ISOLATE_BUILD), 1) CXX.Flags += -I$(PROJ_SRC_DIR)/../Isolate Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Thu Oct 16 15:03:17 2008 @@ -11,6 +11,7 @@ #include #include +#include "ClasspathReflect.h" #include "JavaArray.h" #include "JavaClass.h" #include "JavaConstantPool.h" @@ -227,9 +228,7 @@ #undef PRE_LEN UserCommonClass* NativeUtil::resolvedImplClass(Jnjvm* vm, jclass clazz, bool doClinit) { - JavaObject *Cl = (JavaObject*)clazz; - UserCommonClass* cl = - (UserCommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl); + UserCommonClass* cl = ((JavaObjectClass*)clazz)->getClass(); cl->resolveClass(); if (doClinit) cl->initialiseClass(vm); return cl; Modified: vmkit/trunk/lib/Mvm/BoehmGC/MvmGC.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/BoehmGC/MvmGC.h?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/BoehmGC/MvmGC.h (original) +++ vmkit/trunk/lib/Mvm/BoehmGC/MvmGC.h Thu Oct 16 15:03:17 2008 @@ -17,6 +17,7 @@ //#include "gc/gc_local_alloc.h" #include "gc/gc.h" +#define STATIC_TRACER(type) staticTracer(type* obj) #define TRACER tracer() #define PARENT_TRACER tracer() #define MARK_AND_TRACE markAndTrace() Modified: vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h?rev=57648&r1=57647&r2=57648&view=diff ============================================================================== --- vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h (original) +++ vmkit/trunk/lib/Mvm/GCMmap2/MvmGC.h Thu Oct 16 15:03:17 2008 @@ -21,10 +21,12 @@ #ifdef MULTIPLE_GC +#define STATIC_TRACER(type) staticTracer(type* obj, void* GC) #define TRACER tracer(void* GC) #define CALL_TRACER tracer(GC) #define MARK_AND_TRACE markAndTrace((Collector*)GC) #else +#define STATIC_TRACER(type) staticTracer(type* obj) #define TRACER tracer() #define CALL_TRACER tracer() #define MARK_AND_TRACE markAndTrace() From nicolas.geoffray at lip6.fr Fri Oct 17 08:10:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 17 Oct 2008 15:10:26 -0000 Subject: [vmkit-commits] [vmkit] r57678 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JavaJIT.h JavaJITOpcodes.cpp Message-ID: <200810171510.m9HFAQOR008523@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 17 10:10:24 2008 New Revision: 57678 URL: http://llvm.org/viewvc/llvm-project?rev=57678&view=rev Log: Fix exception handling bug when a Java handler may be used in a normal control flow. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57678&r1=57677&r2=57678&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Fri Oct 17 10:10:24 2008 @@ -894,9 +894,8 @@ unsigned JavaJIT::readExceptionTable(Reader& reader) { BasicBlock* temp = currentBlock; - uint16 nbe = reader.readU2(); - std::vector exceptions; - unsigned sync = isSynchro(compilingMethod->access) ? 1 : 0; + sint16 nbe = reader.readU2(); + sint16 sync = isSynchro(compilingMethod->access) ? 1 : 0; nbe += sync; if (nbe) { supplLocal = new AllocaInst(module->JavaObjectType, "exceptionVar", @@ -958,8 +957,10 @@ // 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 = new Exception(); + Exception* ex = &exceptions[i]; ex->startpc = reader.readU2(); ex->endpc = reader.readU2(); ex->handlerpc = reader.readU2(); @@ -1002,24 +1003,23 @@ if (!(opcodeInfos[ex->handlerpc].newBlock)) { opcodeInfos[ex->handlerpc].newBlock = - createBasicBlock("handlerException"); + createBasicBlock("javaHandler"); } - ex->handler = opcodeInfos[ex->handlerpc].newBlock; + ex->javaHandler = opcodeInfos[ex->handlerpc].newBlock; + ex->nativeHandler = createBasicBlock("nativeHandler"); opcodeInfos[ex->handlerpc].reqSuppl = true; - exceptions.push_back(ex); } module->executionEngine->lock.acquire(); bool first = true; - for (std::vector::iterator i = exceptions.begin(), - e = exceptions.end(); i!= e; ++i) { + for (sint16 i = 0; i < nbe - sync; ++i) { + Exception* cur = &exceptions[i]; - Exception* cur = *i; Exception* next = 0; - if (i + 1 != e) { - next = *(i + 1); + if (i + 1 != nbe - sync) { + next = &exceptions[i + 1]; } if (first) { @@ -1038,17 +1038,15 @@ } - for (std::vector::iterator i = exceptions.begin(), - e = exceptions.end(); i!= e; ++i) { - - Exception* cur = *i; + for (sint16 i = 0; i < nbe - sync; ++i) { + Exception* cur = &exceptions[i]; Exception* next = 0; BasicBlock* bbNext = 0; PHINode* nodeNext = 0; currentExceptionBlock = opcodeInfos[cur->handlerpc].exceptionBlock; - if (i + 1 != e) { - next = *(i + 1); + if (i + 1 != nbe - sync) { + next = &exceptions[i + 1]; if (!(cur->startpc >= next->startpc && cur->endpc <= next->endpc)) { bbNext = realEndExceptionBlock; } else { @@ -1091,37 +1089,40 @@ #endif Value* cmp = llvm::CallInst::Create(module->CompareExceptionFunction, cl, "", currentBlock); - llvm::BranchInst::Create(cur->handler, bbNext, cmp, currentBlock); + llvm::BranchInst::Create(cur->nativeHandler, bbNext, cmp, currentBlock); if (nodeNext) nodeNext->addIncoming(cur->exceptionPHI, currentBlock); - if (cur->handler->empty()) { - cur->handlerPHI = llvm::PHINode::Create(module->ptrType, "", - cur->handler); - cur->handlerPHI->addIncoming(cur->exceptionPHI, currentBlock); - Value* exc = llvm::CallInst::Create(module->GetJavaExceptionFunction, - "", cur->handler); - llvm::CallInst::Create(module->ClearExceptionFunction, "", - cur->handler); - llvm::CallInst::Create(module->exceptionBeginCatch, cur->handlerPHI, - "tmp8", cur->handler); - std::vector void_28_params; - llvm::CallInst::Create(module->exceptionEndCatch, - void_28_params.begin(), void_28_params.end(), "", - cur->handler); - new StoreInst(exc, supplLocal, false, cur->handler); + cur->handlerPHI = llvm::PHINode::Create(module->ptrType, "", + cur->nativeHandler); + cur->handlerPHI->addIncoming(cur->exceptionPHI, currentBlock); + Value* exc = llvm::CallInst::Create(module->GetJavaExceptionFunction, + "", cur->nativeHandler); + llvm::CallInst::Create(module->ClearExceptionFunction, "", + cur->nativeHandler); + llvm::CallInst::Create(module->exceptionBeginCatch, cur->handlerPHI, + "tmp8", cur->nativeHandler); + std::vector void_28_params; + llvm::CallInst::Create(module->exceptionEndCatch, + void_28_params.begin(), void_28_params.end(), "", + cur->nativeHandler); + BranchInst::Create(cur->javaHandler, cur->nativeHandler); + + if (cur->javaHandler->empty()) { + PHINode* node = llvm::PHINode::Create(JnjvmModule::JavaObjectType, "", + cur->javaHandler); + node->addIncoming(exc, cur->nativeHandler); + + new StoreInst(node, supplLocal, false, cur->javaHandler); } else { - Instruction* insn = cur->handler->begin(); - ((PHINode*)insn)->addIncoming(cur->exceptionPHI, currentBlock); + Instruction* insn = cur->javaHandler->begin(); + PHINode* node = dyn_cast(insn); + assert(node && "malformed exceptions"); + node->addIncoming(exc, cur->nativeHandler); } } - for (std::vector::iterator i = exceptions.begin(), - e = exceptions.end(); i!= e; ++i) { - delete *i; - } - currentBlock = temp; return nbe; @@ -1313,6 +1314,7 @@ } else { node = llvm::PHINode::Create(cur->getType(), "", dest); } + assert(node->getType() == cur->getType() && "wrong 1"); node->addIncoming(cur, insert); } } else { @@ -1333,7 +1335,7 @@ } else if (type == Type::Int8Ty || type == Type::Int16Ty) { cur = new SExtInst(cur, Type::Int32Ty, "", jit->currentBlock); } - + assert(ins->getType() == cur->getType() && "wrong 2"); ((PHINode*)ins)->addIncoming(cur, insert); ++stackit; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=57678&r1=57677&r2=57678&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Fri Oct 17 10:10:24 2008 @@ -43,7 +43,8 @@ UserClass* catchClass; llvm::BasicBlock* test; llvm::BasicBlock* realTest; - llvm::BasicBlock* handler; + llvm::BasicBlock* javaHandler; + llvm::BasicBlock* nativeHandler; llvm::PHINode* exceptionPHI; llvm::PHINode* handlerPHI; }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=57678&r1=57677&r2=57678&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Fri Oct 17 10:10:24 2008 @@ -156,8 +156,10 @@ args.end(), "", currentBlock); } #endif - - if (opinfo->reqSuppl) { + + // If we're an exception handler and no one has pushed our exception + // variable on stack, then do it now. + if (opinfo->reqSuppl && stack.size() != 1) { push(new LoadInst(supplLocal, "", currentBlock), false); } @@ -1655,7 +1657,6 @@ ConstantInt::get(Type::Int64Ty, uint64_t (jsrIndex++)), module->JavaObjectType); - new StoreInst(expr, supplLocal, false, currentBlock); BranchInst::Create(opcodeInfos[tmp + readS2(bytecodes, i)].newBlock, currentBlock); From nicolas.geoffray at lip6.fr Fri Oct 17 08:11:15 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 17 Oct 2008 15:11:15 -0000 Subject: [vmkit-commits] [vmkit] r57679 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.h JnjvmClassLoader.cpp VirtualTables.cpp Message-ID: <200810171511.m9HFBGlA008566@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 17 10:11:15 2008 New Revision: 57679 URL: http://llvm.org/viewvc/llvm-project?rev=57679&view=rev Log: Make classes permanentObject instead of GC objects. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=57679&r1=57678&r2=57679&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Oct 17 10:11:15 2008 @@ -122,7 +122,7 @@ /// object that stays in memory has a reference to the class. Same for /// super or interfaces. /// -class CommonClass : public mvm::Object { +class CommonClass : public mvm::PermanentObject { #ifdef ISOLATE_SHARING friend class UserCommonClass; #endif @@ -422,6 +422,13 @@ /// tracer - The tracer of this GC-allocated class. /// virtual void TRACER; + + /// printString - Prints the class. + char *printString() const { + mvm::PrintBuffer *buf = mvm::PrintBuffer::alloc(); + print(buf); + return buf->contents()->cString(); + } /// inheritName - Does this class in its class hierarchy inherits /// the given name? Equality is on the name. This function does not take Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=57679&r1=57678&r2=57679&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Oct 17 10:11:15 2008 @@ -301,7 +301,7 @@ UserClass* res = 0; if (I == End) { const UTF8* internalName = readerConstructUTF8(name->elements, name->size); - res = allocator_new(allocator, UserClass)(this, internalName, bytes); + res = new(allocator) UserClass(this, internalName, bytes); classes->map.insert(std::make_pair(internalName, res)); } else { res = ((UserClass*)(I->second)); @@ -321,8 +321,7 @@ UserClassArray* res = 0; if (I == End) { const UTF8* internalName = readerConstructUTF8(name->elements, name->size); - res = allocator_new(allocator, UserClassArray)(this, internalName, - baseClass); + res = new(allocator) UserClassArray(this, internalName, baseClass); classes->map.insert(std::make_pair(internalName, res)); } else { res = ((UserClassArray*)(I->second)); Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=57679&r1=57678&r2=57679&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Fri Oct 17 10:11:15 2008 @@ -54,7 +54,7 @@ #undef INIT void ArrayObject::TRACER { - classOf->MARK_AND_TRACE; + classOf->classLoader->MARK_AND_TRACE; for (sint32 i = 0; i < size; i++) { if (elements[i]) elements[i]->MARK_AND_TRACE; } @@ -70,8 +70,11 @@ (*i)->MARK_AND_TRACE; }} void CommonClass::TRACER { - super->MARK_AND_TRACE; - TRACE_VECTOR(Class*, gc_allocator, interfaces); + if (super) super->classLoader->MARK_AND_TRACE; + for (std::vector >::iterator i = interfaces.begin(), + e = interfaces.end(); i!= e; ++i) { + (*i)->classLoader->MARK_AND_TRACE; + } classLoader->MARK_AND_TRACE; #if !defined(ISOLATE) delegatee->MARK_AND_TRACE; @@ -80,8 +83,6 @@ void Class::TRACER { CommonClass::CALL_TRACER; - TRACE_VECTOR(Class*, gc_allocator, innerClasses); - outerClass->MARK_AND_TRACE; bytes->MARK_AND_TRACE; #if !defined(ISOLATE) _staticInstance->MARK_AND_TRACE; @@ -93,7 +94,7 @@ } void JavaObject::TRACER { - classOf->MARK_AND_TRACE; + classOf->classLoader->MARK_AND_TRACE; LockObj* l = lockObj(); if (l) l->MARK_AND_TRACE; } @@ -103,7 +104,7 @@ #else extern "C" void JavaObjectTracer(JavaObject* obj) { #endif - obj->classOf->MARK_AND_TRACE; + obj->classOf->classLoader->MARK_AND_TRACE; LockObj* l = obj->lockObj(); if (l) l->MARK_AND_TRACE; } @@ -127,7 +128,7 @@ static void traceClassMap(ClassMap* classes) { for (ClassMap::iterator i = classes->map.begin(), e = classes->map.end(); i!= e; ++i) { - i->second->MARK_AND_TRACE; + i->second->CALL_TRACER; } } From nicolas.geoffray at lip6.fr Fri Oct 17 08:12:45 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 17 Oct 2008 15:12:45 -0000 Subject: [vmkit-commits] [vmkit] r57680 - /vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Message-ID: <200810171512.m9HFCjlT008625@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 17 10:12:45 2008 New Revision: 57680 URL: http://llvm.org/viewvc/llvm-project?rev=57680&view=rev Log: Fakely implement runFinalizersOnExit. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=57680&r1=57679&r2=57680&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Fri Oct 17 10:12:45 2008 @@ -118,6 +118,16 @@ return; } +JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizersOnExit( +#ifdef NATIVE_JNI +JNIEnv *env, +jclass clazz, +#endif +uint8 value +) { + return; +} + JNIEXPORT void JNICALL Java_java_lang_VMRuntime_exit( #ifdef NATIVE_JNI JNIEnv *env, From nicolas.geoffray at lip6.fr Fri Oct 17 08:58:25 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 17 Oct 2008 15:58:25 -0000 Subject: [vmkit-commits] [vmkit] r57682 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaString.cpp Jnjvm.cpp Jnjvm.h Message-ID: <200810171558.m9HFwQ7c010255@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 17 10:58:25 2008 New Revision: 57682 URL: http://llvm.org/viewvc/llvm-project?rev=57682&view=rev Log: Inline the string map in the Jnjvm object. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp?rev=57682&r1=57681&r2=57682&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaString.cpp Fri Oct 17 10:58:25 2008 @@ -52,5 +52,5 @@ void JavaString::stringDestructor(JavaString* str) { Jnjvm* vm = JavaThread::get()->isolate; assert(vm && "No vm when destroying a string"); - if (str->value) vm->hashStr->remove(str->value, str); + if (str->value) vm->hashStr.remove(str->value, str); } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=57682&r1=57681&r2=57682&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Fri Oct 17 10:58:25 2008 @@ -320,7 +320,7 @@ } JavaString* Jnjvm::internalUTF8ToStr(const UTF8* utf8) { - JavaString* res = hashStr->lookup(utf8); + JavaString* res = hashStr.lookup(utf8); if (!res) { uint32 size = utf8->size; UTF8* tmp = (UTF8*)upcalls->ArrayOfChar->doNew(size, this); @@ -331,13 +331,13 @@ } const UTF8* newUTF8 = (const UTF8*)tmp; - res = hashStr->lookupOrCreate(newUTF8, this, JavaString::stringDup); + res = hashStr.lookupOrCreate(newUTF8, this, JavaString::stringDup); } return res; } JavaString* Jnjvm::UTF8ToStr(const UTF8* utf8) { - JavaString* res = hashStr->lookupOrCreate(utf8, this, JavaString::stringDup); + JavaString* res = hashStr.lookupOrCreate(utf8, this, JavaString::stringDup); return res; } @@ -368,17 +368,6 @@ return delegatee; } -Jnjvm::~Jnjvm() { - if (hashStr) { - hashStr->~StringMap(); - allocator.Deallocate(hashStr); - } -} - -Jnjvm::Jnjvm() { - hashStr = 0; -} - #define PATH_MANIFEST "META-INF/MANIFEST.MF" #define MAIN_CLASS "Main-Class: " #define PREMAIN_CLASS "Premain-Class: " @@ -880,7 +869,6 @@ upcalls->initialiseClasspath(bootstrapLoader); - hashStr = new(allocator) StringMap(); } const UTF8* Jnjvm::asciizToInternalUTF8(const char* asciiz) { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=57682&r1=57681&r2=57682&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Fri Oct 17 10:58:25 2008 @@ -23,6 +23,7 @@ #include "JavaTypes.h" #include "JnjvmConfig.h" +#include "LockedMap.h" namespace jnjvm { @@ -36,7 +37,6 @@ class JavaThread; class JnjvmBootstrapLoader; class JnjvmClassLoader; -class StringMap; class UserClass; class UserClassArray; class UserClassPrimitive; @@ -256,7 +256,7 @@ /// hashStr - Hash map of java/lang/String objects allocated by this JVM. /// - StringMap* hashStr; + StringMap hashStr; public: /// Exceptions - These are the only exceptions VMKit will make. @@ -311,11 +311,11 @@ /// ~Jnjvm - Destroy the JVM. /// - ~Jnjvm(); + ~Jnjvm() {} /// Jnjvm - Allocate a default JVM, for VT initialization. /// - Jnjvm(); + Jnjvm() {} /// addProperty - Adds a new property in the postProperties map. /// From nicolas.geoffray at lip6.fr Mon Oct 20 01:17:30 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 08:17:30 -0000 Subject: [vmkit-commits] [vmkit] r57819 - /vmkit/trunk/README.txt Message-ID: <200810200817.m9K8HUu8003894@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 03:17:29 2008 New Revision: 57819 URL: http://llvm.org/viewvc/llvm-project?rev=57819&view=rev Log: Update info for 0.24 version. Modified: vmkit/trunk/README.txt Modified: vmkit/trunk/README.txt URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/README.txt?rev=57819&r1=57818&r2=57819&view=diff ============================================================================== --- vmkit/trunk/README.txt (original) +++ vmkit/trunk/README.txt Mon Oct 20 03:17:29 2008 @@ -7,25 +7,28 @@ 2) JnJVM: a Java Virtual Machine implemented with MVM and LLVM 3) N3: a CLI implementation with MVM and LLVM -JnJVM and N3 work on Linux/x86 (note that you may have to disable SSE on some -architecture), and mostly work on Linux/PPC (there are some errors with -floating points). Portage to Darwin needs to investigate why exceptions -do not work. +JnJVM and N3 work on Linux/x86 and Darwin/x86 (note that you may have to +disable SSE on some architecture), and mostly work on Linux/PPC (there are +some errors with floating points). JnJVM and N3 use GCC's unwinding library (libgcc_s.so). These are the options you should pass to the ./configure script --with-llvmsrc: the source directory of LLVM --with-llvmobj: the object directory of LLVM ---with-gnu-classpath-local-prefix: the local build of GNU classpath +--with-gnu-classpath-libs: GNU classpath libraries +--with-gnu-classpath-glibj: GNU classpath glibj.zip --with-pnet-local-prefix: the local build of PNET +--with-pnetlib: PNET's mscorlib.dll -There's also: +There's also [experimental]: --with-gc: user either boehm or single-mmap +--with-mono: Mono's mscorlib.dll -Running make on the root tree will produce two "tools": -1) Debug|Release/bin/jnjvm: running the JnJVM like any other JVM -2) Debug|Release/bin/n3: running N3 like CLR +Running make on the root tree will produce three "tools": +1) Debug|Release/bin/jnjvm: running the JnJVM like any other JVM. +2) Debug|Release/bin/n3-pnetlib: running N3 like CLR. +2) Debug|Release/bin/vmkit: shell-like vm launcher. JnJVM and N3 have their own README notes. @@ -56,5 +59,4 @@ //===---------------------------------------------------------------------===// - A compiler/system dependency interface -- Port to Darwin From nicolas.geoffray at lip6.fr Mon Oct 20 01:58:02 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 08:58:02 -0000 Subject: [vmkit-commits] [vmkit] r57821 - in /vmkit/trunk: autoconf/configure.ac configure Message-ID: <200810200858.m9K8w2D5005344@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 03:58:02 2008 New Revision: 57821 URL: http://llvm.org/viewvc/llvm-project?rev=57821&view=rev Log: Fix path of Object.cpp. Modified: vmkit/trunk/autoconf/configure.ac vmkit/trunk/configure Modified: vmkit/trunk/autoconf/configure.ac URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/autoconf/configure.ac?rev=57821&r1=57820&r2=57821&view=diff ============================================================================== --- vmkit/trunk/autoconf/configure.ac (original) +++ vmkit/trunk/autoconf/configure.ac Mon Oct 20 03:58:02 2008 @@ -44,7 +44,7 @@ dnl Verify that the source directory is valid. This makes sure that we are dnl configuring VMKit and not some other package (it validates --srcdir argument) -AC_CONFIG_SRCDIR([lib/Mvm/Object.cpp]) +AC_CONFIG_SRCDIR([lib/Mvm/Runtime/Object.cpp]) dnl Quit if the source directory has already been configured. Modified: vmkit/trunk/configure URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/configure?rev=57821&r1=57820&r2=57821&view=diff ============================================================================== --- vmkit/trunk/configure (original) +++ vmkit/trunk/configure Mon Oct 20 03:58:02 2008 @@ -580,7 +580,7 @@ PACKAGE_STRING='vmkit 0.24' PACKAGE_BUGREPORT='nicolas.geoffray at lip6.fr' -ac_unique_file="lib/Mvm/Object.cpp" +ac_unique_file="lib/Mvm/Runtime/Object.cpp" # Factoring default headers for most tests. ac_includes_default="\ #include From nicolas.geoffray at lip6.fr Mon Oct 20 02:01:06 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 09:01:06 -0000 Subject: [vmkit-commits] [vmkit] r57822 - /vmkit/branches/release_024/ Message-ID: <200810200901.m9K916Tr005471@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 04:01:05 2008 New Revision: 57822 URL: http://llvm.org/viewvc/llvm-project?rev=57822&view=rev Log: Create release_024 branch. Added: vmkit/branches/release_024/ - copied from r57821, vmkit/trunk/ From nicolas.geoffray at lip6.fr Mon Oct 20 02:29:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 09:29:29 -0000 Subject: [vmkit-commits] [vmkit] r57823 - /vmkit/branches/release_024/lib/JnJVM/VMCore/JavaClass.h Message-ID: <200810200929.m9K9TTJf007037@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 04:29:29 2008 New Revision: 57823 URL: http://llvm.org/viewvc/llvm-project?rev=57823&view=rev Log: Fix warning on Darwin. Modified: vmkit/branches/release_024/lib/JnJVM/VMCore/JavaClass.h Modified: vmkit/branches/release_024/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/release_024/lib/JnJVM/VMCore/JavaClass.h?rev=57823&r1=57822&r2=57823&view=diff ============================================================================== --- vmkit/branches/release_024/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/branches/release_024/lib/JnJVM/VMCore/JavaClass.h Mon Oct 20 04:29:29 2008 @@ -500,7 +500,7 @@ /// ~CommonClass - Free memory used by this class, and remove it from /// metadata. /// - ~CommonClass(); + virtual ~CommonClass(); /// CommonClass - Default constructor. /// @@ -623,7 +623,7 @@ /// virtual void TRACER; - ~Class(); + virtual ~Class(); Class(); /// lookupAttribut - Look up a JVM attribut of this class. From nicolas.geoffray at lip6.fr Mon Oct 20 02:36:19 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 09:36:19 -0000 Subject: [vmkit-commits] [vmkit] r57824 - /vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Message-ID: <200810200936.m9K9aJT6007260@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 04:36:18 2008 New Revision: 57824 URL: http://llvm.org/viewvc/llvm-project?rev=57824&view=rev Log: Import r57823 in mainline. 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=57824&r1=57823&r2=57824&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Mon Oct 20 04:36:18 2008 @@ -500,7 +500,7 @@ /// ~CommonClass - Free memory used by this class, and remove it from /// metadata. /// - ~CommonClass(); + virtual ~CommonClass(); /// CommonClass - Default constructor. /// @@ -623,7 +623,7 @@ /// virtual void TRACER; - ~Class(); + virtual ~Class(); Class(); /// lookupAttribut - Look up a JVM attribut of this class. From nicolas.geoffray at lip6.fr Mon Oct 20 02:41:02 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 09:41:02 -0000 Subject: [vmkit-commits] [vmkit] r57825 - /vmkit/tags/ Message-ID: <200810200941.m9K9f20x007432@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 04:41:02 2008 New Revision: 57825 URL: http://llvm.org/viewvc/llvm-project?rev=57825&view=rev Log: Add a tags directory. Added: vmkit/tags/ From nicolas.geoffray at lip6.fr Mon Oct 20 02:41:40 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 09:41:40 -0000 Subject: [vmkit-commits] [vmkit] r57826 - /vmkit/tags/release_024/ Message-ID: <200810200941.m9K9feoo007476@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 04:41:39 2008 New Revision: 57826 URL: http://llvm.org/viewvc/llvm-project?rev=57826&view=rev Log: Creating the release_024 tag. Added: vmkit/tags/release_024/ - copied from r57825, vmkit/branches/release_024/ From nicolas.geoffray at lip6.fr Mon Oct 20 09:11:21 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 20 Oct 2008 16:11:21 -0000 Subject: [vmkit-commits] [vmkit] r57835 - in /vmkit/trunk/lib: JnJVM/VMCore/JavaJIT.cpp JnJVM/VMCore/JavaJITOpcodes.cpp N3/VMCore/CLIJit.cpp N3/VMCore/Opcodes.cpp Message-ID: <200810201611.m9KGBLa1022776@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 20 11:11:20 2008 New Revision: 57835 URL: http://llvm.org/viewvc/llvm-project?rev=57835&view=rev Log: Move to the new LLVM API BinaryOperator::create -> BinaryOperator::Create. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp vmkit/trunk/lib/N3/VMCore/CLIJit.cpp vmkit/trunk/lib/N3/VMCore/Opcodes.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=57835&r1=57834&r2=57835&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Mon Oct 20 11:11:20 2008 @@ -94,7 +94,7 @@ Type::Int32Ty, args[0], true); indexes2.push_back(val); #ifdef ISOLATE_SHARING - Value* mul = BinaryOperator::createMul(val, module->constantMinusOne, + Value* mul = BinaryOperator::CreateMul(val, module->constantMinusOne, "", currentBlock); indexesCtp.push_back(mul); #endif @@ -309,7 +309,7 @@ // The compare and swap did not pass, look if it's a thin lock Value* thinMask = ConstantInt::get(Type::Int32Ty, 0x80000000); - Value* isThin = BinaryOperator::createAnd(atomic, thinMask, "", + Value* isThin = BinaryOperator::CreateAnd(atomic, thinMask, "", currentBlock); cmp = new ICmpInst(ICmpInst::ICMP_EQ, isThin, module->constantZero, "", currentBlock); @@ -320,7 +320,7 @@ currentBlock = ThinLockBB; Value* idMask = ConstantInt::get(Type::Int32Ty, 0x7FFFFF00); Value* cptMask = ConstantInt::get(Type::Int32Ty, 0xFF); - Value* IdInLock = BinaryOperator::createAnd(atomic, idMask, "", currentBlock); + Value* IdInLock = BinaryOperator::CreateAnd(atomic, idMask, "", currentBlock); Value* owner = new ICmpInst(ICmpInst::ICMP_EQ, threadId, IdInLock, "", currentBlock); @@ -330,7 +330,7 @@ currentBlock = OwnerBB; // OK, we are the owner, now check if the counter will overflow. - Value* count = BinaryOperator::createAnd(atomic, cptMask, "", currentBlock); + Value* count = BinaryOperator::CreateAnd(atomic, cptMask, "", currentBlock); cmp = new ICmpInst(ICmpInst::ICMP_ULT, count, cptMask, "", currentBlock); BasicBlock* IncCounterBB = createBasicBlock("Increment counter"); @@ -340,7 +340,7 @@ currentBlock = IncCounterBB; // The counter will not overflow, increment it. - Value* Add = BinaryOperator::createAdd(module->constantOne, atomic, "", + Value* Add = BinaryOperator::CreateAdd(module->constantOne, atomic, "", currentBlock); new StoreInst(Add, lockPtr, false, currentBlock); BranchInst::Create(OK, currentBlock); @@ -392,7 +392,7 @@ currentBlock = NotLockedOnceBB; // Look if the lock is thin. Value* thinMask = ConstantInt::get(Type::Int32Ty, 0x80000000); - Value* isThin = BinaryOperator::createAnd(lock, thinMask, "", + Value* isThin = BinaryOperator::CreateAnd(lock, thinMask, "", currentBlock); cmp = new ICmpInst(ICmpInst::ICMP_EQ, isThin, module->constantZero, "", currentBlock); @@ -402,7 +402,7 @@ currentBlock = ThinLockBB; // Decrement the counter. - Value* Sub = BinaryOperator::createSub(lock, module->constantOne, "", + Value* Sub = BinaryOperator::CreateSub(lock, module->constantOne, "", currentBlock); new StoreInst(Sub, lockPtr, false, currentBlock); BranchInst::Create(EndUnlock, currentBlock); @@ -1400,7 +1400,7 @@ Constant* const_int32_9 = module->constantZero; ConstantInt* const_int32_10 = module->constantMinusOne; BinaryOperator* int32_tmpneg = - BinaryOperator::create(Instruction::Sub, const_int32_9, args[0], + BinaryOperator::Create(Instruction::Sub, const_int32_9, args[0], "tmpneg", currentBlock); ICmpInst* int1_abscond = new ICmpInst(ICmpInst::ICMP_SGT, args[0], const_int32_10, "abscond", @@ -1412,7 +1412,7 @@ ConstantInt* const_int64_10 = module->constantLongMinusOne; BinaryOperator* int64_tmpneg = - BinaryOperator::create(Instruction::Sub, const_int64_9, args[0], + BinaryOperator::Create(Instruction::Sub, const_int64_9, args[0], "tmpneg", currentBlock); ICmpInst* int1_abscond = new ICmpInst(ICmpInst::ICMP_SGT, args[0], Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=57835&r1=57834&r2=57835&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Mon Oct 20 11:11:20 2008 @@ -775,7 +775,7 @@ case IADD : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createAdd(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAdd(val1, val2, "", currentBlock), false); break; } @@ -785,7 +785,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createAdd(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAdd(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -794,7 +794,7 @@ case FADD : { Value* val2 = pop(); Value* val1 = pop(); - push(BinaryOperator::createAdd(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAdd(val1, val2, "", currentBlock), false); break; } @@ -804,7 +804,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createAdd(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAdd(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -813,7 +813,7 @@ case ISUB : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createSub(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSub(val1, val2, "", currentBlock), false); break; } @@ -822,7 +822,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createSub(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSub(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -831,7 +831,7 @@ case FSUB : { Value* val2 = pop(); Value* val1 = pop(); - push(BinaryOperator::createSub(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSub(val1, val2, "", currentBlock), false); break; } @@ -841,7 +841,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createSub(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSub(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -850,7 +850,7 @@ case IMUL : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createMul(val1, val2, "", currentBlock), + push(BinaryOperator::CreateMul(val1, val2, "", currentBlock), false); break; } @@ -860,7 +860,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createMul(val1, val2, "", currentBlock), + push(BinaryOperator::CreateMul(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -869,7 +869,7 @@ case FMUL : { Value* val2 = pop(); Value* val1 = pop(); - push(BinaryOperator::createMul(val1, val2, "", currentBlock), + push(BinaryOperator::CreateMul(val1, val2, "", currentBlock), false); break; } @@ -879,7 +879,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createMul(val1, val2, "", currentBlock), + push(BinaryOperator::CreateMul(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -888,7 +888,7 @@ case IDIV : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createSDiv(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSDiv(val1, val2, "", currentBlock), false); break; } @@ -898,7 +898,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createSDiv(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSDiv(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -907,7 +907,7 @@ case FDIV : { Value* val2 = pop(); Value* val1 = pop(); - push(BinaryOperator::createFDiv(val1, val2, "", currentBlock), + push(BinaryOperator::CreateFDiv(val1, val2, "", currentBlock), false); break; } @@ -917,7 +917,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createFDiv(val1, val2, "", currentBlock), + push(BinaryOperator::CreateFDiv(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -926,7 +926,7 @@ case IREM : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createSRem(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSRem(val1, val2, "", currentBlock), false); break; } @@ -936,7 +936,7 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createSRem(val1, val2, "", currentBlock), + push(BinaryOperator::CreateSRem(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -945,7 +945,7 @@ case FREM : { Value* val2 = pop(); Value* val1 = pop(); - push(BinaryOperator::createFRem(val1, val2, "", currentBlock), + push(BinaryOperator::CreateFRem(val1, val2, "", currentBlock), false); break; } @@ -955,14 +955,14 @@ llvm::Value* val2 = pop(); pop(); llvm::Value* val1 = pop(); - push(BinaryOperator::createFRem(val1, val2, "", currentBlock), + push(BinaryOperator::CreateFRem(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; } case INEG : - push(BinaryOperator::createSub( + push(BinaryOperator::CreateSub( module->constantZero, popAsInt(), "", currentBlock), false); @@ -970,7 +970,7 @@ case LNEG : { pop(); - push(BinaryOperator::createSub( + push(BinaryOperator::CreateSub( module->constantLongZero, pop(), "", currentBlock), false); push(module->constantZero, false); @@ -978,14 +978,14 @@ } case FNEG : - push(BinaryOperator::createSub( + push(BinaryOperator::CreateSub( module->constantFloatMinusZero, pop(), "", currentBlock), false); break; case DNEG : { pop(); - push(BinaryOperator::createSub( + push(BinaryOperator::CreateSub( module->constantDoubleMinusZero, pop(), "", currentBlock), false); push(module->constantZero, false); @@ -995,7 +995,7 @@ case ISHL : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createShl(val1, val2, "", currentBlock), + push(BinaryOperator::CreateShl(val1, val2, "", currentBlock), false); break; } @@ -1004,7 +1004,7 @@ Value* val2 = new ZExtInst(pop(), Type::Int64Ty, "", currentBlock); pop(); // remove the 0 on the stack Value* val1 = pop(); - push(BinaryOperator::createShl(val1, val2, "", currentBlock), + push(BinaryOperator::CreateShl(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -1013,7 +1013,7 @@ case ISHR : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createAShr(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock), false); break; } @@ -1022,7 +1022,7 @@ Value* val2 = new ZExtInst(pop(), Type::Int64Ty, "", currentBlock); pop(); // remove the 0 on the stack Value* val1 = pop(); - push(BinaryOperator::createAShr(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -1033,7 +1033,7 @@ Value* val1 = popAsInt(); Value* mask = ConstantInt::get(Type::Int32Ty, 0x1F); val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); - push(BinaryOperator::createLShr(val1, val2, "", currentBlock), + push(BinaryOperator::CreateLShr(val1, val2, "", currentBlock), false); break; } @@ -1044,7 +1044,7 @@ val2 = BinaryOperator::CreateAnd(val2, mask, "", currentBlock); pop(); // remove the 0 on the stack Value* val1 = pop(); - push(BinaryOperator::createLShr(val1, val2, "", currentBlock), + push(BinaryOperator::CreateLShr(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -1053,7 +1053,7 @@ case IAND : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createAnd(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAnd(val1, val2, "", currentBlock), false); break; } @@ -1063,7 +1063,7 @@ Value* val2 = pop(); pop(); // remove the 0 on the stack Value* val1 = pop(); - push(BinaryOperator::createAnd(val1, val2, "", currentBlock), + push(BinaryOperator::CreateAnd(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -1072,7 +1072,7 @@ case IOR : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createOr(val1, val2, "", currentBlock), + push(BinaryOperator::CreateOr(val1, val2, "", currentBlock), false); break; } @@ -1082,7 +1082,7 @@ Value* val2 = pop(); pop(); // remove the 0 on the stack Value* val1 = pop(); - push(BinaryOperator::createOr(val1, val2, "", currentBlock), + push(BinaryOperator::CreateOr(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -1091,7 +1091,7 @@ case IXOR : { Value* val2 = popAsInt(); Value* val1 = popAsInt(); - push(BinaryOperator::createXor(val1, val2, "", currentBlock), + push(BinaryOperator::CreateXor(val1, val2, "", currentBlock), false); break; } @@ -1101,7 +1101,7 @@ Value* val2 = pop(); pop(); // remove the 0 on the stack Value* val1 = pop(); - push(BinaryOperator::createXor(val1, val2, "", currentBlock), + push(BinaryOperator::CreateXor(val1, val2, "", currentBlock), false); push(module->constantZero, false); break; @@ -1110,7 +1110,7 @@ case IINC : { uint16 idx = WREAD_U1(bytecodes, true, i); sint16 val = WREAD_S1(bytecodes, false, i); - llvm::Value* add = BinaryOperator::createAdd( + llvm::Value* add = BinaryOperator::CreateAdd( new LoadInst(intLocals[idx], "", currentBlock), ConstantInt::get(Type::Int32Ty, val), "", currentBlock); @@ -1918,10 +1918,10 @@ } currentBlock = BB2; - Value* mult = BinaryOperator::createMul(arg1, sizeElement, "", + Value* mult = BinaryOperator::CreateMul(arg1, sizeElement, "", currentBlock); Value* size = - BinaryOperator::createAdd(module->JavaObjectSizeConstant, mult, + BinaryOperator::CreateAdd(module->JavaObjectSizeConstant, mult, "", currentBlock); std::vector args; args.push_back(size); Modified: vmkit/trunk/lib/N3/VMCore/CLIJit.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/CLIJit.cpp?rev=57835&r1=57834&r2=57835&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/CLIJit.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/CLIJit.cpp Mon Oct 20 11:11:20 2008 @@ -223,7 +223,7 @@ #endif } BinaryOperator* int32_tmp6 = - BinaryOperator::create(Instruction::Add, int32_i_015_0, const_int32_9, + BinaryOperator::Create(Instruction::Add, int32_i_015_0, const_int32_9, "tmp6", label_bb); LoadInst* int32_tmp10 = new LoadInst(ptr_tmp918, "tmp10", false, label_bb); ICmpInst* int1_tmp12 = new ICmpInst(ICmpInst::ICMP_SGT, int32_tmp10, Modified: vmkit/trunk/lib/N3/VMCore/Opcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/Opcodes.cpp?rev=57835&r1=57834&r2=57835&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/Opcodes.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/Opcodes.cpp Mon Oct 20 11:11:20 2008 @@ -251,7 +251,7 @@ Value* val1 = pop(); isPointer |= (val1->getType() == module->ptrType); verifyType(val1, val2, currentBlock); - Value* res = BinaryOperator::createAdd(val1, val2, "", currentBlock); + Value* res = BinaryOperator::CreateAdd(val1, val2, "", currentBlock); if (isPointer) { res = new IntToPtrInst(res, module->ptrType, "", currentBlock); } @@ -272,7 +272,7 @@ case AND: { Value* val2 = pop(); Value* val1 = pop(); - push(BinaryOperator::createAnd(val1, val2, "", currentBlock)); + push(BinaryOperator::CreateAnd(val1, val2, "", currentBlock)); break; } @@ -671,9 +671,9 @@ Value* one = pop(); if (one->getType()->isFloatingPoint()) { convertValue(one, two->getType(), currentBlock); - push(BinaryOperator::createFDiv(one, two, "", currentBlock)); + push(BinaryOperator::CreateFDiv(one, two, "", currentBlock)); } else { - push(BinaryOperator::createSDiv(one, two, "", currentBlock)); + push(BinaryOperator::CreateSDiv(one, two, "", currentBlock)); } break; } @@ -682,9 +682,9 @@ Value* two = pop(); Value* one = pop(); if (one->getType()->isFloatingPoint()) { - push(BinaryOperator::createFDiv(one, two, "", currentBlock)); + push(BinaryOperator::CreateFDiv(one, two, "", currentBlock)); } else { - push(BinaryOperator::createUDiv(one, two, "", currentBlock)); + push(BinaryOperator::CreateUDiv(one, two, "", currentBlock)); } break; } @@ -1003,7 +1003,7 @@ Value* val2 = pop(); Value* val1 = pop(); convertValue(val1, val2->getType(), currentBlock); - push(BinaryOperator::createMul(val1, val2, "", currentBlock)); + push(BinaryOperator::CreateMul(val1, val2, "", currentBlock)); break; } @@ -1019,7 +1019,7 @@ case NEG : { Value* val = pop(); - push(BinaryOperator::createSub( + push(BinaryOperator::CreateSub( Constant::getNullValue(val->getType()), val, "", currentBlock)); break; @@ -1028,14 +1028,14 @@ case NOP : break; case NOT : { - push(BinaryOperator::createNot(pop(), "", currentBlock)); + push(BinaryOperator::CreateNot(pop(), "", currentBlock)); break; } case OR : { Value* two = pop(); Value* one = pop(); - push(BinaryOperator::createOr(one, two, "", currentBlock)); + push(BinaryOperator::CreateOr(one, two, "", currentBlock)); break; } @@ -1048,9 +1048,9 @@ Value* two = pop(); Value* one = pop(); if (one->getType()->isFloatingPoint()) { - push(BinaryOperator::createFRem(one, two, "", currentBlock)); + push(BinaryOperator::CreateFRem(one, two, "", currentBlock)); } else { - push(BinaryOperator::createSRem(one, two, "", currentBlock)); + push(BinaryOperator::CreateSRem(one, two, "", currentBlock)); } break; } @@ -1059,9 +1059,9 @@ Value* two = pop(); Value* one = pop(); if (one->getType()->isFloatingPoint()) { - push(BinaryOperator::createFRem(one, two, "", currentBlock)); + push(BinaryOperator::CreateFRem(one, two, "", currentBlock)); } else { - push(BinaryOperator::createURem(one, two, "", currentBlock)); + push(BinaryOperator::CreateURem(one, two, "", currentBlock)); } break; } @@ -1087,7 +1087,7 @@ Value* val2 = pop(); Value* val1 = pop(); verifyType(val1, val2, currentBlock); - push(BinaryOperator::createShl(val1, val2, "", currentBlock)); + push(BinaryOperator::CreateShl(val1, val2, "", currentBlock)); break; } @@ -1095,7 +1095,7 @@ Value* val2 = pop(); Value* val1 = pop(); verifyType(val1, val2, currentBlock); - push(BinaryOperator::createAShr(val1, val2, "", currentBlock)); + push(BinaryOperator::CreateAShr(val1, val2, "", currentBlock)); break; } @@ -1103,7 +1103,7 @@ Value* val2 = pop(); Value* val1 = pop(); verifyType(val1, val2, currentBlock); - push(BinaryOperator::createLShr(val1, val2, "", currentBlock)); + push(BinaryOperator::CreateLShr(val1, val2, "", currentBlock)); break; } @@ -1235,7 +1235,7 @@ Value* val2 = pop(); Value* val1 = pop(); verifyType(val1, val2, currentBlock); - push(BinaryOperator::createSub(val1, val2, "", currentBlock)); + push(BinaryOperator::CreateSub(val1, val2, "", currentBlock)); break; } @@ -1269,7 +1269,7 @@ Value* two = pop(); Value* one = pop(); convertValue(two, one->getType(), currentBlock); - push(BinaryOperator::createXor(one, two, "", currentBlock)); + push(BinaryOperator::CreateXor(one, two, "", currentBlock)); break; } From nicolas.geoffray at lip6.fr Tue Oct 21 12:02:24 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 21 Oct 2008 19:02:24 -0000 Subject: [vmkit-commits] [vmkit] r57916 - /vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Message-ID: <200810211902.m9LJ2Obj025753@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 21 14:02:23 2008 New Revision: 57916 URL: http://llvm.org/viewvc/llvm-project?rev=57916&view=rev Log: Missed that one: It was causing a sigsegv when collecting in "inappropriate" moments. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h?rev=57916&r1=57915&r2=57916&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathReflect.h Tue Oct 21 14:02:23 2008 @@ -37,7 +37,7 @@ obj->pd->MARK_AND_TRACE; obj->signers->MARK_AND_TRACE; obj->constructor->MARK_AND_TRACE; - obj->vmdata->classLoader->MARK_AND_TRACE; + if (obj->vmdata) obj->vmdata->classLoader->MARK_AND_TRACE; } }; @@ -54,7 +54,8 @@ obj->JavaObject::CALL_TRACER; obj->name->MARK_AND_TRACE; obj->declaringClass->MARK_AND_TRACE; - obj->slot->classDef->classLoader->MARK_AND_TRACE; + // No need to see if classDef != NULL, it must be. + if (obj->slot) obj->slot->classDef->classLoader->MARK_AND_TRACE; } }; @@ -72,7 +73,7 @@ obj->JavaObject::CALL_TRACER; obj->name->MARK_AND_TRACE; obj->declaringClass->MARK_AND_TRACE; - obj->slot->classDef->classLoader->MARK_AND_TRACE; + if (obj->slot) obj->slot->classDef->classLoader->MARK_AND_TRACE; } }; @@ -87,7 +88,7 @@ static void STATIC_TRACER(JavaObjectConstructor) { obj->JavaObject::CALL_TRACER; obj->clazz->MARK_AND_TRACE; - obj->slot->classDef->classLoader->MARK_AND_TRACE; + if (obj->slot) obj->slot->classDef->classLoader->MARK_AND_TRACE; } }; From nicolas.geoffray at lip6.fr Tue Oct 21 22:28:06 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 22 Oct 2008 05:28:06 -0000 Subject: [vmkit-commits] [vmkit] r57959 - /vmkit/trunk/include/mvm/MvmMemoryManager.h Message-ID: <200810220528.m9M5S6Jk013547@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 22 00:28:05 2008 New Revision: 57959 URL: http://llvm.org/viewvc/llvm-project?rev=57959&view=rev Log: Add new virutal method. Modified: vmkit/trunk/include/mvm/MvmMemoryManager.h Modified: vmkit/trunk/include/mvm/MvmMemoryManager.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/MvmMemoryManager.h?rev=57959&r1=57958&r2=57959&view=diff ============================================================================== --- vmkit/trunk/include/mvm/MvmMemoryManager.h (original) +++ vmkit/trunk/include/mvm/MvmMemoryManager.h Wed Oct 22 00:28:05 2008 @@ -102,6 +102,10 @@ realMemoryManager->setMemoryExecutable(); } + virtual unsigned char* allocateSpace(intptr_t Size, unsigned int Align) { + return realMemoryManager->allocateSpace(Size, Align); + } + }; } // End mvm namespace From nicolas.geoffray at lip6.fr Tue Oct 21 22:28:42 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 22 Oct 2008 05:28:42 -0000 Subject: [vmkit-commits] [vmkit] r57960 - in /vmkit/trunk/lib/JnJVM: LLVMRuntime/runtime-default.ll VMCore/JavaRuntimeJIT.cpp VMCore/JnjvmModule.cpp VMCore/JnjvmModule.h VMCore/LowerConstantCalls.cpp Message-ID: <200810220528.m9M5SgOa013578@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 22 00:28:42 2008 New Revision: 57960 URL: http://llvm.org/viewvc/llvm-project?rev=57960&view=rev Log: Faster class initialization check. Modified: vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll 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=57960&r1=57959&r2=57960&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll (original) +++ vmkit/trunk/lib/JnJVM/LLVMRuntime/runtime-default.ll Wed Oct 22 00:28:42 2008 @@ -50,10 +50,8 @@ ;;;;; Constant calls for Jnjvm runtime internal objects field accesses ;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;; initialisationCheck - Checks if the class has been initialized and -;;; initializes if not. This is used for initialization barriers in an isolate -;;; environment, and in some specific scenario in a single environment. -declare %JavaClass* @initialisationCheck(%JavaClass*) readnone +;;; jnjvmRuntimeInitialiseClass - Initialises the class. +declare %JavaClass* @jnjvmRuntimeInitialiseClass(%JavaClass*) readnone ;;; arrayLength - Get the length of an array. declare i32 @arrayLength(%JavaObject*) readnone @@ -95,6 +93,11 @@ ;;; specific methods. declare %JavaObject* @multiCallNew(%JavaClass*, i32, ...) +;;; initialisationCheck - Checks if the class has been initialized and +;;; initializes if not. This is used for initialization barriers in an isolate +;;; environment, and in some specific scenario in a single environment. +declare %JavaClass* @initialisationCheck(%JavaClass*) readnone + ;;; forceInitialisationCheck - Force to check initialization. The difference ;;; between this function and the initialisationCheck function is that the ;;; latter is readnone and can thus be removed. This function is removed Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=57960&r1=57959&r2=57960&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Wed Oct 22 00:28:42 2008 @@ -304,7 +304,7 @@ JavaThread::get()->isolate->indexOutOfBounds(obj, index); } -extern "C" UserCommonClass* initialisationCheck(UserCommonClass* cl) { +extern "C" UserCommonClass* jnjvmRuntimeInitialiseClass(UserCommonClass* cl) { cl->initialiseClass(JavaThread::get()->isolate); return cl; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57960&r1=57959&r2=57960&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Oct 22 00:28:42 2008 @@ -58,6 +58,7 @@ llvm::ConstantInt* JnjvmModule::OffsetDisplayInClassConstant; llvm::ConstantInt* JnjvmModule::OffsetStatusInClassConstant; llvm::ConstantInt* JnjvmModule::OffsetCtpInClassConstant; +llvm::ConstantInt* JnjvmModule::ClassReadyConstant; const llvm::Type* JnjvmModule::JavaClassType; const llvm::Type* JnjvmModule::VTType; llvm::ConstantInt* JnjvmModule::JavaArrayElementsOffsetConstant; @@ -924,6 +925,8 @@ OffsetDepthInClassConstant = mvm::MvmModule::constantFour; OffsetStatusInClassConstant = mvm::MvmModule::constantFive; OffsetCtpInClassConstant = mvm::MvmModule::constantSix; + + ClassReadyConstant = ConstantInt::get(Type::Int32Ty, clinitParent); LLVMAssessorInfo::initialise(); } @@ -990,6 +993,7 @@ InitialisationCheckFunction = module->getFunction("initialisationCheck"); ForceInitialisationCheckFunction = module->getFunction("forceInitialisationCheck"); + InitialiseClassFunction = module->getFunction("jnjvmRuntimeInitialiseClass"); GetConstantPoolAtFunction = module->getFunction("getConstantPoolAt"); ArrayLengthFunction = module->getFunction("arrayLength"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=57960&r1=57959&r2=57960&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Wed Oct 22 00:28:42 2008 @@ -252,6 +252,7 @@ llvm::Function* PrintMethodStartFunction; llvm::Function* PrintMethodEndFunction; llvm::Function* JniProceedPendingExceptionFunction; + llvm::Function* InitialiseClassFunction; llvm::Function* InitialisationCheckFunction; llvm::Function* ForceInitialisationCheckFunction; llvm::Function* ClassLookupFunction; @@ -311,6 +312,8 @@ static llvm::ConstantInt* OffsetDisplayInClassConstant; static llvm::ConstantInt* OffsetStatusInClassConstant; static llvm::ConstantInt* OffsetCtpInClassConstant; + + static llvm::ConstantInt* ClassReadyConstant; static llvm::Constant* JavaClassNullConstant; Modified: vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=57960&r1=57959&r2=57960&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Wed Oct 22 00:28:42 2008 @@ -228,9 +228,72 @@ BranchInst::Create(NBB, ifTrue); break; } - } - - else if (V == module->GetConstantPoolAtFunction) { + } else if (V == module->InitialisationCheckFunction) { + Changed = true; + + BasicBlock* NBB = 0; + if (CI->getParent()->getTerminator() != CI) { + NBB = II->getParent()->splitBasicBlock(II); + CI->getParent()->getTerminator()->eraseFromParent(); + } else { + InvokeInst* Invoke = dyn_cast(CI); + assert(Invoke && "Last instruction is not an invoke"); + NBB = Invoke->getNormalDest(); + } + + Value* Cl = Call.getArgument(0); + std::vector indexes; + indexes.push_back(mvm::MvmModule::constantZero); + indexes.push_back(module->OffsetStatusInClassConstant); + Value* StatusPtr = GetElementPtrInst::Create(Cl, indexes.begin(), + indexes.end(), "", CI); + Value* Status = new LoadInst(StatusPtr, "", CI); + + + Value* test = new ICmpInst(ICmpInst::ICMP_UGT, Status, + jnjvm::JnjvmModule::ClassReadyConstant, + "", CI); + + BasicBlock* trueCl = BasicBlock::Create("Initialized", &F); + BasicBlock* falseCl = BasicBlock::Create("Uninitialized", &F); + PHINode* node = llvm::PHINode::Create(JnjvmModule::JavaClassType, "", trueCl); + node->addIncoming(Cl, CI->getParent()); + BranchInst::Create(trueCl, falseCl, test, CI); + + std::vector Args; + Args.push_back(Cl); + + Value* res = 0; + if (InvokeInst* Invoke = dyn_cast(CI)) { + BasicBlock* UI = Invoke->getUnwindDest(); + res = InvokeInst::Create(module->InitialiseClassFunction, + trueCl, UI, Args.begin(), + Args.end(), "", falseCl); + + // For some reason, an LLVM pass may add PHI nodes to the + // exception destination. + BasicBlock::iterator Temp = UI->getInstList().begin(); + while (PHINode* PHI = dyn_cast(Temp)) { + Value* Val = PHI->getIncomingValueForBlock(CI->getParent()); + PHI->removeIncomingValue(CI->getParent(), false); + PHI->addIncoming(Val, falseCl); + Temp++; + } + } else { + res = CallInst::Create(module->InitialiseClassFunction, + Args.begin(), Args.end(), "", + falseCl); + BranchInst::Create(trueCl, falseCl); + } + + node->addIncoming(res, falseCl); + + + CI->replaceAllUsesWith(node); + CI->eraseFromParent(); + BranchInst::Create(NBB, trueCl); + break; + } else if (V == module->GetConstantPoolAtFunction) { Function* resolver = dyn_cast(Call.getArgument(0)); assert(resolver && "Wrong use of GetConstantPoolAt"); const Type* returnType = resolver->getReturnType(); From nicolas.geoffray at lip6.fr Wed Oct 22 13:46:20 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Wed, 22 Oct 2008 20:46:20 -0000 Subject: [vmkit-commits] [vmkit] r57996 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JnjvmModule.cpp JnjvmModule.h Message-ID: <200810222046.m9MKkKt9023858@zion.cs.uiuc.edu> Author: geoffray Date: Wed Oct 22 15:46:18 2008 New Revision: 57996 URL: http://llvm.org/viewvc/llvm-project?rev=57996&view=rev Log: Put enveloppes for interface calls in global variables. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.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=57996&r1=57995&r2=57996&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Wed Oct 22 15:46:18 2008 @@ -2026,10 +2026,7 @@ new(allocator) Enveloppe(compilingClass->ctpInfo, index); compilingMethod->caches.push_back(enveloppe); - Value* llvmEnv = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, - uint64_t (enveloppe)), - module->EnveloppeType); + Value* llvmEnv = module->getEnveloppe(enveloppe, this); #else Value* llvmEnv = getConstantPoolAt(index, module->EnveloppeLookupFunction, Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=57996&r1=57995&r2=57996&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Wed Oct 22 15:46:18 2008 @@ -124,6 +124,24 @@ return new LoadInst(varGV, "", jit->currentBlock); } +Value* JnjvmModule::getEnveloppe(Enveloppe* enveloppe, JavaJIT* jit) { + llvm::GlobalVariable* varGV; + enveloppe_iterator SI = enveloppes.find(enveloppe); + if (SI != enveloppes.end()) { + varGV = SI->second; + } else { + void* ptr = enveloppe; + Constant* cons = + ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), + JnjvmModule::EnveloppeType); + varGV = new GlobalVariable(JnjvmModule::EnveloppeType, true, + GlobalValue::ExternalLinkage, + cons, "", this); + enveloppes.insert(std::make_pair(enveloppe, varGV)); + } + return new LoadInst(varGV, "", jit->currentBlock); +} + Value* JnjvmModule::getJavaClass(CommonClass* cl, JavaJIT* jit) { llvm::GlobalVariable* varGV = 0; java_class_iterator End = javaClasses.end(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=57996&r1=57995&r2=57996&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Wed Oct 22 15:46:18 2008 @@ -185,6 +185,7 @@ std::map staticInstances; std::map constantPools; std::map strings; + std::map enveloppes; typedef std::map::iterator native_class_iterator; @@ -204,6 +205,10 @@ typedef std::map::iterator string_iterator; + typedef std::map::iterator + enveloppe_iterator; + + VirtualTable* makeVT(Class* cl, bool stat); @@ -371,6 +376,7 @@ llvm::Value* getStaticInstance(Class* cl, JavaJIT* jit); llvm::Value* getVirtualTable(CommonClass* cl, JavaJIT* jit); + llvm::Value* getEnveloppe(Enveloppe* enveloppe, JavaJIT* jit); llvm::Value* getString(JavaString* str, JavaJIT* jit); llvm::Value* getConstantPool(JavaConstantPool* ctp, JavaJIT* jit); From nicolas.geoffray at lip6.fr Fri Oct 24 02:44:42 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 24 Oct 2008 09:44:42 -0000 Subject: [vmkit-commits] [vmkit] r58087 - in /vmkit/trunk: include/mvm/ lib/JnJVM/Classpath/ lib/JnJVM/VMCore/ Message-ID: <200810240944.m9O9ihGZ017880@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 24 04:44:42 2008 New Revision: 58087 URL: http://llvm.org/viewvc/llvm-project?rev=58087&view=rev Log: Removal of vectors and maps in Class, CommonClass, JavaField and JavaMethod classes. This gives us better control over memory allocations. Modified: vmkit/trunk/include/mvm/Allocator.h vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h 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/JavaInitialise.cpp 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/JavaMetaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/include/mvm/Allocator.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/Allocator.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/include/mvm/Allocator.h (original) +++ vmkit/trunk/include/mvm/Allocator.h Fri Oct 24 04:44:42 2008 @@ -232,6 +232,10 @@ void operator delete(void* ptr) { free(ptr); } + + void* operator new [](size_t sz, BumpPtrAllocator& allocator) { + return allocator.Allocate(sz); + } }; } // end namespace mvm Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Fri Oct 24 04:44:42 2008 @@ -32,9 +32,8 @@ verifyNull(Cl); Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); - UserClass* methodCl = 0; if (cl->lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, - false, methodCl)) + false, 0)) return true; return false; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMClass.cpp Fri Oct 24 04:44:42 2008 @@ -295,14 +295,11 @@ jclass Cl) { Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false); - std::vector * interfaces = cl->getInterfaces(); ArrayObject* ret = - (ArrayObject*)vm->upcalls->classArrayClass->doNew(interfaces->size(), vm); - sint32 index = 0; - for (std::vector::iterator i = interfaces->begin(), - e = interfaces->end(); i != e; ++i, ++index) { - UserClass* klass = *i; - ret->elements[index] = klass->getClassDelegatee(vm); + (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces, vm); + for (uint16 i = 0; i < cl->nbInterfaces; ++i) { + UserClass* klass = cl->interfaces[i]; + ret->elements[i] = klass->getClassDelegatee(vm); } return (jobject)ret; } @@ -337,13 +334,11 @@ UserClass* cl = NativeUtil::resolvedImplClass(vm, Cl, false)->asClass(); if (cl) { cl->resolveInnerOuterClasses(); - std::vector* innerClasses = cl->getInnerClasses(); UserClassArray* array = vm->upcalls->constructorArrayClass; - ArrayObject* res = (ArrayObject*)array->doNew(innerClasses->size(), vm); - uint32 index = 0; - for (std::vector::iterator i = innerClasses->begin(), - e = innerClasses->end(); i!= e; i++) { - res->elements[index++] = (*i)->getClassDelegatee(vm); + ArrayObject* res = (ArrayObject*)array->doNew(cl->nbInnerClasses, vm); + for (uint16 i = 0; i < cl->nbInnerClasses; ++i) { + UserClass* klass = cl->innerClasses[i]; + res->elements[i] = klass->getClassDelegatee(vm); } return (jobject)res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.cpp Fri Oct 24 04:44:42 2008 @@ -48,7 +48,7 @@ #endif } -Enveloppe::Enveloppe(UserConstantPool* ctp, uint32 i) { +void Enveloppe::initialise(UserConstantPool* ctp, uint32 i) { mvm::BumpPtrAllocator& allocator = ctp->classDef->classLoader->allocator; firstCache = new(allocator) CacheNode(this); ctpInfo = ctp; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaCache.h Fri Oct 24 04:44:42 2008 @@ -88,7 +88,13 @@ /// 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); + Enveloppe(UserConstantPool* info, uint32 index) { + initialise(info, index); + } + + Enveloppe() {} + + void initialise(UserConstantPool* info, uint32 index); }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Fri Oct 24 04:44:42 2008 @@ -41,7 +41,7 @@ const UTF8* Attribut::sourceFileAttribut = 0; CommonClass* ClassArray::SuperArray; -std::vector ClassArray::InterfacesArray; +Class** ClassArray::InterfacesArray; Attribut::Attribut(const UTF8* name, uint32 length, uint32 offset) { @@ -53,9 +53,8 @@ } Attribut* Class::lookupAttribut(const UTF8* key ) { - for (std::vector::iterator i = attributs.begin(), - e = attributs.end(); i!= e; ++i) { - Attribut* cur = *i; + for (uint32 i = 0; i < nbAttributs; ++i) { + Attribut* cur = &(attributs[i]); if (cur->name->equals(key)) return cur; } @@ -63,9 +62,8 @@ } Attribut* JavaField::lookupAttribut(const UTF8* key ) { - for (std::vector::iterator i = attributs.begin(), - e = attributs.end(); i!= e;++i) { - Attribut* cur = *i; + for (uint32 i = 0; i < nbAttributs; ++i) { + Attribut* cur = &(attributs[i]); if (cur->name->equals(key)) return cur; } @@ -73,22 +71,14 @@ } Attribut* JavaMethod::lookupAttribut(const UTF8* key ) { - for (std::vector::iterator i = attributs.begin(), - e = attributs.end(); i!= e; ++i) { - Attribut* cur = *i; + for (uint32 i = 0; i < nbAttributs; ++i) { + Attribut* cur = &(attributs[i]); if (cur->name->equals(key)) return cur; } return 0; } -bool CommonClass::FieldCmp::operator<(const CommonClass::FieldCmp &cmp) const { - if (name->lessThan(cmp.name)) return true; - else if (cmp.name->lessThan(name)) return false; - else return type->lessThan(cmp.type); -} - - CommonClass::~CommonClass() { classLoader->allocator.Deallocate(display); } @@ -96,48 +86,49 @@ CommonClass::CommonClass() { display = 0; virtualVT = 0; + nbVirtualFields = 0; + nbStaticFields = 0; + nbVirtualMethods = 0; + nbStaticMethods = 0; + nbInterfaces = 0; } -Class::Class() { +Class::Class() : CommonClass() { ctpInfo = 0; staticVT = 0; JInfo = 0; outerClass = 0; innerOuterResolved = false; + nbInnerClasses = 0; } Class::~Class() { - for (std::vector::iterator i = attributs.begin(), - e = attributs.end(); i!= e; ++i) { - Attribut* cur = *i; + for (uint32 i = 0; i < nbAttributs; ++i) { + Attribut* cur = &(attributs[i]); cur->~Attribut(); classLoader->allocator.Deallocate(cur); } - for (field_iterator i = staticFields.begin(), - e = staticFields.end(); i!= e; ++i) { - JavaField* cur = i->second; + for (uint32 i = 0; i < nbStaticFields; ++i) { + JavaField* cur = &(staticFields[i]); cur->~JavaField(); classLoader->allocator.Deallocate(cur); } - for (field_iterator i = virtualFields.begin(), - e = virtualFields.end(); i!= e; ++i) { - JavaField* cur = i->second; + for (uint32 i = 0; i < nbVirtualFields; ++i) { + JavaField* cur = &(virtualFields[i]); cur->~JavaField(); classLoader->allocator.Deallocate(cur); } - for (method_iterator i = virtualMethods.begin(), - e = virtualMethods.end(); i!= e; ++i) { - JavaMethod* cur = i->second; + for (uint32 i = 0; i < nbVirtualMethods; ++i) { + JavaMethod* cur = &(virtualMethods[i]); cur->~JavaMethod(); classLoader->allocator.Deallocate(cur); } - for (method_iterator i = staticMethods.begin(), - e = staticMethods.end(); i!= e; ++i) { - JavaMethod* cur = i->second; + for (uint32 i = 0; i < nbStaticMethods; ++i) { + JavaMethod* cur = &(staticMethods[i]); cur->~JavaMethod(); classLoader->allocator.Deallocate(cur); } @@ -156,9 +147,8 @@ } JavaField::~JavaField() { - for (std::vector::iterator i = attributs.begin(), - e = attributs.end(); i!= e; ++i) { - Attribut* cur = *i; + for (uint32 i = 0; i < nbAttributs; ++i) { + Attribut* cur = &(attributs[i]); cur->~Attribut(); classDef->classLoader->allocator.Deallocate(cur); } @@ -166,16 +156,14 @@ JavaMethod::~JavaMethod() { - for (std::vector::iterator i = attributs.begin(), - e = attributs.end(); i!= e; ++i) { - Attribut* cur = *i; + for (uint32 i = 0; i < nbAttributs; ++i) { + Attribut* cur = &(attributs[i]); cur->~Attribut(); classDef->classLoader->allocator.Deallocate(cur); } - - for (std::vector::iterator i = caches.begin(), - e = caches.end(); i!= e; ++i) { - Enveloppe* cur = *i; + + for (uint32 i = 0; i < nbEnveloppes; ++i) { + Enveloppe* cur = &(enveloppes[i]); cur->~Enveloppe(); classDef->classLoader->allocator.Deallocate(cur); } @@ -271,11 +259,21 @@ CommonClass::CommonClass(JnjvmClassLoader* loader, const UTF8* n, bool isArray) { name = n; - this->virtualVT = 0; - this->status = loaded; - this->classLoader = loader; - this->array = isArray; - this->primitive = false; + virtualVT = 0; + status = loaded; + classLoader = loader; + array = isArray; + primitive = false; + nbVirtualMethods = 0; + nbStaticMethods = 0; + nbStaticFields = 0; + nbVirtualFields = 0; + nbInterfaces = 0; + interfaces = 0; + virtualMethods = 0; + staticMethods = 0; + virtualFields = 0; + staticFields = 0; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) this->delegatee = 0; #endif @@ -302,6 +300,7 @@ outerClass = 0; innerOuterResolved = false; display = 0; + nbInnerClasses = 0; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) _staticInstance = 0; #endif @@ -313,6 +312,7 @@ _baseClass = base; super = ClassArray::SuperArray; interfaces = ClassArray::InterfacesArray; + nbInterfaces = 2; depth = 1; display = (CommonClass**)loader->allocator.Allocate(2 * sizeof(CommonClass*)); display[0] = ClassArray::SuperArray; @@ -413,18 +413,26 @@ const UTF8* type, bool isStatic, bool recurse, - Class*& methodCl) { + Class** methodCl) { - CommonClass::FieldCmp CC(name, type); - CommonClass::method_map* map = isStatic ? getStaticMethods() : - getVirtualMethods(); - CommonClass::method_iterator End = map->end(); - CommonClass::method_iterator I = map->find(CC); - if (I != End) { - methodCl = (Class*)this; - return I->second; + JavaMethod* methods = 0; + uint32 nb = 0; + if (isStatic) { + methods = getStaticMethods(); + nb = nbStaticMethods; + } else { + methods = getVirtualMethods(); + nb = nbVirtualMethods; } + for (uint32 i = 0; i < nb; ++i) { + JavaMethod& res = methods[i]; + if (res.name->equals(name) && res.type->equals(type)) { + if (methodCl) *methodCl = (Class*)this; + return &res; + } + } + JavaMethod *cur = 0; if (recurse) { @@ -432,11 +440,10 @@ recurse, methodCl); if (cur) return cur; if (isStatic) { - std::vector* interfaces = getInterfaces(); - for (std::vector::iterator i = interfaces->begin(), - e = interfaces->end(); i!= e; i++) { - cur = (*i)->lookupMethodDontThrow(name, type, isStatic, recurse, - methodCl); + for (uint16 i = 0; i < nbInterfaces; ++i) { + Class* I = interfaces[i]; + cur = I->lookupMethodDontThrow(name, type, isStatic, recurse, + methodCl); if (cur) return cur; } } @@ -447,7 +454,7 @@ JavaMethod* CommonClass::lookupMethod(const UTF8* name, const UTF8* type, bool isStatic, bool recurse, - Class*& methodCl) { + Class** methodCl) { JavaMethod* res = lookupMethodDontThrow(name, type, isStatic, recurse, methodCl); if (!res) { @@ -459,18 +466,25 @@ JavaField* CommonClass::lookupFieldDontThrow(const UTF8* name, const UTF8* type, bool isStatic, bool recurse, - CommonClass*& definingClass) { - - CommonClass::FieldCmp CC(name, type); - CommonClass::field_map* map = isStatic ? getStaticFields() : - getVirtualFields(); - CommonClass::field_iterator End = map->end(); - CommonClass::field_iterator I = map->find(CC); - if (I != End) { - definingClass = this; - return I->second; + CommonClass** definingClass) { + JavaField* fields = 0; + uint32 nb = 0; + if (isStatic) { + fields = getStaticFields(); + nb = nbStaticFields; + } else { + fields = getVirtualFields(); + nb = nbVirtualFields; } + for (uint32 i = 0; i < nb; ++i) { + JavaField& res = fields[i]; + if (res.name->equals(name) && res.type->equals(type)) { + if (definingClass) *definingClass = this; + return &res; + } + } + JavaField *cur = 0; if (recurse) { @@ -478,11 +492,10 @@ recurse, definingClass); if (cur) return cur; if (isStatic) { - std::vector* interfaces = getInterfaces(); - for (std::vector::iterator i = interfaces->begin(), - e = interfaces->end(); i!= e; i++) { - cur = (*i)->lookupFieldDontThrow(name, type, isStatic, recurse, - definingClass); + for (uint16 i = 0; i < nbInterfaces; ++i) { + Class* I = interfaces[i]; + cur = I->lookupFieldDontThrow(name, type, isStatic, recurse, + definingClass); if (cur) return cur; } } @@ -493,7 +506,7 @@ JavaField* CommonClass::lookupField(const UTF8* name, const UTF8* type, bool isStatic, bool recurse, - CommonClass*& definingClass) { + CommonClass** definingClass) { JavaField* res = lookupFieldDontThrow(name, type, isStatic, recurse, definingClass); @@ -522,7 +535,7 @@ if (getSuper()->inheritName(Tname)) return true; } - for (uint32 i = 0; i < interfaces.size(); ++i) { + for (uint32 i = 0; i < nbInterfaces; ++i) { if (interfaces[i]->inheritName(Tname)) return true; } return false; @@ -555,10 +568,10 @@ bool UserCommonClass::implements(UserCommonClass* cl) { if (this == cl) return true; else { - for (std::vector::iterator i = interfaces.begin(), - e = interfaces.end(); i!= e; i++) { - if (*i == cl) return true; - else if ((*i)->implements(cl)) return true; + for (uint16 i = 0; i < nbInterfaces; ++i) { + Class* I = interfaces[i]; + if (I == cl) return true; + else if (I->implements(cl)) return true; } if (super) { return super->implements(cl); @@ -636,68 +649,56 @@ } } -JavaMethod* CommonClass::constructMethod(const UTF8* name, +JavaMethod* CommonClass::constructMethod(JavaMethod& method, + const UTF8* name, const UTF8* type, uint32 access) { - method_map& map = isStatic(access) ? staticMethods : virtualMethods; - FieldCmp CC(name, type); - method_iterator End = map.end(); - method_iterator I = map.find(CC); - if (I == End) { - JavaMethod* method = new(classLoader->allocator) JavaMethod(); - method->name = name; - method->type = type; - method->classDef = (Class*)this; - method->_signature = 0; - method->code = 0; - method->access = access; - method->canBeInlined = false; - method->offset = 0; - method->JInfo = 0; - map.insert(std::make_pair(CC, method)); - return method; - } else { - return I->second; - } + method.name = name; + method.type = type; + method.classDef = (Class*)this; + method._signature = 0; + method.code = 0; + method.access = access; + method.canBeInlined = false; + method.offset = 0; + method.JInfo = 0; + return &method; } -JavaField* CommonClass::constructField(const UTF8* name, +JavaField* CommonClass::constructField(JavaField& field, + const UTF8* name, const UTF8* type, uint32 access) { - field_map& map = isStatic(access) ? staticFields : virtualFields; - FieldCmp CC(name, type); - field_iterator End = map.end(); - field_iterator I = map.find(CC); - if (I == End) { - JavaField* field = new(classLoader->allocator) JavaField(); - field->name = name; - field->type = type; - field->classDef = (Class*)this; - field->_signature = 0; - field->ptrOffset = 0; - field->access = access; - field->JInfo = 0; - map.insert(std::make_pair(CC, field)); - return field; - } else { - return I->second; - } + field.name = name; + field.type = type; + field.classDef = (Class*)this; + field._signature = 0; + field.ptrOffset = 0; + field.access = access; + field.JInfo = 0; + return &field; } void Class::readParents(Reader& reader) { - unsigned short int superEntry = reader.readU2(); - const UTF8* super = superEntry ? + uint16 superEntry = reader.readU2(); + const UTF8* superUTF8 = superEntry ? ctpInfo->resolveClassName(superEntry) : 0; - unsigned short int nbI = reader.readU2(); - superUTF8 = super; + uint16 nbI = reader.readU2(); + // Use the super field to store the UTF8. since the field is never + // used before actually loading the super, this is harmless. + super = (Class*)superUTF8; + + // Use the regular interface array to store the UTF8s. Since this array + // is never used before actually loading the interfaces, this is harmless. + interfaces = (Class**) + classLoader->allocator.Allocate(nbI * sizeof(Class*)); + nbInterfaces = nbI; for (int i = 0; i < nbI; i++) - interfacesUTF8.push_back(ctpInfo->resolveClassName(reader.readU2())); + interfaces[i] = (Class*)ctpInfo->resolveClassName(reader.readU2()); } void UserClass::loadParents() { - std::vector* interfacesUTF8 = getInterfacesUTF8(); - unsigned nbI = interfacesUTF8->size(); - const UTF8* superUTF8 = getSuperUTF8(); + const UTF8* superUTF8 = (const UTF8*)super; if (superUTF8 == 0) { depth = 0; display = (CommonClass**) @@ -713,48 +714,70 @@ display[depth] = this; } - for (unsigned i = 0; i < nbI; i++) - interfaces.push_back((UserClass*)classLoader->loadName((*interfacesUTF8)[i], - true, true)); + for (unsigned i = 0; i < nbInterfaces; i++) + interfaces[i] = + ((UserClass*)classLoader->loadName((const UTF8*)interfaces[i], + true, true)); } -void Class::readAttributs(Reader& reader, std::vector& attr) { - unsigned short int nba = reader.readU2(); +Attribut* Class::readAttributs(Reader& reader, uint16& size) { + uint16 nba = reader.readU2(); + Attribut* attributs = new(classLoader->allocator) Attribut[nba]; + for (int i = 0; i < nba; i++) { const UTF8* attName = ctpInfo->UTF8At(reader.readU2()); uint32 attLen = reader.readU4(); - Attribut* att = new(classLoader->allocator) Attribut(attName, attLen, - reader.cursor); - attr.push_back(att); + Attribut& att = attributs[i]; + att.start = reader.cursor; + att.nbb = attLen; + att.name = attName; reader.seek(attLen, Reader::SeekCur); } + + size = nba; + return attributs; } void Class::readFields(Reader& reader) { uint16 nbFields = reader.readU2(); - uint32 sindex = 0; - uint32 vindex = 0; + virtualFields = new (classLoader->allocator) JavaField[nbFields]; + staticFields = virtualFields + nbFields; for (int i = 0; i < nbFields; i++) { uint16 access = reader.readU2(); const UTF8* name = ctpInfo->UTF8At(reader.readU2()); const UTF8* type = ctpInfo->UTF8At(reader.readU2()); - JavaField* field = constructField(name, type, access); - isStatic(access) ? - field->num = sindex++ : - field->num = vindex++; - readAttributs(reader, field->attributs); + JavaField* field = 0; + if (isStatic(access)) { + --staticFields; + field = constructField(staticFields[0], name, type, access); + ++nbStaticFields; + } else { + field = constructField(virtualFields[nbVirtualFields], name, type, access); + ++nbVirtualFields; + } + field->attributs = readAttributs(reader, field->nbAttributs); } } void Class::readMethods(Reader& reader) { uint16 nbMethods = reader.readU2(); + virtualMethods = new(classLoader->allocator) JavaMethod[nbMethods]; + staticMethods = virtualMethods + nbMethods; for (int i = 0; i < nbMethods; i++) { uint16 access = reader.readU2(); const UTF8* name = ctpInfo->UTF8At(reader.readU2()); const UTF8* type = ctpInfo->UTF8At(reader.readU2()); - JavaMethod* meth = constructMethod(name, type, access); - readAttributs(reader, meth->attributs); + JavaMethod* meth = 0; + if (isStatic(access)) { + --staticMethods; + meth = constructMethod(staticMethods[0], name, type, access); + ++nbStaticMethods; + } else { + meth = constructMethod(virtualMethods[nbVirtualMethods], name, type, access); + ++nbVirtualMethods; + } + meth->attributs = readAttributs(reader, meth->nbAttributs); } } @@ -769,8 +792,8 @@ if (magic != Jnjvm::Magic) { JavaThread::get()->isolate->classFormatError("bad magic number %p", magic); } - minor = reader.readU2(); - major = reader.readU2(); + /* uint16 minor = */ reader.readU2(); + /* uint16 major = */ reader.readU2(); uint32 ctpSize = reader.readU2(); ctpInfo = new(classLoader->allocator, ctpSize) JavaConstantPool(this, reader, ctpSize); @@ -790,7 +813,7 @@ readParents(reader); readFields(reader); readMethods(reader); - readAttributs(reader, attributs); + attributs = readAttributs(reader, nbAttributs); } #ifndef ISOLATE_SHARING @@ -839,7 +862,7 @@ Attribut* attribut = lookupAttribut(Attribut::innerClassesAttribut); if (attribut != 0) { Reader reader(attribut, getBytes()); - + uint16 temp = 0; uint16 nbi = reader.readU2(); for (uint16 i = 0; i < nbi; ++i) { uint16 inner = reader.readU2(); @@ -853,8 +876,12 @@ if (clInner == this) { outerClass = clOuter; } else if (clOuter == this) { + if (!temp) { + innerClasses = (Class**) + classLoader->allocator.Allocate(nbi * sizeof(Class*)); + } clInner->setInnerAccess(accessFlags); - innerClasses.push_back(clInner); + innerClasses[nbInnerClasses++] = clInner; } } } @@ -864,9 +891,8 @@ void CommonClass::getDeclaredConstructors(std::vector& res, bool publicOnly) { - for (CommonClass::method_iterator i = virtualMethods.begin(), - e = virtualMethods.end(); i != e; ++i) { - JavaMethod* meth = i->second; + for (uint32 i = 0; i < nbVirtualMethods; ++i) { + JavaMethod* meth = &virtualMethods[i]; bool pub = isPublic(meth->access); if (meth->name->equals(Jnjvm::initName) && (!publicOnly || pub)) { res.push_back(meth); @@ -876,18 +902,16 @@ void CommonClass::getDeclaredMethods(std::vector& res, bool publicOnly) { - for (CommonClass::method_iterator i = virtualMethods.begin(), - e = virtualMethods.end(); i != e; ++i) { - JavaMethod* meth = i->second; + for (uint32 i = 0; i < nbVirtualMethods; ++i) { + JavaMethod* meth = &virtualMethods[i]; bool pub = isPublic(meth->access); if (!(meth->name->equals(Jnjvm::initName)) && (!publicOnly || pub)) { res.push_back(meth); } } - for (CommonClass::method_iterator i = staticMethods.begin(), - e = staticMethods.end(); i != e; ++i) { - JavaMethod* meth = i->second; + for (uint32 i = 0; i < nbStaticMethods; ++i) { + JavaMethod* meth = &staticMethods[i]; bool pub = isPublic(meth->access); if (!(meth->name->equals(Jnjvm::clinitName)) && (!publicOnly || pub)) { res.push_back(meth); @@ -897,17 +921,15 @@ void CommonClass::getDeclaredFields(std::vector& res, bool publicOnly) { - for (CommonClass::field_iterator i = virtualFields.begin(), - e = virtualFields.end(); i != e; ++i) { - JavaField* field = i->second; + for (uint32 i = 0; i < nbVirtualFields; ++i) { + JavaField* field = &virtualFields[i]; if (!publicOnly || isPublic(field->access)) { res.push_back(field); } } - for (CommonClass::field_iterator i = staticFields.begin(), - e = staticFields.end(); i != e; ++i) { - JavaField* field = i->second; + for (uint32 i = 0; i < nbStaticFields; ++i) { + JavaField* field = &staticFields[i]; if (!publicOnly || isPublic(field->access)) { res.push_back(field); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Fri Oct 24 04:44:42 2008 @@ -10,7 +10,6 @@ #ifndef JNJVM_JAVA_CLASS_H #define JNJVM_JAVA_CLASS_H -#include #include #include "types.h" @@ -82,6 +81,7 @@ /// Attribut - Create an attribut at the given length and offset. /// Attribut(const UTF8* name, uint32 length, uint32 offset); + Attribut() {} /// codeAttribut - The "Code" JVM attribut. This is a method attribut for /// finding the bytecode of a method in the .class file. @@ -126,26 +126,6 @@ #ifdef ISOLATE_SHARING friend class UserCommonClass; #endif -private: - - -/// FieldCmp - Internal class for field and method lookup in a class. -/// -class FieldCmp { -public: - - /// name - The name of the field/method - /// - const UTF8* name; - - /// type - The type of the field/method. - /// - const UTF8* type; - - FieldCmp(const UTF8* n, const UTF8* t) : name(n), type(t) {} - - bool operator<(const FieldCmp &cmp) const; -}; public: @@ -169,13 +149,12 @@ /// VirtualTable* virtualVT; - /// display - The class hierarchy of supers for this class. Array classes - /// do not need it. + /// display - The class hierarchy of supers for this class. /// CommonClass** display; /// depth - The depth of this class in its class hierarchy. - /// display[depth] contains the class. Array classes do not need it. + /// display[depth] contains the class. /// uint32 depth; @@ -255,12 +234,14 @@ /// interfaces - The interfaces this class implements. /// - std::vector interfaces; + Class** interfaces; - std::vector * getInterfaces() { - return &interfaces; + Class** getInterfaces() { + return interfaces; } + uint16 nbInterfaces; + /// name - The name of the class. /// const UTF8* name; @@ -277,22 +258,6 @@ return super; } - /// superUTF8 - The name of the parent of this class. - /// - const UTF8* superUTF8; - - const UTF8* getSuperUTF8() { - return superUTF8; - } - - /// interfacesUTF8 - The names of the interfaces this class implements. - /// - std::vector interfacesUTF8; - - std::vector* getInterfacesUTF8() { - return &interfacesUTF8; - } - /// lockVar - When multiple threads want to load/resolve/initialize a class, /// they must be synchronized so that these steps are only performed once /// for a given class. @@ -312,49 +277,40 @@ JavaObject* delegatee; #endif - - typedef std::map >::iterator - field_iterator; - - typedef std::map > - field_map; - /// virtualFields - List of all the virtual fields defined in this class. /// This does not contain non-redefined super fields. - field_map virtualFields; - + JavaField* virtualFields; + uint16 nbVirtualFields; + /// staticFields - List of all the static fields defined in this class. /// - field_map staticFields; - - typedef std::map >::iterator - method_iterator; - - typedef std::map > - method_map; + JavaField* staticFields; + uint16 nbStaticFields; /// virtualMethods - List of all the virtual methods defined by this class. /// This does not contain non-redefined super methods. - method_map virtualMethods; + JavaMethod* virtualMethods; + uint16 nbVirtualMethods; /// staticMethods - List of all the static methods defined by this class. /// - method_map staticMethods; + JavaMethod* staticMethods; + uint16 nbStaticMethods; - field_map* getStaticFields() { return &staticFields; } - field_map* getVirtualFields() { return &virtualFields; } - method_map* getStaticMethods() { return &staticMethods; } - method_map* getVirtualMethods() { return &virtualMethods; } + JavaField* getStaticFields() { return staticFields; } + JavaField* getVirtualFields() { return virtualFields; } + JavaMethod* getStaticMethods() { return staticMethods; } + JavaMethod* getVirtualMethods() { return virtualMethods; } - /// constructMethod - Add a new method in this class method map. + /// constructMethod - Create a new method. /// - JavaMethod* constructMethod(const UTF8* name, const UTF8* type, - uint32 access); + JavaMethod* constructMethod(JavaMethod& method, const UTF8* name, + const UTF8* type, uint32 access); - /// constructField - Add a new field in this class field map. + /// constructField - Create a new field. /// - JavaField* constructField(const UTF8* name, const UTF8* type, - uint32 access); + JavaField* constructField(JavaField& field, const UTF8* name, + const UTF8* type, uint32 access); /// printClassName - Adds a string representation of this class in the /// given buffer. @@ -396,24 +352,24 @@ /// Do not throw if the method is not found. /// JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type, - bool isStatic, bool recurse, Class*& cl); + bool isStatic, bool recurse, Class** cl); /// lookupMethod - Lookup a method and throw an exception if not found. /// JavaMethod* lookupMethod(const UTF8* name, const UTF8* type, bool isStatic, - bool recurse, Class*& cl); + bool recurse, Class** cl); /// lookupFieldDontThrow - Lookup a field in the field map of this class. Do /// not throw if the field is not found. /// JavaField* lookupFieldDontThrow(const UTF8* name, const UTF8* type, bool isStatic, bool recurse, - CommonClass*& definingClass); + CommonClass** definingClass); /// lookupField - Lookup a field and throw an exception if not found. /// JavaField* lookupField(const UTF8* name, const UTF8* type, bool isStatic, - bool recurse, CommonClass*& definingClass); + bool recurse, CommonClass** definingClass); /// print - Print the class for debugging purposes. /// @@ -509,7 +465,7 @@ void getDeclaredConstructors(std::vector& res, bool publicOnly); void getDeclaredMethods(std::vector& res, bool publicOnly); void getDeclaredFields(std::vector& res, bool publicOnly); - void setInterfaces(std::vector I) { + void setInterfaces(Class** I) { interfaces = I; } void setSuper(CommonClass* S) { @@ -529,10 +485,6 @@ static UserClassPrimitive* byteIdToPrimitive(char id, Classpath* upcalls); - void* operator new(size_t sz, mvm::BumpPtrAllocator& allocator) { - return allocator.Allocate(sz); - } - }; @@ -542,18 +494,6 @@ class Class : public CommonClass { public: - /// VT - The virtual table of this class. - /// - static VirtualTable* VT; - - /// minor - The minor version of this class. - /// - unsigned int minor; - - /// major - The major version of this class. - /// - unsigned int major; - /// bytes - The .class file of this class. /// ArrayUInt8* bytes; @@ -564,21 +504,31 @@ /// attributs - JVM attributes of this class. /// - std::vector attributs; + Attribut* attributs; + uint16 nbAttributs; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) /// innerClasses - The inner classes of this class. /// - std::vector innerClasses; + Class** innerClasses; + uint16 nbInnerClasses; /// outerClass - The outer class, if this class is an inner class. /// Class* outerClass; + + Class* getOuterClass() { + return outerClass; + } + + Class** getInnerClasses() { + return innerClasses; + } #endif /// innerAccess - The access of this class, if this class is an inner class. /// - uint32 innerAccess; + uint16 innerAccess; void setInnerAccess(uint32 access) { innerAccess = access; @@ -662,7 +612,7 @@ /// readAttributs - Reads the attributs of the class. /// - void readAttributs(Reader& reader, std::vector & attr); + Attribut* readAttributs(Reader& reader, uint16& size); /// readFields - Reads the fields of the class. /// @@ -687,16 +637,6 @@ void resolveInnerOuterClasses(); -#ifndef ISOLATE_SHARING - Class* getOuterClass() { - return outerClass; - } - - std::vector* getInnerClasses() { - return &innerClasses; - } -#endif - mvm::JITInfo* JInfo; template Ty *getInfo() { @@ -726,10 +666,6 @@ public: - /// VT - The virtual table of array classes. - /// - static VirtualTable* VT; - /// _baseClass - The base class of the array, or null if not resolved. /// CommonClass* _baseClass; @@ -776,7 +712,7 @@ virtual void TRACER; static CommonClass* SuperArray; - static std::vector InterfacesArray; + static Class** InterfacesArray; }; /// JavaMethod - This class represents Java methods. @@ -803,16 +739,18 @@ /// access - Java access type of this method (e.g. private, public...). /// - unsigned int access; + uint16 access; /// attributs - List of Java attributs of this method. /// - std::vector attributs; + Attribut* attributs; + uint16 nbAttributs; /// caches - List of caches in this method. For all invokeinterface bytecode /// there is a corresponding cache. /// - std::vector caches; + Enveloppe* enveloppes; + uint16 nbEnveloppes; /// classDef - The Java class where the method is defined. /// @@ -950,7 +888,7 @@ /// access - The Java access type of this field (e.g. public, private). /// - unsigned int access; + uint16 access; /// name - The name of the field. /// @@ -962,7 +900,8 @@ /// attributs - List of Java attributs for this field. /// - std::vector attributs; + Attribut* attributs; + uint16 nbAttributs; /// classDef - The class where the field is defined. /// @@ -975,7 +914,7 @@ /// num - The index of the field in the field list. /// - uint32 num; + uint16 num; /// getSignature - Get the signature of this field, resolving it if /// necessary. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Fri Oct 24 04:44:42 2008 @@ -365,10 +365,9 @@ const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16); cl = getMethodClassIfLoaded(entry >> 16); if (cl && cl->status >= classRead) { - Class* methodCl = 0; // lookup the method meth = cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), - false, methodCl); + false, 0); } } @@ -410,9 +409,8 @@ CommonClass* cl = getMethodClassIfLoaded(entry >> 16); if (cl && cl->status >= classRead) { // lookup the method - Class* methodCl = 0; meth = cl->lookupMethodDontThrow(utf8, sign->keyName, isStatic(access), - false, methodCl); + false, 0); if (meth) { // don't throw if no meth, the exception will be thrown just in time JnjvmModule* M = classDef->classLoader->TheModule; @@ -473,9 +471,8 @@ const UTF8* utf8 = UTF8At(ctpDef[ntIndex] >> 16); CommonClass* cl = getMethodClassIfLoaded(entry >> 16); if (cl && cl->status >= resolved) { - CommonClass* fieldCl = 0; JavaField* field = cl->lookupFieldDontThrow(utf8, sign->keyName, stat, - true, fieldCl); + true, 0); // don't throw if no field, the exception will be thrown just in time if (field) { if (!stat) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Fri Oct 24 04:44:42 2008 @@ -47,8 +47,6 @@ X fake; \ X::VT = ((void**)(void*)(&fake))[0]; } - INIT(Class); - INIT(ClassArray); INIT(JavaThread); INIT(Jnjvm); INIT(JnjvmBootstrapLoader); @@ -110,14 +108,17 @@ JCL->upcalls->ArrayOfByte = JCL->constructArray(JCL->asciizConstructUTF8("[B"), JCL->upcalls->OfByte); + JCL->InterfacesArray = + (Class**)JCL->allocator.Allocate(2 * sizeof(UserClass*)); + // Now we can create the super and interfaces of arrays. - JCL->InterfacesArray.push_back( + JCL->InterfacesArray[0] = JCL->loadName(JCL->asciizConstructUTF8("java/lang/Cloneable"), false, - false)); + false); - JCL->InterfacesArray.push_back( + JCL->InterfacesArray[1] = JCL->loadName(JCL->asciizConstructUTF8("java/io/Serializable"), false, - false)); + false); JCL->SuperArray = JCL->loadName(JCL->asciizConstructUTF8("java/lang/Object"), false, @@ -126,8 +127,8 @@ #ifdef ISOLATE_SHARING if (!ClassArray::SuperArray) { ClassArray::SuperArray = JCL->SuperArray->classDef; - ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[0]->classDef); - ClassArray::InterfacesArray.push_back((Class*)JCL->InterfacesArray[1]->classDef); + ClassArray::InterfacesArray[0] = ((Class*)JCL->InterfacesArray[0]->classDef); + ClassArray::InterfacesArray[1] = ((Class*)JCL->InterfacesArray[1]->classDef); } #else ClassArray::SuperArray = JCL->SuperArray; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Fri Oct 24 04:44:42 2008 @@ -790,8 +790,10 @@ unsigned nbe = readExceptionTable(reader); exploreOpcodes(&compilingClass->bytes->elements[start], codeLen); - - + compilingMethod->enveloppes = + new (compilingClass->classLoader->allocator) Enveloppe[nbEnveloppes]; + compilingMethod->nbEnveloppes = nbEnveloppes; + nbEnveloppes = 0; endBlock = createBasicBlock("end"); @@ -2021,12 +2023,10 @@ #ifndef ISOLATE_SHARING // ok now the cache - mvm::BumpPtrAllocator& allocator = compilingClass->classLoader->allocator; - Enveloppe* enveloppe = - new(allocator) Enveloppe(compilingClass->ctpInfo, index); - compilingMethod->caches.push_back(enveloppe); + Enveloppe& enveloppe = compilingMethod->enveloppes[nbEnveloppes++]; + enveloppe.initialise(compilingClass->ctpInfo, index); - Value* llvmEnv = module->getEnveloppe(enveloppe, this); + Value* llvmEnv = module->getEnveloppe(&enveloppe, this); #else Value* llvmEnv = getConstantPoolAt(index, module->EnveloppeLookupFunction, Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Fri Oct 24 04:44:42 2008 @@ -64,6 +64,10 @@ public: + JavaJIT() { + nbEnveloppes = 0; + } + JnjvmModule* module; static void invokeOnceVoid(Jnjvm* vm, JnjvmClassLoader* loader, @@ -266,6 +270,10 @@ static JavaObject* getCallingClassLoader(); static void printBacktrace(); static JavaMethod* IPToJavaMethod(void* ip); + + /// nbEnveloppes - Number of enveloppes (ie invokeinterface) in this + /// method. + uint32 nbEnveloppes; }; enum Opcode { Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Fri Oct 24 04:44:42 2008 @@ -2450,6 +2450,7 @@ break; case INVOKEINTERFACE : + ++nbEnveloppes; i += 4; break; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Fri Oct 24 04:44:42 2008 @@ -34,10 +34,9 @@ cl->initialiseClass(vm); bool stat = access == ACC_STATIC ? true : false; - UserClass* methodCl = 0; JavaMethod* method = cl->lookupMethod(loader->asciizConstructUTF8(func), loader->asciizConstructUTF8(sign), stat, - true, methodCl); + true, 0); va_list ap; va_start(ap, access); if (stat) { @@ -146,8 +145,7 @@ } \ \ verifyNull(obj);\ - UserClass* methodCl = 0; \ - JavaMethod* meth = obj->classOf->lookupMethod(name, type, false, true, methodCl);\ + JavaMethod* meth = obj->classOf->lookupMethod(name, type, false, true, 0);\ \ Signdef* sign = getSignature(); \ void* func = meth->compiledPtr();\ Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Fri Oct 24 04:44:42 2008 @@ -60,7 +60,7 @@ if (!rcache) { UserClass* methodCl = 0; JavaMethod* dmeth = ocl->lookupMethod(utf8, sign->keyName, false, true, - methodCl); + &methodCl); #ifndef ISOLATE_SHARING assert(dmeth->classDef->isReady() && "Class not ready in a virtual lookup."); @@ -99,13 +99,12 @@ } UserCommonClass* cl = 0; - UserCommonClass* fieldCl = 0; const UTF8* utf8 = 0; Typedef* sign = 0; ctpInfo->resolveField(index, cl, utf8, sign); - JavaField* field = cl->lookupField(utf8, sign->keyName, false, true, fieldCl); + JavaField* field = cl->lookupField(utf8, sign->keyName, false, true, 0); ctpInfo->ctpRes[index] = (void*)field->ptrOffset; @@ -126,7 +125,7 @@ ctpInfo->resolveField(index, cl, utf8, sign); - JavaField* field = cl->lookupField(utf8, sign->keyName, true, true, fieldCl); + JavaField* field = cl->lookupField(utf8, sign->keyName, true, true, &fieldCl); fieldCl->initialiseClass(JavaThread::get()->isolate); void* ptr = @@ -169,7 +168,7 @@ shared->resolveMethod(index, baseCl, utf8, sign); UserClass* methodCl = 0; - refCl->lookupMethod(utf8, sign->keyName, true, true, methodCl); + refCl->lookupMethod(utf8, sign->keyName, true, true, &methodCl); ctpInfo->ctpRes[index] = methodCl->getConstantPool(); shared->ctpRes[clIndex] = refCl->classDef; return (void*)methodCl->getConstantPool(); @@ -196,7 +195,7 @@ shared->resolveMethod(index, baseCl, utf8, sign); UserClass* methodCl = 0; - refCl->lookupMethod(utf8, sign->keyName, false, true, methodCl); + refCl->lookupMethod(utf8, sign->keyName, false, true, &methodCl); shared->ctpRes[clIndex] = refCl->classDef; *res = methodCl->getConstantPool(); return methodCl->getConstantPool(); @@ -213,9 +212,8 @@ Signdef* sign = 0; caller->getConstantPool()->resolveMethod(index, cl, utf8, sign); - UserClass* methodCl = 0; JavaMethod* dmeth = cl->lookupMethodDontThrow(utf8, sign->keyName, false, - true, methodCl); + true, 0); if (!dmeth) { va_list ap; va_start(ap, index); @@ -224,8 +222,7 @@ assert(obj->classOf->isReady() && "Class not ready in a virtual lookup."); // Arg, the bytecode is buggy! Perform the lookup on the object class // and do not update offset. - dmeth = obj->classOf->lookupMethod(utf8, sign->keyName, false, true, - methodCl); + dmeth = obj->classOf->lookupMethod(utf8, sign->keyName, false, true, 0); } else { caller->getConstantPool()->ctpRes[index] = (void*)dmeth->offset; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Fri Oct 24 04:44:42 2008 @@ -15,19 +15,21 @@ #include "JnjvmConfig.h" #define UPCALL_CLASS(vm, name) \ - vm->loadName(vm->asciizConstructUTF8(name), false, false) + vm->loadName(vm->asciizConstructUTF8(name), true, false) #define UPCALL_PRIMITIVE_CLASS(loader, name, nb) \ new(loader->allocator) \ UserClassPrimitive(loader, loader->asciizConstructUTF8(name), nb) \ #define UPCALL_FIELD(vm, cl, name, type, acc) \ - UPCALL_CLASS(vm, cl)->constructField(vm->asciizConstructUTF8(name), \ - vm->asciizConstructUTF8(type), acc) + UPCALL_CLASS(vm, cl)->lookupFieldDontThrow(vm->asciizConstructUTF8(name), \ + vm->asciizConstructUTF8(type), \ + isStatic(acc), false, 0) #define UPCALL_METHOD(vm, cl, name, type, acc) \ - UPCALL_CLASS(vm, cl)->constructMethod(vm->asciizConstructUTF8(name), \ - vm->asciizConstructUTF8(type), acc) + UPCALL_CLASS(vm, cl)->lookupMethodDontThrow(vm->asciizConstructUTF8(name), \ + vm->asciizConstructUTF8(type), \ + isStatic(acc), false, 0) #define UPCALL_ARRAY_CLASS(loader, name, depth) \ loader->constructArray( \ @@ -40,14 +42,14 @@ name = UPCALL_CLASS(loader, "java/lang/reflect/"#name) #define UPCALL_METHOD_EXCEPTION(loader, name) \ - Init##name = name->constructMethod(loader->asciizConstructUTF8(""), \ - loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \ - ACC_VIRTUAL); + Init##name = name->lookupMethodDontThrow(loader->asciizConstructUTF8(""), \ + loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \ + false, false, 0); #define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \ - ErrorWithExcp##name = name->constructMethod(loader->asciizConstructUTF8(""), \ + ErrorWithExcp##name = name->lookupMethodDontThrow(loader->asciizConstructUTF8(""), \ loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \ - ACC_VIRTUAL); + false, false, 0); 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=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Fri Oct 24 04:44:42 2008 @@ -158,10 +158,9 @@ UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); if (cl->isArray()) assert(0 && "implement me"); JavaObject* res = ((UserClass*)cl)->doNew(vm); - UserClass* methodCl = 0; JavaMethod* init = cl->lookupMethod(Jnjvm::initName, cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"), - false, true, methodCl); + false, true, 0); init->invokeIntSpecial(vm, (UserClass*)cl, res, vm->asciizToStr(msg)); th->pendingException = res; th->returnFromNative(); @@ -329,8 +328,7 @@ UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); const UTF8* name = vm->asciizToInternalUTF8(aname); const UTF8* type = vm->asciizToInternalUTF8(atype); - UserClass* methodCl = 0; - JavaMethod* meth = cl->lookupMethod(name, type, false, true, methodCl); + JavaMethod* meth = cl->lookupMethod(name, type, false, true, 0); return (jmethodID)meth; @@ -872,10 +870,9 @@ // TODO: find a better place to store the UTF8 Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); - UserCommonClass* realCl = 0; return (jfieldID) cl->lookupField(cl->classLoader->asciizConstructUTF8(name), - cl->classLoader->asciizConstructUTF8(sig), 0, 1, realCl); + cl->classLoader->asciizConstructUTF8(sig), 0, 1, 0); END_EXCEPTION return 0; @@ -1118,8 +1115,7 @@ UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); const UTF8* name = vm->asciizToInternalUTF8(aname); const UTF8* type = vm->asciizToInternalUTF8(atype); - UserClass* methodCl = 0; - JavaMethod* meth = cl->lookupMethod(name, type, true, true, methodCl); + JavaMethod* meth = cl->lookupMethod(name, type, true, true, 0); return (jmethodID)meth; @@ -1369,11 +1365,10 @@ // TODO: find a better place to store the UTF8 Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); - UserCommonClass* realCl = 0; return (jfieldID) cl->lookupField(cl->classLoader->asciizConstructUTF8(name), cl->classLoader->asciizConstructUTF8(sig), true, true, - realCl); + 0); END_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=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Fri Oct 24 04:44:42 2008 @@ -112,10 +112,9 @@ cl->resolveStaticClass(); status = inClinit; - UserClass* methodCl; JavaMethod* meth = lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, - false, methodCl); + false, 0); PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0); PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "clinit ", 0); @@ -125,10 +124,9 @@ (JavaObject*)vm->gcAllocator.allocateManagedObject(cl->getStaticSize(), cl->getStaticVT()); val->initialise(cl); - CommonClass::field_map* map = cl->getStaticFields(); - for (CommonClass::field_iterator i = map->begin(), e = map->end(); i!= e; - ++i) { - i->second->initField(val, vm); + JavaField* fields = cl->getStaticFields(); + for (uint32 i = 0; i < cl->nbStaticFields; ++i) { + fields[i].initField(val, vm); } cl->setStaticInstance(val); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Fri Oct 24 04:44:42 2008 @@ -32,7 +32,7 @@ #ifndef ISOLATE_SHARING JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0; UserClass* JnjvmBootstrapLoader::SuperArray = 0; -std::vector JnjvmBootstrapLoader::InterfacesArray; +UserClass** JnjvmBootstrapLoader::InterfacesArray; #endif Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Fri Oct 24 04:44:42 2008 @@ -289,7 +289,7 @@ /// Classpath* upcalls; - ISOLATE_STATIC std::vector InterfacesArray; + ISOLATE_STATIC UserClass** InterfacesArray; ISOLATE_STATIC UserClass* SuperArray; }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Fri Oct 24 04:44:42 2008 @@ -213,8 +213,8 @@ #ifndef WITHOUT_VTABLE VirtualTable* JnjvmModule::allocateVT(Class* cl, - CommonClass::method_iterator meths) { - if (meths == cl->virtualMethods.end()) { + uint32 index) { + if (index == cl->nbVirtualMethods) { uint64 size = cl->virtualTableSize; mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator; VirtualTable* VT = (VirtualTable*)allocator.Allocate(size * sizeof(void*)); @@ -230,14 +230,14 @@ } return VT; } else { - JavaMethod* meth = meths->second; + JavaMethod& meth = cl->virtualMethods[index]; VirtualTable* VT = 0; - if (meth->name->equals(Jnjvm::finalize)) { - VT = allocateVT(cl, ++meths); + if (meth.name->equals(Jnjvm::finalize)) { + VT = allocateVT(cl, ++index); #ifndef ISOLATE_SHARING - meth->offset = 0; - Function* func = cl->classLoader->TheModuleProvider->parseFunction(meth); - if (!cl->super) meth->canBeInlined = true; + meth.offset = 0; + Function* func = cl->classLoader->TheModuleProvider->parseFunction(&meth); + if (!cl->super) meth.canBeInlined = true; Function::iterator BB = func->begin(); BasicBlock::iterator I = BB->begin(); if (isa(I)) { @@ -250,22 +250,21 @@ #endif } else { - Class* methodCl = 0; JavaMethod* parent = cl->super? - cl->super->lookupMethodDontThrow(meth->name, meth->type, false, true, - methodCl) : + cl->super->lookupMethodDontThrow(meth.name, meth.type, false, true, + 0) : 0; uint64_t offset = 0; if (!parent) { offset = cl->virtualTableSize++; - meth->offset = offset; + meth.offset = offset; } else { offset = parent->offset; - meth->offset = parent->offset; + meth.offset = parent->offset; } - VT = allocateVT(cl, ++meths); - LLVMMethodInfo* LMI = getMethodInfo(meth); + VT = allocateVT(cl, ++index); + LLVMMethodInfo* LMI = getMethodInfo(&meth); Function* func = LMI->getMethod(); ExecutionEngine* EE = mvm::MvmModule::executionEngine; ((void**)VT)[offset] = EE->getPointerToFunctionOrStub(func); @@ -293,7 +292,7 @@ } else { cl->virtualTableSize = VT_NB_FUNCS; } - res = allocateVT(cl, cl->virtualMethods.begin()); + res = allocateVT(cl, 0); if (!(cl->super)) { uint32 size = (cl->virtualTableSize - VT_NB_FUNCS) * sizeof(void*); @@ -315,7 +314,15 @@ #ifdef WITH_TRACER LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl); const Type* type = stat ? LCI->getStaticType() : LCI->getVirtualType(); - CommonClass::field_map& fields = stat ? cl->staticFields : cl->virtualFields; + JavaField* fields = 0; + uint32 nbFields = 0; + if (stat) { + fields = cl->getStaticFields(); + nbFields = cl->nbStaticFields; + } else { + fields = cl->getVirtualFields(); + nbFields = cl->nbVirtualFields; + } Function* func = Function::Create(JnjvmModule::MarkAndTraceType, GlobalValue::ExternalLinkage, @@ -348,10 +355,10 @@ } #endif - for (CommonClass::field_iterator i = fields.begin(), e = fields.end(); - i!= e; ++i) { - if (i->second->getSignature()->trace()) { - LLVMFieldInfo* LFI = getFieldInfo(i->second); + for (uint32 i = 0; i < nbFields; ++i) { + JavaField& cur = fields[i]; + if (cur.getSignature()->trace()) { + LLVMFieldInfo* LFI = getFieldInfo(&cur); std::vector args; //size = 2 args.push_back(zero); args.push_back(LFI->getOffset()); @@ -392,8 +399,6 @@ const Type* LLVMClassInfo::getVirtualType() { if (!virtualType) { std::vector fields; - JavaField** array = - (JavaField**)alloca(sizeof(JavaField*) * classDef->virtualFields.size()); if (classDef->super) { LLVMClassInfo* CLI = @@ -403,29 +408,24 @@ fields.push_back(JnjvmModule::JavaObjectType->getContainedType(0)); } - for (CommonClass::field_iterator i = classDef->virtualFields.begin(), - e = classDef->virtualFields.end(); i!= e; ++i) { - JavaField* field = i->second; - array[field->num] = field; - } - - - for (uint32 index = 0; index < classDef->virtualFields.size(); ++index) { - Typedef* type = array[index]->getSignature(); + for (uint32 i = 0; i < classDef->nbVirtualFields; ++i) { + JavaField& field = classDef->virtualFields[i]; + field.num = i; + Typedef* type = field.getSignature(); LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); fields.push_back(LAI.llvmType); } + StructType* structType = StructType::get(fields, false); virtualType = PointerType::getUnqual(structType); ExecutionEngine* engine = mvm::MvmModule::executionEngine; const TargetData* targetData = engine->getTargetData(); const StructLayout* sl = targetData->getStructLayout(structType); - for (CommonClass::field_iterator i = classDef->virtualFields.begin(), - e = classDef->virtualFields.end(); i!= e; ++i) { - JavaField* field = i->second; - field->ptrOffset = sl->getElementOffset(field->num + 1); + for (uint32 i = 0; i < classDef->nbVirtualFields; ++i) { + JavaField& field = classDef->virtualFields[i]; + field.ptrOffset = sl->getElementOffset(i + 1); } JnjvmModule* Mod = classDef->classLoader->TheModule; @@ -446,19 +446,12 @@ if (!staticType) { Class* cl = (Class*)classDef; std::vector fields; - JavaField** array = (JavaField**) - alloca(sizeof(JavaField*) * (classDef->staticFields.size() + 1)); fields.push_back(JnjvmModule::JavaObjectType->getContainedType(0)); - for (CommonClass::field_iterator i = classDef->staticFields.begin(), - e = classDef->staticFields.end(); i!= e; ++i) { - JavaField* field = i->second; - array[field->num] = field; - } - - for (uint32 index = 0; index < classDef->staticFields.size(); ++index) { - JavaField* field = array[index]; - Typedef* type = field->getSignature(); + for (uint32 i = 0; i < classDef->nbStaticFields; ++i) { + JavaField& field = classDef->staticFields[i]; + field.num = i; + Typedef* type = field.getSignature(); LLVMAssessorInfo& LAI = JnjvmModule::getTypedefInfo(type); fields.push_back(LAI.llvmType); } @@ -469,10 +462,9 @@ const TargetData* targetData = engine->getTargetData(); const StructLayout* sl = targetData->getStructLayout(structType); - for (CommonClass::field_iterator i = classDef->staticFields.begin(), - e = classDef->staticFields.end(); i!= e; ++i) { - JavaField* field = i->second; - field->ptrOffset = sl->getElementOffset(field->num + 1); + for (uint32 i = 0; i < classDef->nbStaticFields; ++i) { + JavaField& field = classDef->staticFields[i]; + field.ptrOffset = sl->getElementOffset(i + 1); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Fri Oct 24 04:44:42 2008 @@ -212,7 +212,7 @@ VirtualTable* makeVT(Class* cl, bool stat); - VirtualTable* allocateVT(Class* cl, CommonClass::method_iterator meths); + VirtualTable* allocateVT(Class* cl, uint32 index); public: Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Fri Oct 24 04:44:42 2008 @@ -37,9 +37,8 @@ Signdef* sign = 0; ctpInfo->resolveMethod(index, cl, utf8, sign); - Class* methodCl = 0; JavaMethod* meth = cl->lookupMethod(utf8, sign->keyName, isStatic, true, - methodCl); + 0); #ifndef ISOLATE_SHARING // A multi environment would have already initialized the class. Besides, Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=58087&r1=58086&r2=58087&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Fri Oct 24 04:44:42 2008 @@ -32,8 +32,6 @@ INIT(JavaArray); INIT(ArrayObject); - INIT(Class); - INIT(ClassArray); INIT(JavaObject); INIT(JavaThread); INIT(Jnjvm); @@ -70,10 +68,11 @@ (*i)->MARK_AND_TRACE; }} void CommonClass::TRACER { - if (super) super->classLoader->MARK_AND_TRACE; - for (std::vector >::iterator i = interfaces.begin(), - e = interfaces.end(); i!= e; ++i) { - (*i)->classLoader->MARK_AND_TRACE; + if (status >= prepared) { + if (super) super->classLoader->MARK_AND_TRACE; + for (uint32 i = 0; i < nbInterfaces; ++i) { + interfaces[i]->classLoader->MARK_AND_TRACE; + } } classLoader->MARK_AND_TRACE; #if !defined(ISOLATE) From nicolas.geoffray at lip6.fr Fri Oct 24 02:52:49 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Fri, 24 Oct 2008 09:52:49 -0000 Subject: [vmkit-commits] [vmkit] r58088 - /vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Message-ID: <200810240952.m9O9qn75018151@zion.cs.uiuc.edu> Author: geoffray Date: Fri Oct 24 04:52:49 2008 New Revision: 58088 URL: http://llvm.org/viewvc/llvm-project?rev=58088&view=rev Log: Don't make a lookup on meta java virtual calls. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=58088&r1=58087&r2=58088&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaMetaJIT.cpp Fri Oct 24 04:52:49 2008 @@ -145,10 +145,9 @@ } \ \ verifyNull(obj);\ - JavaMethod* meth = obj->classOf->lookupMethod(name, type, false, true, 0);\ \ Signdef* sign = getSignature(); \ - void* func = meth->compiledPtr();\ + void* func = (((void***)obj)[0])[offset];\ return ((FUNC_TYPE_VIRTUAL_BUF)sign->getVirtualCallBuf())(vm, cl->getConstantPool(), func, obj, buf);\ }\ \ From nicolas.geoffray at lip6.fr Sat Oct 25 12:08:56 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 25 Oct 2008 19:08:56 -0000 Subject: [vmkit-commits] [vmkit] r58147 - /vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Message-ID: <200810251908.m9PJ8u2F031021@zion.cs.uiuc.edu> Author: geoffray Date: Sat Oct 25 14:08:55 2008 New Revision: 58147 URL: http://llvm.org/viewvc/llvm-project?rev=58147&view=rev Log: Prune include. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58147&r1=58146&r2=58147&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sat Oct 25 14:08:55 2008 @@ -7,8 +7,6 @@ // //===----------------------------------------------------------------------===// -#include - #include "mvm/Allocator.h" #include "mvm/VirtualMachine.h" #include "mvm/Threads/Locks.h" From nicolas.geoffray at lip6.fr Sat Oct 25 13:16:33 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 25 Oct 2008 20:16:33 -0000 Subject: [vmkit-commits] [vmkit] r58149 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200810252016.m9PKGXEG000692@zion.cs.uiuc.edu> Author: geoffray Date: Sat Oct 25 15:16:32 2008 New Revision: 58149 URL: http://llvm.org/viewvc/llvm-project?rev=58149&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=58149&r1=58148&r2=58149&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Sat Oct 25 15:16:32 2008 @@ -19,7 +19,6 @@ #include "JnjvmModule.h" -#include using namespace llvm; using namespace jnjvm; From nicolas.geoffray at lip6.fr Sat Oct 25 15:08:42 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 25 Oct 2008 22:08:42 -0000 Subject: [vmkit-commits] [vmkit] r58159 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JavaJIT.h JnjvmModuleProvider.cpp Message-ID: <200810252208.m9PM8gtc003913@zion.cs.uiuc.edu> Author: geoffray Date: Sat Oct 25 17:08:42 2008 New Revision: 58159 URL: http://llvm.org/viewvc/llvm-project?rev=58159&view=rev Log: Code cleanup. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h 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=58159&r1=58158&r2=58159&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sat Oct 25 17:08:42 2008 @@ -488,8 +488,7 @@ } -Instruction* JavaJIT::inlineCompile(Function* parentFunction, - BasicBlock*& curBB, +Instruction* JavaJIT::inlineCompile(BasicBlock*& curBB, BasicBlock* endExBlock, std::vector& args) { PRINT_DEBUG(JNJVM_COMPILE, 1, COLOR_NORMAL, "inline compile %s\n", @@ -515,12 +514,10 @@ LLVMMethodInfo* LMI = module->getMethodInfo(compilingMethod); assert(LMI); Function* func = LMI->getMethod(); - llvmFunction = parentFunction; returnType = func->getReturnType(); endBlock = createBasicBlock("end"); - llvmFunction = parentFunction; currentBlock = curBB; endExceptionBlock = 0; @@ -1506,14 +1503,11 @@ Instruction* JavaJIT::invokeInline(JavaMethod* meth, std::vector& args) { - JavaJIT jit; - jit.compilingClass = meth->classDef; - jit.compilingMethod = meth; + JavaJIT jit(meth, llvmFunction); jit.unifiedUnreachable = unifiedUnreachable; jit.inlineMethods = inlineMethods; jit.inlineMethods[meth] = true; - jit.module = module; - Instruction* ret = jit.inlineCompile(llvmFunction, currentBlock, + Instruction* ret = jit.inlineCompile(currentBlock, currentExceptionBlock, args); inlineMethods[meth] = false; return ret; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=58159&r1=58158&r2=58159&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Sat Oct 25 17:08:42 2008 @@ -64,8 +64,12 @@ public: - JavaJIT() { + JavaJIT(JavaMethod* meth, llvm::Function* func) { nbEnveloppes = 0; + compilingMethod = meth; + compilingClass = meth->classDef; + module = compilingClass->classLoader->TheModule; + llvmFunction = func; } JnjvmModule* module; @@ -78,8 +82,7 @@ llvm::Function* javaCompile(); llvm::Function* nativeCompile(void* natPtr = 0); - llvm::Instruction* inlineCompile(llvm::Function* parentFunction, - llvm::BasicBlock*& curBB, + llvm::Instruction* inlineCompile(llvm::BasicBlock*& curBB, llvm::BasicBlock* endExBlock, std::vector& args); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=58159&r1=58158&r2=58159&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Sat Oct 25 17:08:42 2008 @@ -129,11 +129,7 @@ if (func->hasNotBeenReadFromBitcode()) { // We are jitting. Take the lock. llvm::MutexGuard locked(mvm::MvmModule::executionEngine->lock); - JavaJIT jit; - jit.compilingClass = meth->classDef; - jit.compilingMethod = meth; - jit.module = (JnjvmModule*)TheModule; - jit.llvmFunction = func; + JavaJIT jit(meth, func); if (isNative(meth->access)) { jit.nativeCompile(); } else { From nicolas.geoffray at lip6.fr Sat Oct 25 16:29:59 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 25 Oct 2008 23:29:59 -0000 Subject: [vmkit-commits] [vmkit] r58171 - /vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Message-ID: <200810252329.m9PNTxax006602@zion.cs.uiuc.edu> Author: geoffray Date: Sat Oct 25 18:29:59 2008 New Revision: 58171 URL: http://llvm.org/viewvc/llvm-project?rev=58171&view=rev Log: Initialize access when creating a class. 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=58171&r1=58170&r2=58171&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sat Oct 25 18:29:59 2008 @@ -91,6 +91,7 @@ nbVirtualMethods = 0; nbStaticMethods = 0; nbInterfaces = 0; + access = 0; } Class::Class() : CommonClass() { @@ -274,6 +275,7 @@ staticMethods = 0; virtualFields = 0; staticFields = 0; + access = 0; #if !defined(ISOLATE) && !defined(ISOLATE_SHARING) this->delegatee = 0; #endif From nicolas.geoffray at lip6.fr Sat Oct 25 16:30:41 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sat, 25 Oct 2008 23:30:41 -0000 Subject: [vmkit-commits] [vmkit] r58172 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Message-ID: <200810252330.m9PNUf2M006641@zion.cs.uiuc.edu> Author: geoffray Date: Sat Oct 25 18:30:41 2008 New Revision: 58172 URL: http://llvm.org/viewvc/llvm-project?rev=58172&view=rev Log: Inline of virtual calls (currently disabled). 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=58172&r1=58171&r2=58172&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sat Oct 25 18:30:41 2008 @@ -70,9 +70,33 @@ const llvm::FunctionType* virtualType = LSI->getVirtualType(); FunctionType::param_iterator it = virtualType->param_end(); makeArgs(it, index, args, signature->args.size() + 1); + const llvm::Type* retType = virtualType->getReturnType(); + + JITVerifyNull(args[0]); + BasicBlock* endBlock = 0; + PHINode* node = 0; + if (meth && !isAbstract(meth->access) && meth->canBeInlined && + meth != compilingMethod && inlineMethods[meth] == 0) { + Value* cl = CallInst::Create(module->GetClassFunction, args[0], "", + currentBlock); + Value* cl2 = module->getNativeClass((Class*)cl, this); + Value* test = new ICmpInst(ICmpInst::ICMP_EQ, cl, cl2, "", currentBlock); + + BasicBlock* trueBlock = createBasicBlock("true virtual invoke"); + BasicBlock* falseBlock = createBasicBlock("false virtual invoke"); + endBlock = createBasicBlock("end virtual invoke"); + BranchInst::Create(trueBlock, falseBlock, test, currentBlock); + currentBlock = trueBlock; + Value* res = invokeInline(meth, args); + BranchInst::Create(endBlock, currentBlock); + if (retType != Type::VoidTy) { + node = PHINode::Create(virtualType->getReturnType(), "", endBlock); + node->addIncoming(res, currentBlock); + } + currentBlock = falseBlock; + } - JITVerifyNull(args[0]); Value* VT = CallInst::Create(module->GetVTFunction, args[0], "", currentBlock); @@ -117,7 +141,15 @@ #endif Value* val = invoke(Func, args, "", currentBlock); - const llvm::Type* retType = virtualType->getReturnType(); + if (endBlock) { + if (node) { + node->addIncoming(val, currentBlock); + val = node; + } + BranchInst::Create(endBlock, currentBlock); + currentBlock = endBlock; + } + if (retType != Type::VoidTy) { push(val, retTypedef->isUnsigned()); if (retType == Type::DoubleTy || retType == Type::Int64Ty) { From nicolas.geoffray at lip6.fr Sun Oct 26 09:25:28 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 16:25:28 -0000 Subject: [vmkit-commits] [vmkit] r58186 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaInitialise.cpp JavaJIT.cpp JavaJIT.h Jnjvm.cpp Jnjvm.h Message-ID: <200810261625.m9QGPTZQ011047@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 11:25:28 2008 New Revision: 58186 URL: http://llvm.org/viewvc/llvm-project?rev=58186&view=rev Log: Don't inline functions that call the VMStackWalker. Modified: 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/JavaJIT.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=58186&r1=58185&r2=58186&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sun Oct 26 11:25:28 2008 @@ -663,6 +663,7 @@ method.canBeInlined = false; method.offset = 0; method.JInfo = 0; + method.enveloppes = 0; return &method; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58186&r1=58185&r2=58186&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sun Oct 26 11:25:28 2008 @@ -194,6 +194,7 @@ Jnjvm::postlib = JCL->asciizConstructUTF8(".so"); #endif Jnjvm::mathName = JCL->asciizConstructUTF8("java/lang/Math"); + Jnjvm::stackWalkerName = JCL->asciizConstructUTF8("gnu/classpath/VMStackWalker"); Jnjvm::NoClassDefFoundError = JCL->asciizConstructUTF8("java/lang/NoClassDefFoundError"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=58186&r1=58185&r2=58186&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sun Oct 26 11:25:28 2008 @@ -50,6 +50,12 @@ using namespace jnjvm; using namespace llvm; +bool JavaJIT::canBeInlined(JavaMethod* meth) { + return (meth->canBeInlined && + meth != compilingMethod && inlineMethods[meth] == 0 && + meth->classDef->classLoader == compilingClass->classLoader); +} + void JavaJIT::invokeVirtual(uint16 index) { JavaConstantPool* ctpInfo = compilingClass->ctpInfo; @@ -75,8 +81,7 @@ JITVerifyNull(args[0]); BasicBlock* endBlock = 0; PHINode* node = 0; - if (meth && !isAbstract(meth->access) && meth->canBeInlined && - meth != compilingMethod && inlineMethods[meth] == 0) { + if (meth && !isAbstract(meth->access) && canBeInlined(meth)) { Value* cl = CallInst::Create(module->GetClassFunction, args[0], "", currentBlock); Value* cl2 = module->getNativeClass((Class*)cl, this); @@ -644,7 +649,7 @@ #endif exploreOpcodes(&compilingClass->bytes->elements[start], codeLen); - + nbEnveloppes = 0; if (returnType != Type::VoidTy) { endNode = llvm::PHINode::Create(returnType, "", endBlock); @@ -684,7 +689,7 @@ PRINT_DEBUG(JNJVM_COMPILE, 1, COLOR_NORMAL, "compiling %s\n", compilingMethod->printString()); - + Attribut* codeAtt = compilingMethod->lookupAttribut(Attribut::codeAttribut); if (!codeAtt) { @@ -916,7 +921,7 @@ PRINT_DEBUG(JNJVM_COMPILE, 1, COLOR_NORMAL, "--> end compiling %s\n", compilingMethod->printString()); - if (nbe == 0 && codeLen < 50) + if (nbe == 0 && codeLen < 50 && !callsStackWalker) compilingMethod->canBeInlined = false; return llvmFunction; @@ -1539,6 +1544,7 @@ jit.unifiedUnreachable = unifiedUnreachable; jit.inlineMethods = inlineMethods; jit.inlineMethods[meth] = true; + jit.inlining = true; Instruction* ret = jit.inlineCompile(currentBlock, currentExceptionBlock, args); inlineMethods[meth] = false; @@ -1596,8 +1602,7 @@ (Function*)ctpInfo->infoOfStaticOrSpecialMethod(index, ACC_VIRTUAL, signature, meth); - if (meth && meth->canBeInlined && meth != compilingMethod && - inlineMethods[meth] == 0) { + if (meth && canBeInlined(meth)) { val = invokeInline(meth, args); } else { val = invoke(func, args, "", currentBlock); @@ -1635,6 +1640,10 @@ val = lowerMathOps(name, args); } + if (cl->equals(Jnjvm::stackWalkerName)) { + callsStackWalker = true; + } + if (!val) { Function* func = (Function*) ctpInfo->infoOfStaticOrSpecialMethod(index, ACC_STATIC, @@ -1648,8 +1657,7 @@ args.push_back(newCtpCache); #endif - if (meth && meth->canBeInlined && meth != compilingMethod && - inlineMethods[meth] == 0) { + if (meth && canBeInlined(meth)) { val = invokeInline(meth, args); } else { val = invoke(func, args, "", currentBlock); @@ -2050,7 +2058,8 @@ #ifndef ISOLATE_SHARING // ok now the cache Enveloppe& enveloppe = compilingMethod->enveloppes[nbEnveloppes++]; - enveloppe.initialise(compilingClass->ctpInfo, index); + if (!inlining) + enveloppe.initialise(compilingClass->ctpInfo, index); Value* llvmEnv = module->getEnveloppe(&enveloppe, this); #else Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=58186&r1=58185&r2=58186&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Sun Oct 26 11:25:28 2008 @@ -70,6 +70,8 @@ compilingClass = meth->classDef; module = compilingClass->classLoader->TheModule; llvmFunction = func; + inlining = false; + callsStackWalker = false; } JnjvmModule* module; @@ -87,6 +89,7 @@ std::vector& args); std::map inlineMethods; + bool inlining; Class* compilingClass; JavaMethod* compilingMethod; @@ -277,6 +280,9 @@ /// nbEnveloppes - Number of enveloppes (ie invokeinterface) in this /// method. uint32 nbEnveloppes; + + bool canBeInlined(JavaMethod* meth); + bool callsStackWalker; }; enum Opcode { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58186&r1=58185&r2=58186&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 26 11:25:28 2008 @@ -51,6 +51,7 @@ DEF_UTF8(prelib); DEF_UTF8(postlib); DEF_UTF8(mathName); + DEF_UTF8(stackWalkerName); DEF_UTF8(abs); DEF_UTF8(sqrt); DEF_UTF8(sin); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=58186&r1=58185&r2=58186&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sun Oct 26 11:25:28 2008 @@ -183,6 +183,7 @@ static const UTF8* prelib; static const UTF8* postlib; static const UTF8* mathName; + static const UTF8* stackWalkerName; static const UTF8* abs; static const UTF8* sqrt; static const UTF8* sin; From nicolas.geoffray at lip6.fr Sun Oct 26 10:13:01 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 17:13:01 -0000 Subject: [vmkit-commits] [vmkit] r58188 - in /vmkit/trunk/lib/JnJVM: Classpath/Classpath.cpp Classpath/ClasspathVMRuntime.cpp VMCore/JavaClass.cpp VMCore/JavaInitialise.cpp VMCore/JavaJIT.cpp VMCore/Jni.cpp VMCore/Jnjvm.cpp VMCore/Jnjvm.h VMCore/JnjvmClassLoader.cpp VMCore/JnjvmClassLoader.h VMCore/JnjvmModule.cpp Message-ID: <200810261713.m9QHD1Is012560@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 12:12:59 2008 New Revision: 58188 URL: http://llvm.org/viewvc/llvm-project?rev=58188&view=rev Log: Move internal UTF8s used by JnJVM to the BootstrapClassLoader. Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp 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/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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/Classpath.cpp Sun Oct 26 12:12:59 2008 @@ -32,7 +32,8 @@ verifyNull(Cl); Jnjvm* vm = JavaThread::get()->isolate; UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, Cl, true); - if (cl->lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, + if (cl->lookupMethodDontThrow(vm->bootstrapLoader->clinitName, + vm->bootstrapLoader->clinitType, true, false, 0)) return true; Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Sun Oct 26 12:12:59 2008 @@ -44,17 +44,18 @@ const UTF8* utf8Lib = strLib->value; uint32 stLib = strLib->offset; sint32 lgLib = strLib->count; - sint32 lgPre = vm->prelib->size; - sint32 lgPost = vm->postlib->size; + sint32 lgPre = vm->bootstrapLoader->prelib->size; + sint32 lgPost = vm->bootstrapLoader->postlib->size; uint32 size = (uint32)(lgPre + lgLib + lgPost); ArrayUInt16* array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm); uint16* elements = array->elements; - memmove(elements, vm->prelib->elements, lgPre * sizeof(uint16)); + memmove(elements, vm->bootstrapLoader->prelib->elements, + lgPre * sizeof(uint16)); memmove(&(elements[lgPre]), &(utf8Lib->elements[stLib]), lgLib * sizeof(uint16)); - memmove(&(elements[lgPre + lgLib]), vm->postlib->elements, + memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements, lgPost * sizeof(uint16)); return (jobject)(vm->UTF8ToStr((const UTF8*)array)); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sun Oct 26 12:12:59 2008 @@ -897,7 +897,8 @@ for (uint32 i = 0; i < nbVirtualMethods; ++i) { JavaMethod* meth = &virtualMethods[i]; bool pub = isPublic(meth->access); - if (meth->name->equals(Jnjvm::initName) && (!publicOnly || pub)) { + if (meth->name->equals(classLoader->bootstrapLoader->initName) && + (!publicOnly || pub)) { res.push_back(meth); } } @@ -908,7 +909,8 @@ for (uint32 i = 0; i < nbVirtualMethods; ++i) { JavaMethod* meth = &virtualMethods[i]; bool pub = isPublic(meth->access); - if (!(meth->name->equals(Jnjvm::initName)) && (!publicOnly || pub)) { + if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) && + (!publicOnly || pub)) { res.push_back(meth); } } @@ -916,7 +918,8 @@ for (uint32 i = 0; i < nbStaticMethods; ++i) { JavaMethod* meth = &staticMethods[i]; bool pub = isPublic(meth->access); - if (!(meth->name->equals(Jnjvm::clinitName)) && (!publicOnly || pub)) { + if (!(meth->name->equals(classLoader->bootstrapLoader->clinitName)) && + (!publicOnly || pub)) { res.push_back(meth); } } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sun Oct 26 12:12:59 2008 @@ -183,23 +183,23 @@ Attribut::innerClassesAttribut = JCL->asciizConstructUTF8("InnerClasses"); Attribut::sourceFileAttribut = JCL->asciizConstructUTF8("SourceFile"); - Jnjvm::initName = JCL->asciizConstructUTF8(""); - Jnjvm::clinitName = JCL->asciizConstructUTF8(""); - Jnjvm::clinitType = JCL->asciizConstructUTF8("()V"); - Jnjvm::runName = JCL->asciizConstructUTF8("run"); - Jnjvm::prelib = JCL->asciizConstructUTF8("lib"); + JCL->initName = JCL->asciizConstructUTF8(""); + JCL->clinitName = JCL->asciizConstructUTF8(""); + JCL->clinitType = JCL->asciizConstructUTF8("()V"); + JCL->runName = JCL->asciizConstructUTF8("run"); + JCL->prelib = JCL->asciizConstructUTF8("lib"); #if defined(__MACH__) - Jnjvm::postlib = JCL->asciizConstructUTF8(".dylib"); + JCL->postlib = JCL->asciizConstructUTF8(".dylib"); #else - Jnjvm::postlib = JCL->asciizConstructUTF8(".so"); + JCL->postlib = JCL->asciizConstructUTF8(".so"); #endif - Jnjvm::mathName = JCL->asciizConstructUTF8("java/lang/Math"); - Jnjvm::stackWalkerName = JCL->asciizConstructUTF8("gnu/classpath/VMStackWalker"); - Jnjvm::NoClassDefFoundError = + JCL->mathName = JCL->asciizConstructUTF8("java/lang/Math"); + JCL->stackWalkerName = JCL->asciizConstructUTF8("gnu/classpath/VMStackWalker"); + JCL->NoClassDefFoundError = JCL->asciizConstructUTF8("java/lang/NoClassDefFoundError"); #define DEF_UTF8(var) \ - Jnjvm::var = JCL->asciizConstructUTF8(#var) + JCL->var = JCL->asciizConstructUTF8(#var) DEF_UTF8(abs); DEF_UTF8(sqrt); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sun Oct 26 12:12:59 2008 @@ -1430,7 +1430,8 @@ Instruction* JavaJIT::lowerMathOps(const UTF8* name, std::vector& args) { - if (name->equals(Jnjvm::abs)) { + JnjvmBootstrapLoader* loader = compilingClass->classLoader->bootstrapLoader; + if (name->equals(loader->abs)) { const Type* Ty = args[0]->getType(); if (Ty == Type::Int32Ty) { Constant* const_int32_9 = module->constantZero; @@ -1464,71 +1465,71 @@ return llvm::CallInst::Create(module->func_llvm_fabs_f64, args[0], "tmp1", currentBlock); } - } else if (name->equals(Jnjvm::sqrt)) { + } else if (name->equals(loader->sqrt)) { return llvm::CallInst::Create(module->func_llvm_sqrt_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::sin)) { + } else if (name->equals(loader->sin)) { return llvm::CallInst::Create(module->func_llvm_sin_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::cos)) { + } else if (name->equals(loader->cos)) { return llvm::CallInst::Create(module->func_llvm_cos_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::tan)) { + } else if (name->equals(loader->tan)) { return llvm::CallInst::Create(module->func_llvm_tan_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::asin)) { + } else if (name->equals(loader->asin)) { return llvm::CallInst::Create(module->func_llvm_asin_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::acos)) { + } else if (name->equals(loader->acos)) { return llvm::CallInst::Create(module->func_llvm_acos_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::atan)) { + } else if (name->equals(loader->atan)) { return llvm::CallInst::Create(module->func_llvm_atan_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::atan2)) { + } else if (name->equals(loader->atan2)) { return llvm::CallInst::Create(module->func_llvm_atan2_f64, args.begin(), args.end(), "tmp1", currentBlock); - } else if (name->equals(Jnjvm::exp)) { + } else if (name->equals(loader->exp)) { return llvm::CallInst::Create(module->func_llvm_exp_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::log)) { + } else if (name->equals(loader->log)) { return llvm::CallInst::Create(module->func_llvm_log_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::pow)) { + } else if (name->equals(loader->pow)) { return llvm::CallInst::Create(module->func_llvm_pow_f64, args.begin(), args.end(), "tmp1", currentBlock); - } else if (name->equals(Jnjvm::ceil)) { + } else if (name->equals(loader->ceil)) { return llvm::CallInst::Create(module->func_llvm_ceil_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::floor)) { + } else if (name->equals(loader->floor)) { return llvm::CallInst::Create(module->func_llvm_floor_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::rint)) { + } else if (name->equals(loader->rint)) { return llvm::CallInst::Create(module->func_llvm_rint_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::cbrt)) { + } else if (name->equals(loader->cbrt)) { return llvm::CallInst::Create(module->func_llvm_cbrt_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::cosh)) { + } else if (name->equals(loader->cosh)) { return llvm::CallInst::Create(module->func_llvm_cosh_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::expm1)) { + } else if (name->equals(loader->expm1)) { return llvm::CallInst::Create(module->func_llvm_expm1_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::hypot)) { + } else if (name->equals(loader->hypot)) { return llvm::CallInst::Create(module->func_llvm_hypot_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::log10)) { + } else if (name->equals(loader->log10)) { return llvm::CallInst::Create(module->func_llvm_log10_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::log1p)) { + } else if (name->equals(loader->log1p)) { return llvm::CallInst::Create(module->func_llvm_log1p_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::sinh)) { + } else if (name->equals(loader->sinh)) { return llvm::CallInst::Create(module->func_llvm_sinh_f64, args[0], "tmp1", currentBlock); - } else if (name->equals(Jnjvm::tanh)) { + } else if (name->equals(loader->tanh)) { return llvm::CallInst::Create(module->func_llvm_tanh_f64, args[0], "tmp1", currentBlock); } @@ -1567,7 +1568,7 @@ makeArgs(it, index, args, signature->args.size() + 1); JITVerifyNull(args[0]); - if (cl->equals(Jnjvm::mathName)) { + if (cl->equals(compilingClass->classLoader->bootstrapLoader->mathName)) { val = lowerMathOps(name, args); } @@ -1636,11 +1637,12 @@ makeArgs(it, index, args, signature->args.size()); ctpInfo->markAsStaticCall(index); - if (cl->equals(Jnjvm::mathName)) { + JnjvmBootstrapLoader* loader = compilingClass->classLoader->bootstrapLoader; + if (cl->equals(loader->mathName)) { val = lowerMathOps(name, args); } - if (cl->equals(Jnjvm::stackWalkerName)) { + if (cl->equals(loader->stackWalkerName)) { callsStackWalker = true; } Modified: vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jni.cpp Sun Oct 26 12:12:59 2008 @@ -158,7 +158,7 @@ UserCommonClass* cl = NativeUtil::resolvedImplClass(vm, clazz, true); if (cl->isArray()) assert(0 && "implement me"); JavaObject* res = ((UserClass*)cl)->doNew(vm); - JavaMethod* init = cl->lookupMethod(Jnjvm::initName, + JavaMethod* init = cl->lookupMethod(vm->bootstrapLoader->initName, cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"), false, true, 0); init->invokeIntSpecial(vm, (UserClass*)cl, res, vm->asciizToStr(msg)); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 26 12:12:59 2008 @@ -40,45 +40,6 @@ using namespace jnjvm; -#define DEF_UTF8(var) \ - const UTF8* Jnjvm::var = 0 - - DEF_UTF8(NoClassDefFoundError); - DEF_UTF8(initName); - DEF_UTF8(clinitName); - DEF_UTF8(clinitType); - DEF_UTF8(runName); - DEF_UTF8(prelib); - DEF_UTF8(postlib); - DEF_UTF8(mathName); - DEF_UTF8(stackWalkerName); - DEF_UTF8(abs); - DEF_UTF8(sqrt); - DEF_UTF8(sin); - DEF_UTF8(cos); - DEF_UTF8(tan); - DEF_UTF8(asin); - DEF_UTF8(acos); - DEF_UTF8(atan); - DEF_UTF8(atan2); - DEF_UTF8(exp); - DEF_UTF8(log); - DEF_UTF8(pow); - DEF_UTF8(ceil); - DEF_UTF8(floor); - DEF_UTF8(rint); - DEF_UTF8(cbrt); - DEF_UTF8(cosh); - DEF_UTF8(expm1); - DEF_UTF8(hypot); - DEF_UTF8(log10); - DEF_UTF8(log1p); - DEF_UTF8(sinh); - DEF_UTF8(tanh); - DEF_UTF8(finalize); - -#undef DEF_UTF8 - const char* Jnjvm::dirSeparator = "/"; const char* Jnjvm::envSeparator = ":"; const unsigned int Jnjvm::Magic = 0xcafebabe; @@ -113,9 +74,9 @@ cl->resolveStaticClass(); status = inClinit; - JavaMethod* meth = lookupMethodDontThrow(Jnjvm::clinitName, - Jnjvm::clinitType, true, - false, 0); + JavaMethod* meth = lookupMethodDontThrow(vm->bootstrapLoader->clinitName, + vm->bootstrapLoader->clinitType, + true, false, 0); PRINT_DEBUG(JNJVM_LOAD, 0, COLOR_NORMAL, "; ", 0); PRINT_DEBUG(JNJVM_LOAD, 0, LIGHT_GREEN, "clinit ", 0); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sun Oct 26 12:12:59 2008 @@ -173,41 +173,6 @@ /// Magic - The magic number at the beginning of each .class file. 0xcafebabe. /// static const unsigned int Magic; - - /// Lists of UTF8s used internaly in VMKit. - static const UTF8* NoClassDefFoundError; - static const UTF8* initName; - static const UTF8* clinitName; - static const UTF8* clinitType; - static const UTF8* runName; - static const UTF8* prelib; - static const UTF8* postlib; - static const UTF8* mathName; - static const UTF8* stackWalkerName; - static const UTF8* abs; - static const UTF8* sqrt; - static const UTF8* sin; - static const UTF8* cos; - static const UTF8* tan; - static const UTF8* asin; - static const UTF8* acos; - static const UTF8* atan; - static const UTF8* atan2; - static const UTF8* exp; - static const UTF8* log; - static const UTF8* pow; - static const UTF8* ceil; - static const UTF8* floor; - static const UTF8* rint; - static const UTF8* cbrt; - static const UTF8* cosh; - static const UTF8* expm1; - static const UTF8* hypot; - static const UTF8* log10; - static const UTF8* log1p; - static const UTF8* sinh; - static const UTF8* tanh; - static const UTF8* finalize; /// bootstraLoader - Bootstrap loader for base classes of this virtual /// machine. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 12:12:59 2008 @@ -166,7 +166,7 @@ if (!cl && doThrow) { Jnjvm* vm = JavaThread::get()->isolate; - if (!(name->equals(Jnjvm::NoClassDefFoundError))) { + if (!(name->equals(bootstrapLoader->NoClassDefFoundError))) { vm->unknownError("Unable to load NoClassDefFoundError"); } vm->noClassDefFoundError("unable to load %s", name->printString()); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sun Oct 26 12:12:59 2008 @@ -291,6 +291,43 @@ ISOLATE_STATIC UserClass** InterfacesArray; ISOLATE_STATIC UserClass* SuperArray; + + + /// Lists of UTF8s used internaly in VMKit. + const UTF8* NoClassDefFoundError; + const UTF8* initName; + const UTF8* clinitName; + const UTF8* clinitType; + const UTF8* runName; + const UTF8* prelib; + const UTF8* postlib; + const UTF8* mathName; + const UTF8* stackWalkerName; + const UTF8* abs; + const UTF8* sqrt; + const UTF8* sin; + const UTF8* cos; + const UTF8* tan; + const UTF8* asin; + const UTF8* acos; + const UTF8* atan; + const UTF8* atan2; + const UTF8* exp; + const UTF8* log; + const UTF8* pow; + const UTF8* ceil; + const UTF8* floor; + const UTF8* rint; + const UTF8* cbrt; + const UTF8* cosh; + const UTF8* expm1; + const UTF8* hypot; + const UTF8* log10; + const UTF8* log1p; + const UTF8* sinh; + const UTF8* tanh; + const UTF8* finalize; + }; } // end namespace jnjvm Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58188&r1=58187&r2=58188&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Sun Oct 26 12:12:59 2008 @@ -232,7 +232,7 @@ } else { JavaMethod& meth = cl->virtualMethods[index]; VirtualTable* VT = 0; - if (meth.name->equals(Jnjvm::finalize)) { + if (meth.name->equals(cl->classLoader->bootstrapLoader->finalize)) { VT = allocateVT(cl, ++index); #ifndef ISOLATE_SHARING meth.offset = 0; From nicolas.geoffray at lip6.fr Sun Oct 26 10:25:28 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 17:25:28 -0000 Subject: [vmkit-commits] [vmkit] r58190 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaInitialise.cpp JnjvmClassLoader.cpp Message-ID: <200810261725.m9QHPSvh012960@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 12:25:28 2008 New Revision: 58190 URL: http://llvm.org/viewvc/llvm-project?rev=58190&view=rev Log: Remove initialisation from Jnjvm to bootstrapLoader. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58190&r1=58189&r2=58190&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sun Oct 26 12:25:28 2008 @@ -83,150 +83,7 @@ } #endif - JnjvmBootstrapLoader* JCL = bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); - - // Create the name of char arrays. - const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C"); - - // Create the base class of char arrays. - JCL->upcalls->OfChar = UPCALL_PRIMITIVE_CLASS(JCL, "char", 2); - - // Create the char array. - JCL->upcalls->ArrayOfChar = JCL->constructArray(utf8OfChar, - JCL->upcalls->OfChar); - - // Alright, now we can repair the damage: set the class to the UTF8s created - // and set the array class of UTF8s. - ((UTF8*)utf8OfChar)->classOf = JCL->upcalls->ArrayOfChar; - ((UTF8*)JCL->upcalls->OfChar->name)->classOf = JCL->upcalls->ArrayOfChar; - JCL->hashUTF8->array = JCL->upcalls->ArrayOfChar; - - // Create the byte array, so that bytes for classes can be created. - JCL->upcalls->OfByte = UPCALL_PRIMITIVE_CLASS(JCL, "byte", 1); - JCL->upcalls->ArrayOfByte = - JCL->constructArray(JCL->asciizConstructUTF8("[B"), JCL->upcalls->OfByte); - - JCL->InterfacesArray = - (Class**)JCL->allocator.Allocate(2 * sizeof(UserClass*)); - - // Now we can create the super and interfaces of arrays. - JCL->InterfacesArray[0] = - JCL->loadName(JCL->asciizConstructUTF8("java/lang/Cloneable"), false, - false); - - JCL->InterfacesArray[1] = - JCL->loadName(JCL->asciizConstructUTF8("java/io/Serializable"), false, - false); - - JCL->SuperArray = - JCL->loadName(JCL->asciizConstructUTF8("java/lang/Object"), false, - false); - -#ifdef ISOLATE_SHARING - if (!ClassArray::SuperArray) { - ClassArray::SuperArray = JCL->SuperArray->classDef; - ClassArray::InterfacesArray[0] = ((Class*)JCL->InterfacesArray[0]->classDef); - ClassArray::InterfacesArray[1] = ((Class*)JCL->InterfacesArray[1]->classDef); - } -#else - ClassArray::SuperArray = JCL->SuperArray; - ClassArray::InterfacesArray = JCL->InterfacesArray; -#endif - - // And repair the damage: set the interfaces and super of array classes already - // created. - JCL->upcalls->ArrayOfChar->setInterfaces(JCL->InterfacesArray); - JCL->upcalls->ArrayOfChar->setSuper(JCL->SuperArray); - JCL->upcalls->ArrayOfByte->setInterfaces(JCL->InterfacesArray); - JCL->upcalls->ArrayOfByte->setSuper(JCL->SuperArray); - - // Yay, create the other primitive types. - JCL->upcalls->OfBool = UPCALL_PRIMITIVE_CLASS(JCL, "boolean", 1); - JCL->upcalls->OfShort = UPCALL_PRIMITIVE_CLASS(JCL, "short", 2); - JCL->upcalls->OfInt = UPCALL_PRIMITIVE_CLASS(JCL, "int", 4); - JCL->upcalls->OfLong = UPCALL_PRIMITIVE_CLASS(JCL, "long", 8); - JCL->upcalls->OfFloat = UPCALL_PRIMITIVE_CLASS(JCL, "float", 4); - JCL->upcalls->OfDouble = UPCALL_PRIMITIVE_CLASS(JCL, "double", 8); - JCL->upcalls->OfVoid = UPCALL_PRIMITIVE_CLASS(JCL, "void", 0); - - // And finally create the primitive arrays. - JCL->upcalls->ArrayOfInt = - JCL->constructArray(JCL->asciizConstructUTF8("[I"), JCL->upcalls->OfInt); - - JCL->upcalls->ArrayOfBool = - JCL->constructArray(JCL->asciizConstructUTF8("[Z"), JCL->upcalls->OfBool); - - JCL->upcalls->ArrayOfLong = - JCL->constructArray(JCL->asciizConstructUTF8("[J"), JCL->upcalls->OfLong); - - JCL->upcalls->ArrayOfFloat = - JCL->constructArray(JCL->asciizConstructUTF8("[F"), JCL->upcalls->OfFloat); - - JCL->upcalls->ArrayOfDouble = - JCL->constructArray(JCL->asciizConstructUTF8("[D"), JCL->upcalls->OfDouble); - - JCL->upcalls->ArrayOfShort = - JCL->constructArray(JCL->asciizConstructUTF8("[S"), JCL->upcalls->OfShort); - - JCL->upcalls->ArrayOfString = - JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;")); - - JCL->upcalls->ArrayOfObject = - JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;")); - - - Attribut::codeAttribut = JCL->asciizConstructUTF8("Code"); - Attribut::exceptionsAttribut = JCL->asciizConstructUTF8("Exceptions"); - Attribut::constantAttribut = JCL->asciizConstructUTF8("ConstantValue"); - Attribut::lineNumberTableAttribut = - JCL->asciizConstructUTF8("LineNumberTable"); - Attribut::innerClassesAttribut = JCL->asciizConstructUTF8("InnerClasses"); - Attribut::sourceFileAttribut = JCL->asciizConstructUTF8("SourceFile"); - - JCL->initName = JCL->asciizConstructUTF8(""); - JCL->clinitName = JCL->asciizConstructUTF8(""); - JCL->clinitType = JCL->asciizConstructUTF8("()V"); - JCL->runName = JCL->asciizConstructUTF8("run"); - JCL->prelib = JCL->asciizConstructUTF8("lib"); -#if defined(__MACH__) - JCL->postlib = JCL->asciizConstructUTF8(".dylib"); -#else - JCL->postlib = JCL->asciizConstructUTF8(".so"); -#endif - JCL->mathName = JCL->asciizConstructUTF8("java/lang/Math"); - JCL->stackWalkerName = JCL->asciizConstructUTF8("gnu/classpath/VMStackWalker"); - JCL->NoClassDefFoundError = - JCL->asciizConstructUTF8("java/lang/NoClassDefFoundError"); - -#define DEF_UTF8(var) \ - JCL->var = JCL->asciizConstructUTF8(#var) - - DEF_UTF8(abs); - DEF_UTF8(sqrt); - DEF_UTF8(sin); - DEF_UTF8(cos); - DEF_UTF8(tan); - DEF_UTF8(asin); - DEF_UTF8(acos); - DEF_UTF8(atan); - DEF_UTF8(atan2); - DEF_UTF8(exp); - DEF_UTF8(log); - DEF_UTF8(pow); - DEF_UTF8(ceil); - DEF_UTF8(floor); - DEF_UTF8(rint); - DEF_UTF8(cbrt); - DEF_UTF8(cosh); - DEF_UTF8(expm1); - DEF_UTF8(hypot); - DEF_UTF8(log10); - DEF_UTF8(log1p); - DEF_UTF8(sinh); - DEF_UTF8(tanh); - DEF_UTF8(finalize); - -#undef DEF_UTF8 + bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); } void mvm::VirtualMachine::initialiseJVM() { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58190&r1=58189&r2=58190&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 12:25:28 2008 @@ -64,6 +64,145 @@ upcalls = new(allocator) Classpath(); bootstrapLoader = this; + + + // Create the name of char arrays. + const UTF8* utf8OfChar = asciizConstructUTF8("[C"); + + // Create the base class of char arrays. + upcalls->OfChar = UPCALL_PRIMITIVE_CLASS(this, "char", 2); + + // Create the char array. + upcalls->ArrayOfChar = constructArray(utf8OfChar, upcalls->OfChar); + + // Alright, now we can repair the damage: set the class to the UTF8s created + // and set the array class of UTF8s. + ((UTF8*)utf8OfChar)->classOf = upcalls->ArrayOfChar; + ((UTF8*)upcalls->OfChar->name)->classOf = upcalls->ArrayOfChar; + hashUTF8->array = upcalls->ArrayOfChar; + + // Create the byte array, so that bytes for classes can be created. + upcalls->OfByte = UPCALL_PRIMITIVE_CLASS(this, "byte", 1); + upcalls->ArrayOfByte = constructArray(asciizConstructUTF8("[B"), + upcalls->OfByte); + + InterfacesArray = + (Class**)allocator.Allocate(2 * sizeof(UserClass*)); + + // Now we can create the super and interfaces of arrays. + InterfacesArray[0] = loadName(asciizConstructUTF8("java/lang/Cloneable"), + false, false); + + InterfacesArray[1] = loadName(asciizConstructUTF8("java/io/Serializable"), + false, false); + + SuperArray = loadName(asciizConstructUTF8("java/lang/Object"), false, + false); + +#ifdef ISOLATE_SHARING + if (!ClassArray::SuperArray) { + ClassArray::SuperArray = SuperArray->classDef; + ClassArray::InterfacesArray[0] = ((Class*)InterfacesArray[0]->classDef); + ClassArray::InterfacesArray[1] = ((Class*)InterfacesArray[1]->classDef); + } +#else + ClassArray::SuperArray = SuperArray; + ClassArray::InterfacesArray = InterfacesArray; +#endif + + // And repair the damage: set the interfaces and super of array classes already + // created. + upcalls->ArrayOfChar->setInterfaces(InterfacesArray); + upcalls->ArrayOfChar->setSuper(SuperArray); + upcalls->ArrayOfByte->setInterfaces(InterfacesArray); + upcalls->ArrayOfByte->setSuper(SuperArray); + + // Yay, create the other primitive types. + upcalls->OfBool = UPCALL_PRIMITIVE_CLASS(this, "boolean", 1); + upcalls->OfShort = UPCALL_PRIMITIVE_CLASS(this, "short", 2); + upcalls->OfInt = UPCALL_PRIMITIVE_CLASS(this, "int", 4); + upcalls->OfLong = UPCALL_PRIMITIVE_CLASS(this, "long", 8); + upcalls->OfFloat = UPCALL_PRIMITIVE_CLASS(this, "float", 4); + upcalls->OfDouble = UPCALL_PRIMITIVE_CLASS(this, "double", 8); + upcalls->OfVoid = UPCALL_PRIMITIVE_CLASS(this, "void", 0); + + // And finally create the primitive arrays. + upcalls->ArrayOfInt = constructArray(asciizConstructUTF8("[I"), + upcalls->OfInt); + + upcalls->ArrayOfBool = constructArray(asciizConstructUTF8("[Z"), + upcalls->OfBool); + + upcalls->ArrayOfLong = constructArray(asciizConstructUTF8("[J"), + upcalls->OfLong); + + upcalls->ArrayOfFloat = constructArray(asciizConstructUTF8("[F"), + upcalls->OfFloat); + + upcalls->ArrayOfDouble = constructArray(asciizConstructUTF8("[D"), + upcalls->OfDouble); + + upcalls->ArrayOfShort = constructArray(asciizConstructUTF8("[S"), + upcalls->OfShort); + + upcalls->ArrayOfString = + constructArray(asciizConstructUTF8("[Ljava/lang/String;")); + + upcalls->ArrayOfObject = + constructArray(asciizConstructUTF8("[Ljava/lang/Object;")); + + + Attribut::codeAttribut = asciizConstructUTF8("Code"); + Attribut::exceptionsAttribut = asciizConstructUTF8("Exceptions"); + Attribut::constantAttribut = asciizConstructUTF8("ConstantValue"); + Attribut::lineNumberTableAttribut = asciizConstructUTF8("LineNumberTable"); + Attribut::innerClassesAttribut = asciizConstructUTF8("InnerClasses"); + Attribut::sourceFileAttribut = asciizConstructUTF8("SourceFile"); + + initName = asciizConstructUTF8(""); + clinitName = asciizConstructUTF8(""); + clinitType = asciizConstructUTF8("()V"); + runName = asciizConstructUTF8("run"); + prelib = asciizConstructUTF8("lib"); +#if defined(__MACH__) + postlib = asciizConstructUTF8(".dylib"); +#else + postlib = asciizConstructUTF8(".so"); +#endif + mathName = asciizConstructUTF8("java/lang/Math"); + stackWalkerName = asciizConstructUTF8("gnu/classpath/VMStackWalker"); + NoClassDefFoundError = asciizConstructUTF8("java/lang/NoClassDefFoundError"); + +#define DEF_UTF8(var) \ + var = asciizConstructUTF8(#var) + + DEF_UTF8(abs); + DEF_UTF8(sqrt); + DEF_UTF8(sin); + DEF_UTF8(cos); + DEF_UTF8(tan); + DEF_UTF8(asin); + DEF_UTF8(acos); + DEF_UTF8(atan); + DEF_UTF8(atan2); + DEF_UTF8(exp); + DEF_UTF8(log); + DEF_UTF8(pow); + DEF_UTF8(ceil); + DEF_UTF8(floor); + DEF_UTF8(rint); + DEF_UTF8(cbrt); + DEF_UTF8(cosh); + DEF_UTF8(expm1); + DEF_UTF8(hypot); + DEF_UTF8(log10); + DEF_UTF8(log1p); + DEF_UTF8(sinh); + DEF_UTF8(tanh); + DEF_UTF8(finalize); + +#undef DEF_UTF8 + } JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, From nicolas.geoffray at lip6.fr Sun Oct 26 11:17:41 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 18:17:41 -0000 Subject: [vmkit-commits] [vmkit] r58192 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMRuntime.cpp VMCore/JavaInitialise.cpp VMCore/Jnjvm.cpp VMCore/Jnjvm.h VMCore/JnjvmClassLoader.cpp VMCore/JnjvmClassLoader.h VMCore/NativeUtil.cpp Message-ID: <200810261817.m9QIHfDn014415@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 13:17:39 2008 New Revision: 58192 URL: http://llvm.org/viewvc/llvm-project?rev=58192&view=rev Log: Code cleanup. Class loader reference the native libraries they loaded, not the virtual machine. Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp?rev=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp (original) +++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMRuntime.cpp Sun Oct 26 13:17:39 2008 @@ -73,12 +73,14 @@ jobject _loader) { JavaString* str = (JavaString*)_str; Jnjvm* vm = JavaThread::get()->isolate; - + JnjvmClassLoader* loader = + JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)_loader, vm); + char* buf = str->strToAsciiz(); void* res = dlopen(buf, RTLD_LAZY | RTLD_LOCAL); if (res != 0) { - vm->nativeLibs.push_back(res); + loader->nativeLibs.push_back(res); onLoad_t onLoad = (onLoad_t)(intptr_t)dlsym(res, "JNI_OnLoad"); if (onLoad) onLoad(&vm->javavmEnv, 0); return 1; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sun Oct 26 13:17:39 2008 @@ -7,26 +7,12 @@ // //===----------------------------------------------------------------------===// -#include "mvm/Allocator.h" #include "mvm/VirtualMachine.h" -#include "mvm/Threads/Locks.h" -#include "mvm/Threads/Thread.h" #include "JavaArray.h" -#include "JavaCache.h" -#include "JavaClass.h" -#include "JavaConstantPool.h" -#include "JavaJIT.h" #include "JavaObject.h" -#include "JavaString.h" #include "JavaThread.h" -#include "JavaTypes.h" -#include "JavaUpcalls.h" #include "Jnjvm.h" -#include "JnjvmModuleProvider.h" -#include "NativeUtil.h" -#include "LockedMap.h" -#include "Zip.h" #ifdef SERVICE_VM #include "ServiceDomain.h" @@ -75,35 +61,31 @@ #undef INIT } -void Jnjvm::initialiseStatics() { - #ifdef ISOLATE_SHARING +void mvm::VirtualMachine::initialiseJVM() { + initialiseVT(); if (!JnjvmSharedLoader::sharedLoader) { JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); } -#endif - - bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); } +mvm::VirtualMachine* mvm::VirtualMachine::createJVM() { + JnjvmBootstraLoader* bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); + Jnjvm* vm = gc_new(Jnjvm)(bootstrapLoader); + return vm; +} +#else + void mvm::VirtualMachine::initialiseJVM() { -#ifndef ISOLATE_SHARING + initialiseVT(); if (!JnjvmClassLoader::bootstrapLoader) { - initialiseVT(); - Jnjvm::initialiseStatics(); - JnjvmClassLoader::bootstrapLoader = Jnjvm::bootstrapLoader; + JnjvmClassLoader::bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); } -#else - initialiseVT(); -#endif } mvm::VirtualMachine* mvm::VirtualMachine::createJVM() { -#ifdef SERVICE_VM - ServiceDomain* vm = ServiceDomain::allocateService(); - vm->startExecution(); -#else - Jnjvm* vm = gc_new(Jnjvm)(0); -#endif + Jnjvm* vm = gc_new(Jnjvm)(JnjvmClassLoader::bootstrapLoader); return vm; } + +#endif Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 26 13:17:39 2008 @@ -45,9 +45,6 @@ const unsigned int Jnjvm::Magic = 0xcafebabe; #ifndef ISOLATE -/// If we're not in a multi-vm environment, this can be made static. -std::vector Jnjvm::nativeLibs; -JnjvmBootstrapLoader* Jnjvm::bootstrapLoader; std::map Jnjvm::primitiveMap; #endif @@ -789,7 +786,7 @@ } } -Jnjvm::Jnjvm(uint32 memLimit) { +Jnjvm::Jnjvm(JnjvmBootstrapLoader* loader) { classpath = getenv("CLASSPATH"); if (!classpath) classpath = "."; @@ -799,10 +796,7 @@ javavmEnv = &JNI_JavaVMTable; -#ifdef ISOLATE_SHARING - initialiseStatics(); -#endif - + bootstrapLoader = loader; upcalls = bootstrapLoader->upcalls; #ifdef ISOLATE_SHARING Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sun Oct 26 13:17:39 2008 @@ -21,7 +21,6 @@ #include "mvm/Threads/Cond.h" #include "mvm/Threads/Locks.h" -#include "JavaTypes.h" #include "JnjvmConfig.h" #include "LockedMap.h" @@ -177,7 +176,7 @@ /// bootstraLoader - Bootstrap loader for base classes of this virtual /// machine. /// - ISOLATE_STATIC JnjvmBootstrapLoader* bootstrapLoader; + JnjvmBootstrapLoader* bootstrapLoader; /// upcalls - Upcalls to call Java methods and access Java fields. /// @@ -200,10 +199,6 @@ /// std::vector< std::pair > postProperties; - /// nativeLibs - Native libraries (e.g. '.so') loaded by this JVM. - /// - ISOLATE_STATIC std::vector nativeLibs; - /// classpath - The CLASSPATH value, or the paths given in command line. /// const char* classpath; @@ -293,18 +288,13 @@ classpath = cp; } - /// initialiseStatics - Initializes the isolate. The function initialize - /// static variables in a single environment. - /// - ISOLATE_STATIC void initialiseStatics(); - ISOLATE_STATIC UserClassPrimitive* getPrimitiveClass(char id) { return primitiveMap[id]; } /// Jnjvm - Allocates a new JVM. /// - Jnjvm(uint32 memLimit); + Jnjvm(JnjvmBootstrapLoader* loader); /// runApplication - Runs the application with the given command line. /// User-visible function, inherited by the VirtualMachine class. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 13:17:39 2008 @@ -7,10 +7,18 @@ // //===----------------------------------------------------------------------===// +#include #include #include #include + +#if defined(__MACH__) +#define SELF_HANDLE RTLD_DEFAULT +#else +#define SELF_HANDLE 0 +#endif + #include "debug.h" #include "mvm/Allocator.h" @@ -31,8 +39,6 @@ #ifndef ISOLATE_SHARING JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0; -UserClass* JnjvmBootstrapLoader::SuperArray = 0; -UserClass** JnjvmBootstrapLoader::InterfacesArray; #endif @@ -654,3 +660,22 @@ return readerConstructUTF8(buf, n); } + +void* JnjvmClassLoader::loadLib(const char* buf, bool& jnjvm) { + void* res = dlsym(SELF_HANDLE, buf); + + if (!res) { + for (std::vector::iterator i = nativeLibs.begin(), + e = nativeLibs.end(); i!= e; ++i) { + res = dlsym((*i), buf); + if (res) break; + } + } else { + jnjvm = true; + } + + if (!res && this != bootstrapLoader) + res = bootstrapLoader->loadLib(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=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sun Oct 26 13:17:39 2008 @@ -222,6 +222,12 @@ /// Strings hashed by this classloader. std::vector > strings; + + /// nativeLibs - Native libraries (e.g. '.so') loaded by this class loader. + /// + std::vector nativeLibs; + + void* loadLib(const char* buf, bool& jnjvm); }; /// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which @@ -288,10 +294,13 @@ /// Java code. /// Classpath* upcalls; + + /// InterfacesArray - The interfaces that array classes implement. + /// + UserClass** InterfacesArray; - ISOLATE_STATIC UserClass** InterfacesArray; - ISOLATE_STATIC UserClass* SuperArray; - + /// SuperArray - The super of array classes. + UserClass* SuperArray; /// Lists of UTF8s used internaly in VMKit. const UTF8* NoClassDefFoundError; Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=58192&r1=58191&r2=58192&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Sun Oct 26 13:17:39 2008 @@ -30,12 +30,6 @@ return JavaThread::get()->isolate; } -#if defined(__MACH__) -#define SELF_HANDLE RTLD_DEFAULT -#else -#define SELF_HANDLE 0 -#endif - #define PRE "Java_" #define PRE_LEN 5 @@ -177,25 +171,6 @@ } -static void* loadName(char* buf, bool& jnjvm) { - void* res = dlsym(SELF_HANDLE, buf); - if (!res) { -#ifndef SERVICE_VM - Jnjvm* vm = JavaThread::get()->isolate; -#else - Jnjvm* vm = Jnjvm::bootstrapVM; -#endif - for (std::vector::iterator i = vm->nativeLibs.begin(), - e = vm->nativeLibs.end(); i!= e; ++i) { - res = dlsym((*i), buf); - if (res) break; - } - } else { - jnjvm = true; - } - return res; -} - void* NativeUtil::nativeLookup(CommonClass* cl, JavaMethod* meth, bool& jnjvm) { const UTF8* jniConsClName = cl->name; const UTF8* jniConsName = meth->name; @@ -206,13 +181,13 @@ char* buf = (char*)alloca(3 + PRE_LEN + mnlen + clen + (mtlen << 1)); jniConsFromMeth(cl, meth, buf); - void* res = loadName(buf, jnjvm); + void* res = cl->classLoader->loadLib(buf, jnjvm); if (!res) { buf = jniConsFromMeth2(cl, meth, buf); - res = loadName(buf, jnjvm); + res = cl->classLoader->loadLib(buf, jnjvm); if (!res) { buf = jniConsFromMeth3(cl, meth, buf); - res = loadName(buf, jnjvm); + res = cl->classLoader->loadLib(buf, jnjvm); if (!res) { printf("Native function %s not found. Probably " "not implemented by JnJVM?\n", meth->printString()); From nicolas.geoffray at lip6.fr Sun Oct 26 11:26:04 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 18:26:04 -0000 Subject: [vmkit-commits] [vmkit] r58193 - in /vmkit/trunk/lib/JnJVM/VMCore: Jnjvm.cpp Jnjvm.h JnjvmClassLoader.cpp JnjvmClassLoader.h Message-ID: <200810261826.m9QIQ5Hu014659@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 13:26:04 2008 New Revision: 58193 URL: http://llvm.org/viewvc/llvm-project?rev=58193&view=rev Log: Move the primitive map to the bootstrap loader. Modified: 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/JnjvmClassLoader.h Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58193&r1=58192&r2=58193&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 26 13:26:04 2008 @@ -44,10 +44,6 @@ const char* Jnjvm::envSeparator = ":"; const unsigned int Jnjvm::Magic = 0xcafebabe; -#ifndef ISOLATE -std::map Jnjvm::primitiveMap; -#endif - typedef void (*clinit_t)(Jnjvm* vm, UserConstantPool*); void UserCommonClass::initialiseClass(Jnjvm* vm) { @@ -810,16 +806,6 @@ arrayClasses[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat; arrayClasses[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong; arrayClasses[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble; - - primitiveMap[I_VOID] = upcalls->OfVoid; - primitiveMap[I_BOOL] = upcalls->OfBool; - primitiveMap[I_BYTE] = upcalls->OfByte; - primitiveMap[I_CHAR] = upcalls->OfChar; - primitiveMap[I_SHORT] = upcalls->OfShort; - primitiveMap[I_INT] = upcalls->OfInt; - primitiveMap[I_FLOAT] = upcalls->OfFloat; - primitiveMap[I_LONG] = upcalls->OfLong; - primitiveMap[I_DOUBLE] = upcalls->OfDouble; upcalls->initialiseClasspath(bootstrapLoader); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=58193&r1=58192&r2=58193&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sun Oct 26 13:26:04 2008 @@ -94,8 +94,6 @@ std::map arrayClasses; private: - ISOLATE_STATIC std::map primitiveMap; - /// bootstrapThread - The initial thread of this JVM. /// JavaThread* bootstrapThread; @@ -287,10 +285,6 @@ void setClasspath(char* cp) { classpath = cp; } - - ISOLATE_STATIC UserClassPrimitive* getPrimitiveClass(char id) { - return primitiveMap[id]; - } /// Jnjvm - Allocates a new JVM. /// Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58193&r1=58192&r2=58193&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 13:26:04 2008 @@ -208,7 +208,16 @@ DEF_UTF8(finalize); #undef DEF_UTF8 - + + primitiveMap[I_VOID] = upcalls->OfVoid; + primitiveMap[I_BOOL] = upcalls->OfBool; + primitiveMap[I_BYTE] = upcalls->OfByte; + primitiveMap[I_CHAR] = upcalls->OfChar; + primitiveMap[I_SHORT] = upcalls->OfShort; + primitiveMap[I_INT] = upcalls->OfInt; + primitiveMap[I_FLOAT] = upcalls->OfFloat; + primitiveMap[I_LONG] = upcalls->OfLong; + primitiveMap[I_DOUBLE] = upcalls->OfDouble; } JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, @@ -487,10 +496,10 @@ break; default : UserClassPrimitive* cl = - isolate->getPrimitiveClass((char)name->elements[0]); + bootstrapLoader->getPrimitiveClass((char)name->elements[0]); assert(cl && "No primitive"); - bool unsign = (cl == isolate->upcalls->OfChar || - cl == isolate->upcalls->OfBool); + bool unsign = (cl == bootstrapLoader->upcalls->OfChar || + cl == bootstrapLoader->upcalls->OfBool); res = new(allocator) PrimitiveTypedef(name, cl, unsign, cur); } 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=58193&r1=58192&r2=58193&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sun Oct 26 13:26:04 2008 @@ -337,6 +337,12 @@ const UTF8* tanh; const UTF8* finalize; + /// primitiveMap - Map of primitives, hashed by id. + std::map primitiveMap; + + UserClassPrimitive* getPrimitiveClass(char id) { + return primitiveMap[id]; + } }; } // end namespace jnjvm From nicolas.geoffray at lip6.fr Sun Oct 26 11:43:36 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 18:43:36 -0000 Subject: [vmkit-commits] [vmkit] r58194 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJITOpcodes.cpp Jnjvm.cpp Jnjvm.h JnjvmClassLoader.cpp JnjvmClassLoader.h Message-ID: <200810261843.m9QIhaFq015147@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 13:43:36 2008 New Revision: 58194 URL: http://llvm.org/viewvc/llvm-project?rev=58194&view=rev Log: Move the array class table to the bootstrap loader. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.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/JnjvmClassLoader.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=58194&r1=58193&r2=58194&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Sun Oct 26 13:43:36 2008 @@ -1840,7 +1840,9 @@ uint8 id = bytecodes[++i]; uint8 charId = arrayType(id); #ifndef ISOLATE_SHARING - dcl = JavaThread::get()->isolate->arrayClasses[id - 4]; + JnjvmBootstrapLoader* loader = + compilingClass->classLoader->bootstrapLoader; + dcl = loader->getArrayClass(id); #else std::vector args; args.push_back(isolateLocal); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58194&r1=58193&r2=58194&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 26 13:43:36 2008 @@ -795,17 +795,7 @@ bootstrapLoader = loader; upcalls = bootstrapLoader->upcalls; -#ifdef ISOLATE_SHARING throwable = upcalls->newThrowable; -#endif - arrayClasses[JavaArray::T_BOOLEAN - 4] = upcalls->ArrayOfBool; - arrayClasses[JavaArray::T_BYTE - 4] = upcalls->ArrayOfByte; - arrayClasses[JavaArray::T_CHAR - 4] = upcalls->ArrayOfChar; - arrayClasses[JavaArray::T_SHORT - 4] = upcalls->ArrayOfShort; - arrayClasses[JavaArray::T_INT - 4] = upcalls->ArrayOfInt; - arrayClasses[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat; - arrayClasses[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong; - arrayClasses[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble; upcalls->initialiseClasspath(bootstrapLoader); Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=58194&r1=58193&r2=58194&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Sun Oct 26 13:43:36 2008 @@ -88,10 +88,11 @@ /// mvm::BumpPtrAllocator allocator; mvm::Allocator gcAllocator; -#ifdef ISOLATE_SHARING + + /// throwable - The java/lang/Throwable class. In an isolate + /// environment, generated code references this field. UserClass* throwable; -#endif - std::map arrayClasses; + private: /// bootstrapThread - The initial thread of this JVM. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58194&r1=58193&r2=58194&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 13:43:36 2008 @@ -218,6 +218,15 @@ primitiveMap[I_FLOAT] = upcalls->OfFloat; primitiveMap[I_LONG] = upcalls->OfLong; primitiveMap[I_DOUBLE] = upcalls->OfDouble; + + arrayTable[JavaArray::T_BOOLEAN - 4] = upcalls->ArrayOfBool; + arrayTable[JavaArray::T_BYTE - 4] = upcalls->ArrayOfByte; + arrayTable[JavaArray::T_CHAR - 4] = upcalls->ArrayOfChar; + arrayTable[JavaArray::T_SHORT - 4] = upcalls->ArrayOfShort; + arrayTable[JavaArray::T_INT - 4] = upcalls->ArrayOfInt; + arrayTable[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat; + arrayTable[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong; + arrayTable[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble; } JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58194&r1=58193&r2=58194&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sun Oct 26 13:43:36 2008 @@ -337,12 +337,19 @@ const UTF8* tanh; const UTF8* finalize; - /// primitiveMap - Map of primitives, hashed by id. + /// primitiveMap - Map of primitive classes, hashed by id. std::map primitiveMap; UserClassPrimitive* getPrimitiveClass(char id) { return primitiveMap[id]; } + + /// arrayTable - Table of array classes. + UserClassArray* arrayTable[8]; + + UserClassArray* getArrayClass(unsigned id) { + return arrayTable[id - 4]; + } }; } // end namespace jnjvm From nicolas.geoffray at lip6.fr Sun Oct 26 11:48:28 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 18:48:28 -0000 Subject: [vmkit-commits] [vmkit] r58195 - in /vmkit/trunk/lib/JnJVM/VMCore: Jnjvm.cpp JnjvmClassLoader.cpp Message-ID: <200810261848.m9QImTP8015284@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 13:48:25 2008 New Revision: 58195 URL: http://llvm.org/viewvc/llvm-project?rev=58195&view=rev Log: Move initialisation of classpath to the bootstrap class loader. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58195&r1=58194&r2=58195&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Sun Oct 26 13:48:25 2008 @@ -796,9 +796,7 @@ upcalls = bootstrapLoader->upcalls; throwable = upcalls->newThrowable; - - upcalls->initialiseClasspath(bootstrapLoader); - + } const UTF8* Jnjvm::asciizToInternalUTF8(const char* asciiz) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58195&r1=58194&r2=58195&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 13:48:25 2008 @@ -227,6 +227,8 @@ arrayTable[JavaArray::T_FLOAT - 4] = upcalls->ArrayOfFloat; arrayTable[JavaArray::T_LONG - 4] = upcalls->ArrayOfLong; arrayTable[JavaArray::T_DOUBLE - 4] = upcalls->ArrayOfDouble; + + upcalls->initialiseClasspath(this); } JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, From nicolas.geoffray at lip6.fr Sun Oct 26 11:57:09 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 18:57:09 -0000 Subject: [vmkit-commits] [vmkit] r58197 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.h JnjvmClassLoader.cpp JnjvmClassLoader.h Message-ID: <200810261857.m9QIvAr7015538@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 13:57:09 2008 New Revision: 58197 URL: http://llvm.org/viewvc/llvm-project?rev=58197&view=rev Log: Don't be isolate specific on this one. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=58197&r1=58196&r2=58197&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Sun Oct 26 13:57:09 2008 @@ -473,6 +473,10 @@ } UserClassPrimitive* toPrimitive(Jnjvm* vm) const; + + CommonClass* getInternal() { + return this; + } }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58197&r1=58196&r2=58197&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 13:57:09 2008 @@ -104,17 +104,12 @@ SuperArray = loadName(asciizConstructUTF8("java/lang/Object"), false, false); - -#ifdef ISOLATE_SHARING - if (!ClassArray::SuperArray) { - ClassArray::SuperArray = SuperArray->classDef; - ClassArray::InterfacesArray[0] = ((Class*)InterfacesArray[0]->classDef); - ClassArray::InterfacesArray[1] = ((Class*)InterfacesArray[1]->classDef); - } -#else - ClassArray::SuperArray = SuperArray; - ClassArray::InterfacesArray = InterfacesArray; -#endif + + ClassArray::SuperArray = SuperArray->getInternal(); + ClassArray::InterfacesArray = + (Class**)allocator.Allocate(2 * sizeof(UserClass*)); + ClassArray::InterfacesArray[0] = (Class*)InterfacesArray[0]->getInternal(); + ClassArray::InterfacesArray[1] = (Class*)(InterfacesArray[1]->getInternal()); // And repair the damage: set the interfaces and super of array classes already // created. @@ -246,12 +241,10 @@ javaLoader = loader; isolate = I; -#ifdef ISOLATE_SHARING JavaMethod* meth = bootstrapLoader->upcalls->loadInClassLoader; loader->classOf->lookupMethodDontThrow(meth->name, meth->type, false, true, - loadClass); + &loadClass); assert(loadClass && "Loader does not have a loadClass function"); -#endif } @@ -307,12 +300,7 @@ const UTF8* javaName = name->internalToJava(isolate, 0, name->size); JavaString* str = isolate->UTF8ToStr(javaName); Classpath* upcalls = bootstrapLoader->upcalls; - UserClass* forCtp = 0; -#ifdef ISOLATE_SHARING - forCtp = loadClass; -#else - forCtp = upcalls->loadInClassLoader->classDef; -#endif + UserClass* forCtp = loadClass; JavaObject* obj = (JavaObject*) upcalls->loadInClassLoader->invokeJavaObjectVirtual(isolate, forCtp, javaLoader, str); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58197&r1=58196&r2=58197&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sun Oct 26 13:57:09 2008 @@ -212,9 +212,7 @@ classes = 0; } -#ifdef ISOLATE_SHARING UserClass* loadClass; -#endif const UTF8* constructArrayName(uint32 steps, const UTF8* className); From nicolas.geoffray at lip6.fr Sun Oct 26 12:28:26 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 19:28:26 -0000 Subject: [vmkit-commits] [vmkit] r58200 - in /vmkit/trunk: include/mvm/CompilationUnit.h include/mvm/VirtualMachine.h lib/JnJVM/VMCore/JavaConstantPool.cpp lib/JnJVM/VMCore/JavaInitialise.cpp lib/JnJVM/VMCore/JnjvmClassLoader.cpp lib/JnJVM/VMCore/JnjvmClassLoader.h lib/N3/VMCore/N3Initialise.cpp tools/jnjvm/Main.cpp tools/vmkit/CommandLine.cpp tools/vmkit/CommandLine.h tools/vmkit/Launcher.cpp Message-ID: <200810261928.m9QJSQfx016566@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 14:28:25 2008 New Revision: 58200 URL: http://llvm.org/viewvc/llvm-project?rev=58200&view=rev Log: Static initialization of a VM returns a compilation unit, which is then passed to the VM factory. In JnJVM, this makes the bootstrap loader non static. Added: vmkit/trunk/include/mvm/CompilationUnit.h Modified: vmkit/trunk/include/mvm/VirtualMachine.h vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp vmkit/trunk/tools/jnjvm/Main.cpp vmkit/trunk/tools/vmkit/CommandLine.cpp vmkit/trunk/tools/vmkit/CommandLine.h vmkit/trunk/tools/vmkit/Launcher.cpp Added: vmkit/trunk/include/mvm/CompilationUnit.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/CompilationUnit.h?rev=58200&view=auto ============================================================================== --- vmkit/trunk/include/mvm/CompilationUnit.h (added) +++ vmkit/trunk/include/mvm/CompilationUnit.h Sun Oct 26 14:28:25 2008 @@ -0,0 +1,36 @@ +//===---- CompilingUnit.h - A compilation unit to compile source files ----===// +// +// The VMKit project +// +// This file is distributed under the University of Pierre et Marie Curie +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// A compilation unit contains a module and a module provider to compile source +// files of a virtual machine, e.g .java files in Java. +// +//===----------------------------------------------------------------------===// + +#ifndef MVM_COMPILATION_UNIT_H +#define MVM_COMPILATION_UNIT_H + +#include "mvm/Object.h" + +namespace llvm { + class Module; + class ModuleProvider; +} + +namespace mvm { + +class CompilationUnit : public mvm::Object { +public: + llvm::Module* TheModule; + llvm::ModuleProvider* TheModuleProvider; + +}; +} + + +#endif Modified: vmkit/trunk/include/mvm/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/include/mvm/VirtualMachine.h (original) +++ vmkit/trunk/include/mvm/VirtualMachine.h Sun Oct 26 14:28:25 2008 @@ -15,6 +15,7 @@ #ifndef MVM_VIRTUALMACHINE_H #define MVM_VIRTUALMACHINE_H +#include "mvm/CompilationUnit.h" #include "mvm/Object.h" namespace mvm { @@ -30,11 +31,11 @@ /// the arguments, hence it is the virtual machine's job to parse them. virtual void runApplication(int argc, char** argv) = 0; - static void initialiseJVM(); - static VirtualMachine* createJVM(); + static CompilationUnit* initialiseJVM(); + static VirtualMachine* createJVM(CompilationUnit* C = 0); - static void initialiseCLIVM(); - static VirtualMachine* createCLIVM(); + static CompilationUnit* initialiseCLIVM(); + static VirtualMachine* createCLIVM(CompilationUnit* C = 0); }; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Sun Oct 26 14:28:25 2008 @@ -307,7 +307,7 @@ const UTF8* name = UTF8At(ctpDef[index]); temp = loader->lookupClass(name); if (!temp) - temp = JnjvmClassLoader::bootstrapLoader->lookupClass(name); + temp = loader->bootstrapLoader->lookupClass(name); } #endif return temp; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Sun Oct 26 14:28:25 2008 @@ -62,29 +62,26 @@ } #ifdef ISOLATE_SHARING -void mvm::VirtualMachine::initialiseJVM() { +mvm::CompilationUnit* mvm::VirtualMachine::initialiseJVM() { initialiseVT(); - if (!JnjvmSharedLoader::sharedLoader) { - JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); - } + JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); + return JnjvmSharedLoader::sharedLoader; } -mvm::VirtualMachine* mvm::VirtualMachine::createJVM() { +mvm::VirtualMachine* mvm::VirtualMachine::createJVM(mvm::CompilationUnit* C) { JnjvmBootstraLoader* bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); Jnjvm* vm = gc_new(Jnjvm)(bootstrapLoader); return vm; } #else -void mvm::VirtualMachine::initialiseJVM() { +mvm::CompilationUnit* mvm::VirtualMachine::initialiseJVM() { initialiseVT(); - if (!JnjvmClassLoader::bootstrapLoader) { - JnjvmClassLoader::bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); - } + return gc_new(JnjvmBootstrapLoader)(0); } -mvm::VirtualMachine* mvm::VirtualMachine::createJVM() { - Jnjvm* vm = gc_new(Jnjvm)(JnjvmClassLoader::bootstrapLoader); +mvm::VirtualMachine* mvm::VirtualMachine::createJVM(mvm::CompilationUnit* C) { + Jnjvm* vm = gc_new(Jnjvm)((JnjvmBootstrapLoader*)C); return vm; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Sun Oct 26 14:28:25 2008 @@ -37,11 +37,6 @@ using namespace jnjvm; -#ifndef ISOLATE_SHARING -JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0; -#endif - - extern const char* GNUClasspathGlibj; extern const char* GNUClasspathLibs; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Sun Oct 26 14:28:25 2008 @@ -16,6 +16,7 @@ #include "types.h" #include "mvm/Allocator.h" +#include "mvm/CompilationUnit.h" #include "mvm/Object.h" #include "mvm/PrintBuffer.h" @@ -49,7 +50,7 @@ /// its own tables (signatures, UTF8, types) which are mapped to a single /// table for non-isolate environments. /// -class JnjvmClassLoader : public mvm::Object { +class JnjvmClassLoader : public mvm::CompilationUnit { private: @@ -192,7 +193,7 @@ /// bootstrapLoader - The bootstrap loader of the JVM. Loads the base /// classes. /// - ISOLATE_STATIC JnjvmBootstrapLoader* bootstrapLoader; + JnjvmBootstrapLoader* bootstrapLoader; /// ~JnjvmClassLoader - Destroy the loader. Depending on the JVM /// configuration, this may destroy the tables, JIT module and Modified: vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp Sun Oct 26 14:28:25 2008 @@ -10,6 +10,7 @@ #include +#include "mvm/CompilationUnit.h" #include "mvm/JIT.h" #include "mvm/Threads/Locks.h" @@ -327,11 +328,12 @@ } -void mvm::VirtualMachine::initialiseCLIVM() { +mvm::CompilationUnit* mvm::VirtualMachine::initialiseCLIVM() { if (!N3::bootstrapVM) { initialiseVT(); initialiseStatics(); } + return 0; } void VirtualMachine::runApplication(int argc, char** argv) { @@ -339,7 +341,7 @@ ((N3*)this)->runMain(argc, argv); } -mvm::VirtualMachine* mvm::VirtualMachine::createCLIVM() { +mvm::VirtualMachine* mvm::VirtualMachine::createCLIVM(mvm::CompilationUnit* C) { N3* vm = N3::allocate("", N3::bootstrapVM); return vm; } Modified: vmkit/trunk/tools/jnjvm/Main.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/jnjvm/Main.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/tools/jnjvm/Main.cpp (original) +++ vmkit/trunk/tools/jnjvm/Main.cpp Sun Oct 26 14:28:25 2008 @@ -26,8 +26,8 @@ Thread::initialise(); Collector::initialise(0, &base); - VirtualMachine::initialiseJVM(); - VirtualMachine* vm = VirtualMachine::createJVM(); + CompilationUnit* CU = VirtualMachine::initialiseJVM(); + VirtualMachine* vm = VirtualMachine::createJVM(CU); vm->runApplication(argc, argv); return 0; Modified: vmkit/trunk/tools/vmkit/CommandLine.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/CommandLine.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/tools/vmkit/CommandLine.cpp (original) +++ vmkit/trunk/tools/vmkit/CommandLine.cpp Sun Oct 26 14:28:25 2008 @@ -100,6 +100,7 @@ } } +#if 0 extern "C" int startApp(thread_arg_t* arg) { int argc = arg->argc; char** argv = arg->argv; @@ -120,6 +121,7 @@ #endif return 0; } +#endif void CommandLine::executeInstr() { if (!strcmp(argv[0], "load")) { @@ -152,6 +154,7 @@ } else { create_vm_t func = vmlets[argv[0]]; + mvm::CompilationUnit* CU = compilers[argv[0]]; if (!func) { fprintf(stderr, "\t Unknown vm %s\n", argv[0]); } else { @@ -163,7 +166,7 @@ int tid = 0; Thread::start(&tid, (int (*)(void *))startApp, thread_arg); #else - VirtualMachine* VM = func(); + VirtualMachine* VM = func(CU); try { VM->runApplication(argc, argv); } catch(...) { Modified: vmkit/trunk/tools/vmkit/CommandLine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/CommandLine.h?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/tools/vmkit/CommandLine.h (original) +++ vmkit/trunk/tools/vmkit/CommandLine.h Sun Oct 26 14:28:25 2008 @@ -29,7 +29,7 @@ #endif typedef int (*boot_t)(); -typedef mvm::VirtualMachine* (*create_vm_t)(); +typedef mvm::VirtualMachine* (*create_vm_t)(mvm::CompilationUnit*); namespace mvm { @@ -54,6 +54,7 @@ char _yyChar; std::map vmlets; + std::map compilers; CommandLine(); Modified: vmkit/trunk/tools/vmkit/Launcher.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmkit/Launcher.cpp?rev=58200&r1=58199&r2=58200&view=diff ============================================================================== --- vmkit/trunk/tools/vmkit/Launcher.cpp (original) +++ vmkit/trunk/tools/vmkit/Launcher.cpp Sun Oct 26 14:28:25 2008 @@ -69,25 +69,29 @@ if (VMToRun == RunJava) { #if WITH_JNJVM - mvm::VirtualMachine::initialiseJVM(); - mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(); + mvm::CompilationUnit* CU = mvm::VirtualMachine::initialiseJVM(); + mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(CU); vm->runApplication(argc, argv); #endif } else if (VMToRun == RunNet) { #if WITH_N3 - mvm::VirtualMachine::initialiseCLIVM(); - mvm::VirtualMachine* vm = mvm::VirtualMachine::createCLIVM(); + mvm::CompilationUnit* CU = mvm::VirtualMachine::initialiseCLIVM(); + mvm::VirtualMachine* vm = mvm::VirtualMachine::createCLIVM(CU); vm->runApplication(argc, argv); #endif } else { mvm::CommandLine MyCl; #if WITH_JNJVM - mvm::VirtualMachine::initialiseJVM(); + mvm::CompilationUnit* JVMCompiler = + mvm::VirtualMachine::initialiseJVM(); MyCl.vmlets["java"] = (mvm::VirtualMachine::createJVM); + MyCl.compilers["java"] = JVMCompiler; #endif #if WITH_N3 - mvm::VirtualMachine::initialiseCLIVM(); + mvm::CompilationUnit* CLICompiler = + mvm::VirtualMachine::initialiseCLIVM(); MyCl.vmlets["net"] = (mvm::VirtualMachine::createCLIVM); + MyCl.compilers["net"] = CLICompiler; #endif MyCl.start(); } From nicolas.geoffray at lip6.fr Sun Oct 26 12:55:13 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 19:55:13 -0000 Subject: [vmkit-commits] [vmkit] r58201 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaClass.cpp JavaClass.h JnjvmModule.cpp JnjvmModule.h Message-ID: <200810261955.m9QJtD33017389@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 14:55:12 2008 New Revision: 58201 URL: http://llvm.org/viewvc/llvm-project?rev=58201&view=rev Log: Move initialisation of a field in JavaField. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h 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=58201&r1=58200&r2=58201&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Sun Oct 26 14:55:12 2008 @@ -619,12 +619,51 @@ } } +void JavaField::InitField(JavaObject* obj, uint64 val) { + + Typedef* type = getSignature(); + if (!type->isPrimitive()) { + ((sint32*)((uint64)obj + ptrOffset))[0] = (sint32)val; + return; + } + + PrimitiveTypedef* prim = (PrimitiveTypedef*)type; + if (prim->isLong()) { + ((sint64*)((uint64)obj + ptrOffset))[0] = val; + } else if (prim->isInt()) { + ((sint32*)((uint64)obj + ptrOffset))[0] = (sint32)val; + } else if (prim->isChar()) { + ((uint16*)((uint64)obj + ptrOffset))[0] = (uint16)val; + } else if (prim->isShort()) { + ((sint16*)((uint64)obj + ptrOffset))[0] = (sint16)val; + } else if (prim->isByte()) { + ((sint8*)((uint64)obj + ptrOffset))[0] = (sint8)val; + } else if (prim->isBool()) { + ((uint8*)((uint64)obj + ptrOffset))[0] = (uint8)val; + } else { + // 0 value for everything else + ((sint32*)((uint64)obj + ptrOffset))[0] = (sint32)val; + } +} + +void JavaField::InitField(JavaObject* obj, JavaObject* val) { + ((JavaObject**)((uint64)obj + ptrOffset))[0] = val; +} + +void JavaField::InitField(JavaObject* obj, double val) { + ((double*)((uint64)obj + ptrOffset))[0] = val; +} + +void JavaField::InitField(JavaObject* obj, float val) { + ((float*)((uint64)obj + ptrOffset))[0] = val; +} + void JavaField::initField(JavaObject* obj, Jnjvm* vm) { const Typedef* type = getSignature(); Attribut* attribut = lookupAttribut(Attribut::constantAttribut); if (!attribut) { - JnjvmModule::InitField(this, obj); + InitField(obj); } else { Reader reader(attribut, classDef->bytes); JavaConstantPool * ctpInfo = classDef->ctpInfo; @@ -632,18 +671,17 @@ if (type->isPrimitive()) { UserCommonClass* cl = type->assocClass(vm->bootstrapLoader); if (cl == vm->upcalls->OfLong) { - JnjvmModule::InitField(this, obj, (uint64)ctpInfo->LongAt(idx)); + InitField(obj, (uint64)ctpInfo->LongAt(idx)); } else if (cl == vm->upcalls->OfDouble) { - JnjvmModule::InitField(this, obj, ctpInfo->DoubleAt(idx)); + InitField(obj, ctpInfo->DoubleAt(idx)); } else if (cl == vm->upcalls->OfFloat) { - JnjvmModule::InitField(this, obj, ctpInfo->FloatAt(idx)); + InitField(obj, ctpInfo->FloatAt(idx)); } else { - JnjvmModule::InitField(this, obj, (uint64)ctpInfo->IntegerAt(idx)); + InitField(obj, (uint64)ctpInfo->IntegerAt(idx)); } } else if (type->isReference()){ const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[idx]); - JnjvmModule::InitField(this, obj, - (JavaObject*)ctpInfo->resolveString(utf8, idx)); + InitField(obj, (JavaObject*)ctpInfo->resolveString(utf8, idx)); } else { JavaThread::get()->isolate-> unknownError("unknown constant %s\n", type->printString()); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=58201&r1=58200&r2=58201&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Sun Oct 26 14:55:12 2008 @@ -884,6 +884,14 @@ /// _signature - The signature of the field. Null if not resolved. /// Typedef* _signature; + + /// InitField - Set an initial value to the field of an object. + /// + void InitField(JavaObject* obj, uint64 val = 0); + void InitField(JavaObject* obj, JavaObject* val); + void InitField(JavaObject* obj, double val); + void InitField(JavaObject* obj, float val); + public: /// ~JavaField - Destroy the field as well as its attributs. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58201&r1=58200&r2=58201&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Sun Oct 26 14:55:12 2008 @@ -941,46 +941,6 @@ LLVMAssessorInfo::initialise(); } -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, uint64 val) { - - Typedef* type = field->getSignature(); - if (!type->isPrimitive()) { - ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - return; - } - - PrimitiveTypedef* prim = (PrimitiveTypedef*)type; - if (prim->isLong()) { - ((sint64*)((uint64)obj + field->ptrOffset))[0] = val; - } else if (prim->isInt()) { - ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - } else if (prim->isChar()) { - ((uint16*)((uint64)obj + field->ptrOffset))[0] = (uint16)val; - } else if (prim->isShort()) { - ((sint16*)((uint64)obj + field->ptrOffset))[0] = (sint16)val; - } else if (prim->isByte()) { - ((sint8*)((uint64)obj + field->ptrOffset))[0] = (sint8)val; - } else if (prim->isBool()) { - ((uint8*)((uint64)obj + field->ptrOffset))[0] = (uint8)val; - } else { - // 0 value for everything else - ((sint32*)((uint64)obj + field->ptrOffset))[0] = (sint32)val; - } -} - -void -JnjvmModule::InitField(JavaField* field, JavaObject* obj, JavaObject* val) { - ((JavaObject**)((uint64)obj + field->ptrOffset))[0] = val; -} - -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, double val) { - ((double*)((uint64)obj + field->ptrOffset))[0] = val; -} - -void JnjvmModule::InitField(JavaField* field, JavaObject* obj, float val) { - ((float*)((uint64)obj + field->ptrOffset))[0] = val; -} - void JnjvmModule::setMethod(JavaMethod* meth, const char* name) { llvm::Function* func = getMethodInfo(meth)->getMethod(); func->setName(name); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58201&r1=58200&r2=58201&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Sun Oct 26 14:55:12 2008 @@ -338,13 +338,6 @@ llvm::Function* OutOfMemoryErrorFunction; llvm::Function* NegativeArraySizeExceptionFunction; - static void InitField(JavaField* field); - static void InitField(JavaField* field, JavaObject* obj, uint64 val = 0); - static void InitField(JavaField* field, JavaObject* obj, JavaObject* val); - static void InitField(JavaField* field, JavaObject* obj, double val); - static void InitField(JavaField* field, JavaObject* obj, float val); - - static void resolveVirtualClass(Class* cl); static void resolveStaticClass(Class* cl); static void setMethod(JavaMethod* meth, const char* name); From nicolas.geoffray at lip6.fr Sun Oct 26 15:32:45 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 22:32:45 -0000 Subject: [vmkit-commits] [vmkit] r58204 - in /vmkit/trunk/lib/JnJVM/VMCore: JnjvmModule.cpp JnjvmModule.h Message-ID: <200810262232.m9QMWjAt022715@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 17:32:44 2008 New Revision: 58204 URL: http://llvm.org/viewvc/llvm-project?rev=58204&view=rev Log: Move creation of the tracer in a function. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58204&r1=58203&r2=58204&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Sun Oct 26 17:32:44 2008 @@ -276,42 +276,8 @@ #endif -VirtualTable* JnjvmModule::makeVT(Class* cl, bool stat) { - - VirtualTable* res = 0; -#ifndef WITHOUT_VTABLE - if (stat) { -#endif - mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator; - res = (VirtualTable*)allocator.Allocate(VT_SIZE); - memcpy(res, JavaObject::VT, VT_SIZE); -#ifndef WITHOUT_VTABLE - } else { - if (cl->super) { - cl->virtualTableSize = cl->super->virtualTableSize; - } else { - cl->virtualTableSize = VT_NB_FUNCS; - } - res = allocateVT(cl, 0); +llvm::Function* JnjvmModule::makeTracer(Class* cl, bool stat) { - if (!(cl->super)) { - uint32 size = (cl->virtualTableSize - VT_NB_FUNCS) * sizeof(void*); -#define COPY(CLASS) \ - memcpy((void*)((unsigned)CLASS::VT + VT_SIZE), \ - (void*)((unsigned)res + VT_SIZE), size); - - COPY(JavaArray) - COPY(JavaObject) - COPY(ArrayObject) - -#undef COPY - } - } -#endif - - - -#ifdef WITH_TRACER LLVMClassInfo* LCI = (LLVMClassInfo*)getClassInfo(cl); const Type* type = stat ? LCI->getStaticType() : LCI->getVirtualType(); JavaField* fields = 0; @@ -323,7 +289,7 @@ fields = cl->getVirtualFields(); nbFields = cl->nbVirtualFields; } - + Function* func = Function::Create(JnjvmModule::MarkAndTraceType, GlobalValue::ExternalLinkage, "markAndTraceObject", @@ -380,17 +346,57 @@ } ReturnInst::Create(block); - - void* codePtr = mvm::MvmModule::executionEngine->getPointerToGlobal(func); - ((void**)res)[VT_TRACER_OFFSET] = codePtr; - func->deleteBody(); - if (!stat) { LCI->virtualTracerFunction = func; } else { LCI->staticTracerFunction = func; } + + return func; +} + +VirtualTable* JnjvmModule::makeVT(Class* cl, bool stat) { + + VirtualTable* res = 0; +#ifndef WITHOUT_VTABLE + if (stat) { +#endif + mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator; + res = (VirtualTable*)allocator.Allocate(VT_SIZE); + memcpy(res, JavaObject::VT, VT_SIZE); +#ifndef WITHOUT_VTABLE + } else { + if (cl->super) { + cl->virtualTableSize = cl->super->virtualTableSize; + } else { + cl->virtualTableSize = VT_NB_FUNCS; + } + res = allocateVT(cl, 0); + + if (!(cl->super)) { + uint32 size = (cl->virtualTableSize - VT_NB_FUNCS) * sizeof(void*); +#define COPY(CLASS) \ + memcpy((void*)((unsigned)CLASS::VT + VT_SIZE), \ + (void*)((unsigned)res + VT_SIZE), size); + + COPY(JavaArray) + COPY(JavaObject) + COPY(ArrayObject) + +#undef COPY + } + } +#endif + +#ifdef WITH_TRACER + llvm::Function* func = makeTracer(cl, stat); + + void* codePtr = mvm::MvmModule::executionEngine->getPointerToGlobal(func); + ((void**)res)[VT_TRACER_OFFSET] = codePtr; + + func->deleteBody(); + #endif return res; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58204&r1=58203&r2=58204&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Sun Oct 26 17:32:44 2008 @@ -210,7 +210,8 @@ - + + llvm::Function* makeTracer(Class* cl, bool stat); VirtualTable* makeVT(Class* cl, bool stat); VirtualTable* allocateVT(Class* cl, uint32 index); From nicolas.geoffray at lip6.fr Sun Oct 26 15:52:22 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 22:52:22 -0000 Subject: [vmkit-commits] [vmkit] r58211 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JavaJITOpcodes.cpp JnjvmModule.cpp JnjvmModule.h Message-ID: <200810262252.m9QMqMLT023477@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 17:52:21 2008 New Revision: 58211 URL: http://llvm.org/viewvc/llvm-project?rev=58211&view=rev Log: Code cleanup. No functionality changes. 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=58211&r1=58210&r2=58211&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sun Oct 26 17:52:21 2008 @@ -84,7 +84,8 @@ if (meth && !isAbstract(meth->access) && canBeInlined(meth)) { Value* cl = CallInst::Create(module->GetClassFunction, args[0], "", currentBlock); - Value* cl2 = module->getNativeClass((Class*)cl, this); + Value* cl2 = module->getNativeClass((Class*)cl); + cl2 = new LoadInst(cl2, "", currentBlock); Value* test = new ICmpInst(ICmpInst::ICMP_EQ, cl, cl2, "", currentBlock); @@ -267,7 +268,9 @@ val, "", currentBlock); nativeArgs.push_back(res); #else - nativeArgs.push_back(module->getJavaClass(compilingClass, this)); + Value* cl = module->getJavaClass(compilingClass); + cl= new LoadInst(cl, "", currentBlock); + nativeArgs.push_back(cl); #endif index = 2; } else { @@ -482,7 +485,8 @@ obj = llvmFunction->arg_begin(); } else { #ifndef ISOLATE_SHARING - obj = module->getStaticInstance(compilingClass, this); + obj = module->getStaticInstance(compilingClass); + obj = new LoadInst(obj, "", currentBlock); #else obj = getStaticInstanceCtp(); #endif @@ -506,7 +510,8 @@ obj = llvmFunction->arg_begin(); } else { #ifndef ISOLATE_SHARING - obj = module->getStaticInstance(compilingClass, this); + obj = module->getStaticInstance(compilingClass); + obj = new LoadInst(obj, "", currentBlock); #else obj = getStaticInstanceCtp(); #endif @@ -953,7 +958,8 @@ argsSync.push_back(llvmFunction->arg_begin()); } else { #ifndef ISOLATE_SHARING - Value* arg = module->getStaticInstance(compilingClass, this); + Value* arg = module->getStaticInstance(compilingClass); + arg = new LoadInst(arg, "", currentBlock); #else Value* arg = getStaticInstanceCtp(); #endif @@ -1121,7 +1127,8 @@ isolateLocal, "", currentBlock); #else assert(cur->catchClass); - cl = module->getNativeClass(cur->catchClass, this); + cl = module->getNativeClass(cur->catchClass); + cl = new LoadInst(cl, "", currentBlock); #endif Value* cmp = llvm::CallInst::Create(module->CompareExceptionFunction, cl, "", currentBlock); @@ -1194,7 +1201,8 @@ const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]); JavaString* str = compilingClass->classLoader->UTF8ToStr(utf8); - Value* val = module->getString(str, this); + Value* val = module->getString(str); + val = new LoadInst(val, "", currentBlock); push(val, false); #endif @@ -1214,7 +1222,9 @@ #if !defined(ISOLATE) if (ctpInfo->ctpRes[index]) { CommonClass* cl = (CommonClass*)(ctpInfo->ctpRes[index]); - push(module->getJavaClass(cl, this), false); + Value* Val = module->getJavaClass(cl); + Val = new LoadInst(Val, "", currentBlock); + push(Val, false); } else { #endif Value* val = getResolvedClass(index, false); @@ -1693,8 +1703,10 @@ Args.clear(); #else JavaConstantPool* ctp = compilingClass->ctpInfo; - Value* CTP = module->getConstantPool(ctp, this); - Value* Cl = module->getNativeClass(compilingClass, this); + Value* CTP = module->getConstantPool(ctp); + CTP = new LoadInst(CTP, "", currentBlock); + Value* Cl = module->getNativeClass(compilingClass); + Cl = new LoadInst(Cl, "", currentBlock); #endif Args.push_back(resolver); @@ -1750,10 +1762,12 @@ currentBlock); } else { LLVMClassInfo* LCI = module->getClassInfo(cl); - Size = LCI->getVirtualSize(this); + Size = LCI->getVirtualSize(); #ifndef ISOLATE_SHARING - VT = module->getVirtualTable(cl, this); - Cl = module->getNativeClass(cl, this); + VT = module->getVirtualTable(cl); + VT = new LoadInst(VT, "", currentBlock); + Cl = module->getNativeClass(cl); + Cl = new LoadInst(Cl, "", currentBlock); if (!cl->isReady()) { Cl = invoke(module->InitialisationCheckFunction, Cl, "", currentBlock); @@ -1825,7 +1839,8 @@ #ifndef ISOLATE_SHARING if (field->classDef->isReady()) { - object = module->getStaticInstance(field->classDef, this); + object = module->getStaticInstance(field->classDef); + object = new LoadInst(object, "", currentBlock); type = LCI->getStaticType(); return fieldGetter(this, type, object, LFI->getOffset()); } @@ -2063,7 +2078,8 @@ if (!inlining) enveloppe.initialise(compilingClass->ctpInfo, index); - Value* llvmEnv = module->getEnveloppe(&enveloppe, this); + Value* llvmEnv = module->getEnveloppe(&enveloppe); + llvmEnv = new LoadInst(llvmEnv, "", currentBlock); #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=58211&r1=58210&r2=58211&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Sun Oct 26 17:52:21 2008 @@ -1872,8 +1872,10 @@ sizeElement = module->constantPtrSize; } #ifndef ISOLATE_SHARING - valCl = module->getNativeClass(dcl, this); - TheVT = module->getVirtualTable(dcl, this); + valCl = module->getNativeClass(dcl); + valCl = new LoadInst(valCl, "", currentBlock); + TheVT = module->getVirtualTable(dcl); + TheVT = new LoadInst(TheVT, "", currentBlock); #endif llvm::Value* arg1 = popAsInt(); @@ -2003,7 +2005,8 @@ Value* clVar = 0; #ifndef ISOLATE_SHARING if (dcl) { - clVar = module->getNativeClass(dcl, this); + clVar = module->getNativeClass(dcl); + clVar = new LoadInst(clVar, "", currentBlock); } else #endif clVar = getResolvedClass(index, false); @@ -2044,7 +2047,8 @@ Value* clVar = 0; if (dcl) { - clVar = module->getNativeClass(dcl, this); + clVar = module->getNativeClass(dcl); + clVar = new LoadInst(clVar, "", currentBlock); } else { clVar = getResolvedClass(index, false); } @@ -2109,7 +2113,8 @@ UserClassArray* dcl = JCL->constructArray(className); compilingClass->ctpInfo->loadClass(index); - Value* valCl = module->getNativeClass(dcl ,this); + Value* valCl = module->getNativeClass(dcl); + valCl = new LoadInst(valCl, "", currentBlock); #endif Value** args = (Value**)alloca(sizeof(Value*) * (dim + 2)); args[0] = valCl; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58211&r1=58210&r2=58211&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Sun Oct 26 17:52:21 2008 @@ -8,18 +8,17 @@ //===----------------------------------------------------------------------===// #include "llvm/CallingConv.h" +#include "llvm/Instructions.h" #include "llvm/Support/MutexGuard.h" #include "mvm/JIT.h" -#include "JavaJIT.h" #include "JavaThread.h" #include "JavaTypes.h" #include "Jnjvm.h" #include "JnjvmModule.h" #include "JnjvmModuleProvider.h" -#include "LockedMap.h" using namespace jnjvm; @@ -66,7 +65,7 @@ llvm::ConstantInt* JnjvmModule::JavaObjectLockOffsetConstant; llvm::ConstantInt* JnjvmModule::JavaObjectClassOffsetConstant; -Value* JnjvmModule::getNativeClass(CommonClass* classDef, JavaJIT* jit) { +Value* JnjvmModule::getNativeClass(CommonClass* classDef) { llvm::GlobalVariable* varGV = 0; native_class_iterator End = nativeClasses.end(); native_class_iterator I = nativeClasses.find(classDef); @@ -84,10 +83,10 @@ } else { varGV = I->second; } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } -Value* JnjvmModule::getConstantPool(JavaConstantPool* ctp, JavaJIT* jit) { +Value* JnjvmModule::getConstantPool(JavaConstantPool* ctp) { llvm::GlobalVariable* varGV = 0; constant_pool_iterator End = constantPools.end(); constant_pool_iterator I = constantPools.find(ctp); @@ -103,10 +102,10 @@ } else { varGV = I->second; } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } -Value* JnjvmModule::getString(JavaString* str, JavaJIT* jit) { +Value* JnjvmModule::getString(JavaString* str) { llvm::GlobalVariable* varGV; string_iterator SI = strings.find(str); if (SI != strings.end()) { @@ -121,10 +120,10 @@ cons, "", this); strings.insert(std::make_pair(str, varGV)); } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } -Value* JnjvmModule::getEnveloppe(Enveloppe* enveloppe, JavaJIT* jit) { +Value* JnjvmModule::getEnveloppe(Enveloppe* enveloppe) { llvm::GlobalVariable* varGV; enveloppe_iterator SI = enveloppes.find(enveloppe); if (SI != enveloppes.end()) { @@ -139,10 +138,10 @@ cons, "", this); enveloppes.insert(std::make_pair(enveloppe, varGV)); } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } -Value* JnjvmModule::getJavaClass(CommonClass* cl, JavaJIT* jit) { +Value* JnjvmModule::getJavaClass(CommonClass* cl) { llvm::GlobalVariable* varGV = 0; java_class_iterator End = javaClasses.end(); java_class_iterator I = javaClasses.find(cl); @@ -160,10 +159,10 @@ } else { varGV = I->second; } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } -Value* JnjvmModule::getStaticInstance(Class* classDef, JavaJIT* jit) { +Value* JnjvmModule::getStaticInstance(Class* classDef) { llvm::GlobalVariable* varGV = 0; static_instance_iterator End = staticInstances.end(); static_instance_iterator I = staticInstances.find(classDef); @@ -184,10 +183,10 @@ varGV = I->second; } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } -Value* JnjvmModule::getVirtualTable(CommonClass* classDef, JavaJIT* jit) { +Value* JnjvmModule::getVirtualTable(CommonClass* classDef) { llvm::GlobalVariable* varGV = 0; virtual_table_iterator End = virtualTables.end(); virtual_table_iterator I = virtualTables.find(classDef); @@ -208,7 +207,7 @@ } else { varGV = I->second; } - return new LoadInst(varGV, "", jit->currentBlock); + return varGV; } #ifndef WITHOUT_VTABLE @@ -218,7 +217,6 @@ uint64 size = cl->virtualTableSize; mvm::BumpPtrAllocator& allocator = cl->classLoader->allocator; VirtualTable* VT = (VirtualTable*)allocator.Allocate(size * sizeof(void*)); - if (!VT) JavaThread::get()->isolate->outOfMemoryError(size * sizeof(void*)); if (cl->super) { Class* super = (Class*)cl->super; assert(cl->virtualTableSize >= cl->super->virtualTableSize && @@ -485,7 +483,7 @@ } -Value* LLVMClassInfo::getVirtualSize(JavaJIT* jit) { +Value* LLVMClassInfo::getVirtualSize() { if (!virtualSizeConstant) { getVirtualType(); virtualSizeConstant = Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58211&r1=58210&r2=58211&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Sun Oct 26 17:52:21 2008 @@ -33,7 +33,6 @@ class JavaField; class JavaMethod; class JavaObject; -class JavaJIT; class JnjvmModule; class Signdef; @@ -68,7 +67,7 @@ const llvm::Type * staticType; public: - llvm::Value* getVirtualSize(JavaJIT* jit); + llvm::Value* getVirtualSize(); llvm::Function* getStaticTracer(); llvm::Function* getVirtualTracer(); const llvm::Type* getVirtualType(); @@ -365,14 +364,14 @@ explicit JnjvmModule(const std::string &ModuleID); static void initialise(); - llvm::Value* getNativeClass(CommonClass* cl, JavaJIT* jit); - llvm::Value* getJavaClass(CommonClass* cl, JavaJIT* jit); - llvm::Value* getStaticInstance(Class* cl, JavaJIT* jit); - llvm::Value* getVirtualTable(CommonClass* cl, JavaJIT* jit); - - llvm::Value* getEnveloppe(Enveloppe* enveloppe, JavaJIT* jit); - llvm::Value* getString(JavaString* str, JavaJIT* jit); - llvm::Value* getConstantPool(JavaConstantPool* ctp, JavaJIT* jit); + llvm::Value* getNativeClass(CommonClass* cl); + llvm::Value* getJavaClass(CommonClass* cl); + llvm::Value* getStaticInstance(Class* cl); + llvm::Value* getVirtualTable(CommonClass* cl); + + llvm::Value* getEnveloppe(Enveloppe* enveloppe); + llvm::Value* getString(JavaString* str); + llvm::Value* getConstantPool(JavaConstantPool* ctp); private: static llvm::Module* initialModule; From nicolas.geoffray at lip6.fr Sun Oct 26 16:11:15 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 23:11:15 -0000 Subject: [vmkit-commits] [vmkit] r58214 - in /vmkit/trunk/lib/JnJVM/VMCore: JnjvmModule.cpp JnjvmModule.h Message-ID: <200810262311.m9QNBF3A024082@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 18:11:15 2008 New Revision: 58214 URL: http://llvm.org/viewvc/llvm-project?rev=58214&view=rev Log: Add a "staticCompilation" field to a JnjvmModule. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58214&r1=58213&r2=58214&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Sun Oct 26 18:11:15 2008 @@ -75,7 +75,7 @@ uint64_t (classDef)), JnjvmModule::JavaClassType); - varGV = new GlobalVariable(JnjvmModule::JavaClassType, true, + varGV = new GlobalVariable(JnjvmModule::JavaClassType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); @@ -95,7 +95,7 @@ Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), mvm::MvmModule::ptrPtrType); - varGV = new GlobalVariable(mvm::MvmModule::ptrPtrType, true, + varGV = new GlobalVariable(mvm::MvmModule::ptrPtrType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); constantPools.insert(std::make_pair(ctp, varGV)); @@ -115,7 +115,7 @@ Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), JnjvmModule::JavaObjectType); - varGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, + varGV = new GlobalVariable(JnjvmModule::JavaObjectType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); strings.insert(std::make_pair(str, varGV)); @@ -133,7 +133,7 @@ Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(ptr)), JnjvmModule::EnveloppeType); - varGV = new GlobalVariable(JnjvmModule::EnveloppeType, true, + varGV = new GlobalVariable(JnjvmModule::EnveloppeType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); enveloppes.insert(std::make_pair(enveloppe, varGV)); @@ -151,7 +151,7 @@ Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(obj)), JnjvmModule::JavaObjectType); - varGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, + varGV = new GlobalVariable(JnjvmModule::JavaObjectType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); @@ -174,7 +174,7 @@ ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t (obj)), JnjvmModule::JavaObjectType); - varGV = new GlobalVariable(JnjvmModule::JavaObjectType, true, + varGV = new GlobalVariable(JnjvmModule::JavaObjectType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); @@ -199,7 +199,7 @@ ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t(classDef->virtualVT)), JnjvmModule::VTType); - varGV = new GlobalVariable(JnjvmModule::VTType, true, + varGV = new GlobalVariable(JnjvmModule::VTType, !staticCompilation, GlobalValue::ExternalLinkage, cons, "", this); @@ -243,7 +243,11 @@ } else { ExecutionEngine* EE = mvm::MvmModule::executionEngine; // LLVM does not allow recursive compilation. Create the code now. - ((void**)VT)[0] = EE->getPointerToFunction(func); + if (staticCompilation) { + ((void**)VT)[0] = func; + } else { + ((void**)VT)[0] = EE->getPointerToFunction(func); + } } #endif } else { @@ -265,7 +269,11 @@ LLVMMethodInfo* LMI = getMethodInfo(&meth); Function* func = LMI->getMethod(); ExecutionEngine* EE = mvm::MvmModule::executionEngine; - ((void**)VT)[offset] = EE->getPointerToFunctionOrStub(func); + if (staticCompilation) { + ((void**)VT)[offset] = func; + } else { + ((void**)VT)[offset] = EE->getPointerToFunctionOrStub(func); + } } return VT; @@ -389,11 +397,15 @@ #ifdef WITH_TRACER llvm::Function* func = makeTracer(cl, stat); - - void* codePtr = mvm::MvmModule::executionEngine->getPointerToGlobal(func); - ((void**)res)[VT_TRACER_OFFSET] = codePtr; - func->deleteBody(); + if (staticCompilation) { + ((void**)res)[VT_TRACER_OFFSET] = func; + } else { + void* codePtr = mvm::MvmModule::executionEngine->getPointerToFunction(func); + ((void**)res)[VT_TRACER_OFFSET] = codePtr; + func->deleteBody(); + } + #endif return res; @@ -955,11 +967,14 @@ return getMethodInfo(meth)->getMethod(); } -JnjvmModule::JnjvmModule(const std::string &ModuleID) : MvmModule(ModuleID) { +JnjvmModule::JnjvmModule(const std::string &ModuleID, bool sc) : + MvmModule(ModuleID) { + std::string str = mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation(); setDataLayout(str); - + staticCompilation = sc; + Module* module = initialModule; InterfaceLookupFunction = module->getFunction("jnjvmVirtualLookup"); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58214&r1=58213&r2=58214&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Sun Oct 26 18:11:15 2008 @@ -208,13 +208,14 @@ enveloppe_iterator; + bool staticCompilation; llvm::Function* makeTracer(Class* cl, bool stat); VirtualTable* makeVT(Class* cl, bool stat); VirtualTable* allocateVT(Class* cl, uint32 index); - + public: static llvm::ConstantInt* JavaArraySizeOffsetConstant; @@ -361,7 +362,7 @@ static LLVMAssessorInfo& getTypedefInfo(Typedef* type); - explicit JnjvmModule(const std::string &ModuleID); + explicit JnjvmModule(const std::string &ModuleID, bool sc = false); static void initialise(); llvm::Value* getNativeClass(CommonClass* cl); From nicolas.geoffray at lip6.fr Sun Oct 26 16:49:13 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Sun, 26 Oct 2008 23:49:13 -0000 Subject: [vmkit-commits] [vmkit] r58219 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JnjvmModule.h Message-ID: <200810262349.m9QNnExm025297@zion.cs.uiuc.edu> Author: geoffray Date: Sun Oct 26 18:49:13 2008 New Revision: 58219 URL: http://llvm.org/viewvc/llvm-project?rev=58219&view=rev Log: Only getstatic/putstatic have different behaviors when static compiling. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.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=58219&r1=58218&r2=58219&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Sun Oct 26 18:49:13 2008 @@ -1836,8 +1836,22 @@ LLVMFieldInfo* LFI = module->getFieldInfo(field); const Type* type = 0; if (stat) { - + #ifndef ISOLATE_SHARING + if (module->isStaticCompiling()) { + // Do an initialization check first. + Value* Cl = module->getNativeClass(field->classDef); + Cl = new LoadInst(Cl, "", currentBlock); + Cl = invoke(module->InitialisationCheckFunction, Cl, "", + currentBlock); + CallInst::Create(module->ForceInitialisationCheckFunction, Cl, "", + currentBlock); + object = module->getStaticInstance(field->classDef); + object = new LoadInst(object, "", currentBlock); + type = LCI->getStaticType(); + return fieldGetter(this, type, object, LFI->getOffset()); + } + if (field->classDef->isReady()) { object = module->getStaticInstance(field->classDef); object = new LoadInst(object, "", currentBlock); @@ -1854,29 +1868,29 @@ } } - const Type* Pty = module->arrayPtrType; - Constant* zero = module->constantZero; + const Type* Pty = module->arrayPtrType; + Constant* zero = module->constantZero; - Function* func = stat ? module->StaticFieldLookupFunction : - module->VirtualFieldLookupFunction; + Function* func = stat ? module->StaticFieldLookupFunction : + module->VirtualFieldLookupFunction; - const Type* returnType = 0; - if (stat) - returnType = module->ptrType; - else - returnType = Type::Int32Ty; - - Value* ptr = getConstantPoolAt(index, func, returnType, 0, true); - if (!stat) { - Value* tmp = new BitCastInst(object, Pty, "", currentBlock); - std::vector args; - args.push_back(zero); - args.push_back(ptr); - ptr = GetElementPtrInst::Create(tmp, args.begin(), args.end(), "", - currentBlock); - } + const Type* returnType = 0; + if (stat) + returnType = module->ptrType; + else + returnType = Type::Int32Ty; + + Value* ptr = getConstantPoolAt(index, func, returnType, 0, true); + if (!stat) { + Value* tmp = new BitCastInst(object, Pty, "", currentBlock); + std::vector args; + args.push_back(zero); + args.push_back(ptr); + ptr = GetElementPtrInst::Create(tmp, args.begin(), args.end(), "", + currentBlock); + } - return new BitCastInst(ptr, fieldTypePtr, "", currentBlock); + return new BitCastInst(ptr, fieldTypePtr, "", currentBlock); } void JavaJIT::convertValue(Value*& val, const Type* t1, BasicBlock* currentBlock, Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58219&r1=58218&r2=58219&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Sun Oct 26 18:49:13 2008 @@ -217,7 +217,11 @@ public: - + + bool isStaticCompiling() { + return staticCompilation; + } + static llvm::ConstantInt* JavaArraySizeOffsetConstant; static llvm::ConstantInt* JavaArrayElementsOffsetConstant; static llvm::ConstantInt* JavaObjectLockOffsetConstant; From nicolas.geoffray at lip6.fr Mon Oct 27 09:13:20 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 16:13:20 -0000 Subject: [vmkit-commits] [vmkit] r58251 - in /vmkit/trunk: include/mvm/CompilationUnit.h lib/JnJVM/VMCore/JavaClass.cpp lib/JnJVM/VMCore/JavaConstantPool.cpp lib/JnJVM/VMCore/JavaJIT.h lib/JnJVM/VMCore/JavaTypes.cpp lib/JnJVM/VMCore/JavaUpcalls.cpp lib/JnJVM/VMCore/JnjvmClassLoader.cpp lib/JnJVM/VMCore/JnjvmClassLoader.h lib/JnJVM/VMCore/JnjvmModule.cpp lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Message-ID: <200810271613.m9RGDLec020727@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 11:13:20 2008 New Revision: 58251 URL: http://llvm.org/viewvc/llvm-project?rev=58251&view=rev Log: The llvm::Module is in the compilation unit. Modified: vmkit/trunk/include/mvm/CompilationUnit.h vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Modified: vmkit/trunk/include/mvm/CompilationUnit.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/CompilationUnit.h?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/include/mvm/CompilationUnit.h (original) +++ vmkit/trunk/include/mvm/CompilationUnit.h Mon Oct 27 11:13:20 2008 @@ -27,7 +27,6 @@ class CompilationUnit : public mvm::Object { public: llvm::Module* TheModule; - llvm::ModuleProvider* TheModuleProvider; }; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Mon Oct 27 11:13:20 2008 @@ -878,7 +878,7 @@ cl->loadParents(); cl->acquire(); cl->status = prepared; - classLoader->TheModule->resolveVirtualClass(cl); + classLoader->getModule()->resolveVirtualClass(cl); cl->status = resolved; } release(); @@ -981,5 +981,5 @@ } void Class::resolveStaticClass() { - classLoader->TheModule->resolveStaticClass((Class*)this); + classLoader->getModule()->resolveStaticClass((Class*)this); } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Oct 27 11:13:20 2008 @@ -413,7 +413,7 @@ false, 0); if (meth) { // don't throw if no meth, the exception will be thrown just in time - JnjvmModule* M = classDef->classLoader->TheModule; + JnjvmModule* M = classDef->classLoader->getModule(); void* F = M->getMethod(meth); return F; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.h Mon Oct 27 11:13:20 2008 @@ -68,7 +68,7 @@ nbEnveloppes = 0; compilingMethod = meth; compilingClass = meth->classDef; - module = compilingClass->classLoader->TheModule; + module = compilingClass->classLoader->getModule(); llvmFunction = func; inlining = false; callsStackWalker = false; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaTypes.cpp Mon Oct 27 11:13:20 2008 @@ -196,7 +196,7 @@ intptr_t Signdef::staticCallBuf() { if (!_staticCallBuf) { - LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this); + LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this); LSI->getStaticBuf(); } return _staticCallBuf; @@ -204,7 +204,7 @@ intptr_t Signdef::virtualCallBuf() { if (!_virtualCallBuf) { - LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this); + LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this); LSI->getVirtualBuf(); } return _virtualCallBuf; @@ -212,7 +212,7 @@ intptr_t Signdef::staticCallAP() { if (!_staticCallAP) { - LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this); + LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this); LSI->getStaticAP(); } return _staticCallAP; @@ -220,7 +220,7 @@ intptr_t Signdef::virtualCallAP() { if (!_virtualCallAP) { - LLVMSignatureInfo* LSI = initialLoader->TheModule->getSignatureInfo(this); + LLVMSignatureInfo* LSI = initialLoader->getModule()->getSignatureInfo(this); LSI->getVirtualAP(); } return _virtualCallAP; Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Mon Oct 27 11:13:20 2008 @@ -430,11 +430,11 @@ JavaMethod* internString = UPCALL_METHOD(loader, "java/lang/VMString", "intern", "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC); - loader->TheModule->setMethod(internString, "internString"); + loader->getModule()->setMethod(internString, "internString"); JavaMethod* isArray = UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL); - loader->TheModule->setMethod(isArray, "isArray"); + loader->getModule()->setMethod(isArray, "isArray"); UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException); @@ -594,17 +594,17 @@ JavaMethod* getCallingClass = UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass", "()Ljava/lang/Class;", ACC_STATIC); - loader->TheModule->setMethod(getCallingClass, "getCallingClass"); + loader->getModule()->setMethod(getCallingClass, "getCallingClass"); JavaMethod* getCallingClassLoader = UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClassLoader", "()Ljava/lang/ClassLoader;", ACC_STATIC); - loader->TheModule->setMethod(getCallingClassLoader, "getCallingClassLoader"); + loader->getModule()->setMethod(getCallingClassLoader, "getCallingClassLoader"); JavaMethod* postProperties = UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit", "(Ljava/util/Properties;)V", ACC_STATIC); - loader->TheModule->setMethod(postProperties, "propertiesPostInit"); + loader->getModule()->setMethod(postProperties, "propertiesPostInit"); } extern "C" JavaString* internString(JavaString* obj) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 27 11:13:20 2008 @@ -44,7 +44,7 @@ JnjvmModule::initialise(); TheModule = new JnjvmModule("Bootstrap JnJVM"); - TheModuleProvider = new JnjvmModuleProvider(TheModule); + TheModuleProvider = new JnjvmModuleProvider(getModule()); hashUTF8 = new(allocator) UTF8Map(allocator, 0); classes = new(allocator) ClassMap(); @@ -224,7 +224,7 @@ JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* I) { TheModule = new JnjvmModule("Applicative loader"); - TheModuleProvider = new JnjvmModuleProvider(TheModule); + TheModuleProvider = new JnjvmModuleProvider(getModule()); bootstrapLoader = JCL.bootstrapLoader; hashUTF8 = new(allocator) UTF8Map(allocator, Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Oct 27 11:13:20 2008 @@ -112,7 +112,9 @@ /// TheModule - JIT module for compiling methods. /// - JnjvmModule* TheModule; + JnjvmModule* getModule() { + return (JnjvmModule*)TheModule; + } /// TheModuleProvider - JIT module provider for dynamic class loading and /// lazy compilation. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Mon Oct 27 11:13:20 2008 @@ -444,7 +444,7 @@ field.ptrOffset = sl->getElementOffset(i + 1); } - JnjvmModule* Mod = classDef->classLoader->TheModule; + JnjvmModule* Mod = classDef->classLoader->getModule(); VirtualTable* VT = Mod->makeVT((Class*)classDef, false); uint64 size = mvm::MvmModule::getTypeSize(structType); @@ -484,7 +484,7 @@ } - JnjvmModule* Mod = cl->classLoader->TheModule; + JnjvmModule* Mod = cl->classLoader->getModule(); VirtualTable* VT = Mod->makeVT((Class*)classDef, true); uint64 size = mvm::MvmModule::getTypeSize(structType); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=58251&r1=58250&r2=58251&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Mon Oct 27 11:13:20 2008 @@ -151,7 +151,7 @@ } const llvm::FunctionType* type = 0; - JnjvmModule* M = cl->classLoader->TheModule; + JnjvmModule* M = cl->classLoader->getModule(); LLVMSignatureInfo* LSI = M->getSignatureInfo(sign); if (stat) { From nicolas.geoffray at lip6.fr Mon Oct 27 10:30:30 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 17:30:30 -0000 Subject: [vmkit-commits] [vmkit] r58254 - /vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Message-ID: <200810271730.m9RHUU3o023950@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 12:30:29 2008 New Revision: 58254 URL: http://llvm.org/viewvc/llvm-project?rev=58254&view=rev Log: Don't lookup twice when it's the bootstrap loader. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=58254&r1=58253&r2=58254&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaConstantPool.cpp Mon Oct 27 12:30:29 2008 @@ -306,7 +306,7 @@ assert(loader && "Class has no loader?"); const UTF8* name = UTF8At(ctpDef[index]); temp = loader->lookupClass(name); - if (!temp) + if (!temp && loader != loader->bootstrapLoader) temp = loader->bootstrapLoader->lookupClass(name); } #endif From nicolas.geoffray at lip6.fr Mon Oct 27 14:28:16 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 21:28:16 -0000 Subject: [vmkit-commits] [vmkit] r58274 - /vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Message-ID: <200810272128.m9RLSGMe000601@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 16:28:16 2008 New Revision: 58274 URL: http://llvm.org/viewvc/llvm-project?rev=58274&view=rev Log: Fix Typo. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58274&r1=58273&r2=58274&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 27 16:28:16 2008 @@ -314,7 +314,7 @@ if (!cl && doThrow) { Jnjvm* vm = JavaThread::get()->isolate; - if (!(name->equals(bootstrapLoader->NoClassDefFoundError))) { + if (name->equals(bootstrapLoader->NoClassDefFoundError)) { vm->unknownError("Unable to load NoClassDefFoundError"); } vm->noClassDefFoundError("unable to load %s", name->printString()); From nicolas.geoffray at lip6.fr Mon Oct 27 14:28:58 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 21:28:58 -0000 Subject: [vmkit-commits] [vmkit] r58275 - in /vmkit/trunk/lib/JnJVM/VMCore: Jnjvm.cpp VirtualTables.cpp Message-ID: <200810272128.m9RLSw5B000640@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 16:28:58 2008 New Revision: 58275 URL: http://llvm.org/viewvc/llvm-project?rev=58275&view=rev Log: Code cleanup. Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58275&r1=58274&r2=58275&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 27 16:28:58 2008 @@ -747,12 +747,13 @@ info.readArgs(argc, argv, this); if (info.className) { int pos = info.appArgumentsPos; - //llvm::cl::ParseCommandLineOptions(pos, argv, - // " JnJVM Java Virtual Machine\n"); + argv = argv + pos - 1; argc = argc - pos + 1; - - bootstrapThread = gc_new(JavaThread)(0, this, mvm::Thread::get()->baseSP); + + mvm::Thread* oldThread = mvm::Thread::get(); + JavaThread thread(0, this, oldThread->baseSP); + bootstrapThread = &thread; loadBootstrap(); @@ -779,6 +780,7 @@ executeClass(info.className, args); waitForExit(); + mvm::Thread::set(oldThread); } } Modified: vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp?rev=58275&r1=58274&r2=58275&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Mon Oct 27 16:28:58 2008 @@ -117,7 +117,6 @@ void Jnjvm::TRACER { appClassLoader->MARK_AND_TRACE; TRACE_VECTOR(JavaObject*, gc_allocator, globalRefs); - bootstrapThread->MARK_AND_TRACE; bootstrapLoader->MARK_AND_TRACE; #if defined(ISOLATE_SHARING) JnjvmSharedLoader::sharedLoader->MARK_AND_TRACE; From nicolas.geoffray at lip6.fr Mon Oct 27 15:34:19 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 22:34:19 -0000 Subject: [vmkit-commits] [vmkit] r58287 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaThread.cpp JavaThread.h Message-ID: <200810272234.m9RMYJvl002928@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 17:34:19 2008 New Revision: 58287 URL: http://llvm.org/viewvc/llvm-project?rev=58287&view=rev Log: Who knew that gcc compiles the throw keyword differently if you declare the __cxa_throw function? Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp?rev=58287&r1=58286&r2=58287&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.cpp Mon Oct 27 17:34:19 2008 @@ -19,6 +19,7 @@ #include "JavaThread.h" #include "Jnjvm.h" + using namespace jnjvm; const unsigned int JavaThread::StateRunning = 0; @@ -78,3 +79,27 @@ #endif } } + +// We define these here because gcc compiles the 'throw' keyword +// differently, whether these are defined in a file or not. Since many +// cpp files import JavaThread.h, they couldn't use the keyword. + +extern "C" void* __cxa_allocate_exception(unsigned); +extern "C" void __cxa_throw(void*, void*, void*); + +void JavaThread::throwException(JavaObject* obj) { + JavaThread* th = JavaThread::get(); + assert(th->pendingException == 0 && "pending exception already there?"); + th->pendingException = obj; + void* exc = __cxa_allocate_exception(0); + th->internalPendingException = exc; + __cxa_throw(exc, 0, 0); +} + +void JavaThread::throwPendingException() { + JavaThread* th = JavaThread::get(); + assert(th->pendingException); + void* exc = __cxa_allocate_exception(0); + th->internalPendingException = exc; + __cxa_throw(exc, 0, 0); +} Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h?rev=58287&r1=58286&r2=58287&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaThread.h Mon Oct 27 17:34:19 2008 @@ -20,9 +20,6 @@ #include "JavaObject.h" -extern "C" void* __cxa_allocate_exception(unsigned); -extern "C" void __cxa_throw(void*, void*, void*); - namespace jnjvm { class Class; @@ -69,23 +66,14 @@ return (void*) ((char*)JavaThread::get()->internalPendingException - 8 * sizeof(void*)); } - - static void throwException(JavaObject* obj) { - JavaThread* th = JavaThread::get(); - assert(th->pendingException == 0 && "pending exception already there?"); - th->pendingException = obj; - void* exc = __cxa_allocate_exception(0); - th->internalPendingException = exc; - __cxa_throw(exc, 0, 0); - } - - static void throwPendingException() { - JavaThread* th = JavaThread::get(); - assert(th->pendingException); - void* exc = __cxa_allocate_exception(0); - th->internalPendingException = exc; - __cxa_throw(exc, 0, 0); - } + + /// throwException - Throws the given exception in the current thread. + /// + static void throwException(JavaObject* obj); + + /// throwPendingException - Throws a pending exception created by JNI. + /// + static void throwPendingException(); static bool compareException(UserClass* cl) { JavaObject* pe = JavaThread::get()->pendingException; From nicolas.geoffray at lip6.fr Mon Oct 27 15:38:22 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 22:38:22 -0000 Subject: [vmkit-commits] [vmkit] r58288 - /vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Message-ID: <200810272238.m9RMcMou003061@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 17:38:22 2008 New Revision: 58288 URL: http://llvm.org/viewvc/llvm-project?rev=58288&view=rev Log: No need to trace archives, they are allocated in permanent memory. 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=58288&r1=58287&r2=58288&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/VirtualTables.cpp Mon Oct 27 17:38:22 2008 @@ -140,10 +140,6 @@ void JnjvmBootstrapLoader::TRACER { traceClassMap(classes); - for (std::vector::iterator i = bootArchives.begin(), - e = bootArchives.end(); i != e; ++i) { - (*i)->bytes->MARK_AND_TRACE; - } #define TRACE_DELEGATEE(prim) \ prim->delegatee->MARK_AND_TRACE @@ -157,6 +153,7 @@ TRACE_DELEGATEE(upcalls->OfLong); TRACE_DELEGATEE(upcalls->OfDouble); #undef TRACE_DELEGATEE + TRACE_VECTOR(JavaString*, gc_allocator, strings); } From nicolas.geoffray at lip6.fr Mon Oct 27 16:56:29 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Mon, 27 Oct 2008 23:56:29 -0000 Subject: [vmkit-commits] [vmkit] r58302 - in /vmkit/trunk: include/mvm/CompilationUnit.h include/mvm/VirtualMachine.h lib/JnJVM/VMCore/JavaInitialise.cpp lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/Jnjvm.h lib/JnJVM/VMCore/JnjvmClassLoader.cpp lib/JnJVM/VMCore/JnjvmClassLoader.h lib/JnJVM/VMCore/JnjvmModule.cpp lib/JnJVM/VMCore/JnjvmModule.h lib/N3/VMCore/N3.h lib/N3/VMCore/N3Initialise.cpp lib/N3/VMCore/VirtualMachine.h tools/Makefile tools/vmjc/ tools/vmjc/Makefile tools/vmjc/vmjc.cpp Message-ID: <200810272356.m9RNuUHZ005876@zion.cs.uiuc.edu> Author: geoffray Date: Mon Oct 27 18:56:29 2008 New Revision: 58302 URL: http://llvm.org/viewvc/llvm-project?rev=58302&view=rev Log: New tool in VMKit, a static Java compiler! Added: vmkit/trunk/tools/vmjc/ vmkit/trunk/tools/vmjc/Makefile (with props) vmkit/trunk/tools/vmjc/vmjc.cpp Modified: vmkit/trunk/include/mvm/CompilationUnit.h vmkit/trunk/include/mvm/VirtualMachine.h vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.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/JnjvmClassLoader.h vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h vmkit/trunk/lib/N3/VMCore/N3.h vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp vmkit/trunk/lib/N3/VMCore/VirtualMachine.h vmkit/trunk/tools/Makefile Modified: vmkit/trunk/include/mvm/CompilationUnit.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/CompilationUnit.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/include/mvm/CompilationUnit.h (original) +++ vmkit/trunk/include/mvm/CompilationUnit.h Mon Oct 27 18:56:29 2008 @@ -27,7 +27,6 @@ class CompilationUnit : public mvm::Object { public: llvm::Module* TheModule; - }; } Modified: vmkit/trunk/include/mvm/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/VirtualMachine.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/include/mvm/VirtualMachine.h (original) +++ vmkit/trunk/include/mvm/VirtualMachine.h Mon Oct 27 18:56:29 2008 @@ -30,8 +30,12 @@ /// runApplication - Run an application. The application name is in /// the arguments, hence it is the virtual machine's job to parse them. virtual void runApplication(int argc, char** argv) = 0; + + /// compile - Compile a given file to LLVM. + virtual void compile(const char* name) = 0; + - static CompilationUnit* initialiseJVM(); + static CompilationUnit* initialiseJVM(bool staticCompilation = false); static VirtualMachine* createJVM(CompilationUnit* C = 0); static CompilationUnit* initialiseCLIVM(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaInitialise.cpp Mon Oct 27 18:56:29 2008 @@ -62,22 +62,23 @@ } #ifdef ISOLATE_SHARING -mvm::CompilationUnit* mvm::VirtualMachine::initialiseJVM() { +mvm::CompilationUnit* mvm::VirtualMachine::initialiseJVM(bool sc) { initialiseVT(); JnjvmSharedLoader::sharedLoader = JnjvmSharedLoader::createSharedLoader(); return JnjvmSharedLoader::sharedLoader; } mvm::VirtualMachine* mvm::VirtualMachine::createJVM(mvm::CompilationUnit* C) { - JnjvmBootstraLoader* bootstrapLoader = gc_new(JnjvmBootstrapLoader)(0); + JnjvmBootstraLoader* bootstrapLoader = gc_new(JnjvmBootstrapLoader)(false); Jnjvm* vm = gc_new(Jnjvm)(bootstrapLoader); return vm; } #else -mvm::CompilationUnit* mvm::VirtualMachine::initialiseJVM() { +mvm::CompilationUnit* +mvm::VirtualMachine::initialiseJVM(bool staticCompilation) { initialiseVT(); - return gc_new(JnjvmBootstrapLoader)(0); + return gc_new(JnjvmBootstrapLoader)(staticCompilation); } mvm::VirtualMachine* mvm::VirtualMachine::createJVM(mvm::CompilationUnit* C) { Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Oct 27 18:56:29 2008 @@ -135,9 +135,13 @@ vsnprintf(tmp, 4096, fmt, ap); va_end(ap); - JavaObject* obj = cl->doNew(this); - init->invokeIntSpecial(this, cl, obj, asciizToStr(tmp)); - JavaThread::throwException(obj); + if (cl && !bootstrapLoader->getModule()->isStaticCompiling()) { + JavaObject* obj = cl->doNew(this); + init->invokeIntSpecial(this, cl, obj, asciizToStr(tmp)); + JavaThread::throwException(obj); + } else { + throw std::string(tmp); + } } void Jnjvm::arrayStoreException() { @@ -253,10 +257,10 @@ obj); } -void Jnjvm::noClassDefFoundError(const char* fmt, ...) { +void Jnjvm::noClassDefFoundError(const UTF8* name) { error(upcalls->NoClassDefFoundError, upcalls->InitNoClassDefFoundError, - fmt); + "Unable to load %s", name->UTF8ToAsciiz()); } void Jnjvm::classNotFoundException(JavaString* str) { @@ -824,3 +828,34 @@ } return (const UTF8*)tmp; } + + +void Jnjvm::compile(const char* name) { + bootstrapLoader->analyseClasspathEnv(classpath); + + mvm::Thread* oldThread = mvm::Thread::get(); + JavaThread thread(0, this, oldThread->baseSP); + bootstrapThread = &thread; + + + + const UTF8* utf8 = bootstrapLoader->asciizConstructUTF8(name); + UserClass* cl = bootstrapLoader->loadName(utf8, true, true); + + for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) { + JavaMethod& meth = cl->virtualMethods[i]; + bootstrapLoader->TheModuleProvider->parseFunction(&meth); + } + + for (uint32 i = 0; i < cl->nbStaticMethods; ++i) { + JavaMethod& meth = cl->staticMethods[i]; + bootstrapLoader->TheModuleProvider->parseFunction(&meth); + } + + llvm::Module* M = bootstrapLoader->getModule(); + for (Module::iterator i = M->begin(), e = M->end(); i != e; ++i) { + i->setLinkage(llvm::GlobalValue::ExternalLinkage); + } + + mvm::Thread::set(oldThread); +} Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.h Mon Oct 27 18:56:29 2008 @@ -242,7 +242,7 @@ void noSuchMethodError(CommonClass* cl, const UTF8* name); void classFormatError(const char* fmt, ...); void noClassDefFoundError(JavaObject* obj); - void noClassDefFoundError(const char* fmt, ...); + void noClassDefFoundError(const UTF8* name); void classNotFoundException(JavaString* str); /// asciizToStr - Constructs a java/lang/String object from the given asciiz. @@ -296,6 +296,10 @@ /// virtual void runApplication(int argc, char** argv); + /// compile - Compile the .class, .zip or .jar file to LLVM IR. + /// + virtual void compile(const char* name); + }; } // 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=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Mon Oct 27 18:56:29 2008 @@ -40,11 +40,12 @@ extern const char* GNUClasspathGlibj; extern const char* GNUClasspathLibs; -JnjvmBootstrapLoader::JnjvmBootstrapLoader(uint32 memLimit) { +JnjvmBootstrapLoader::JnjvmBootstrapLoader(bool staticCompilation) { JnjvmModule::initialise(); TheModule = new JnjvmModule("Bootstrap JnJVM"); TheModuleProvider = new JnjvmModuleProvider(getModule()); + getModule()->setIsStaticCompiling(staticCompilation); hashUTF8 = new(allocator) UTF8Map(allocator, 0); classes = new(allocator) ClassMap(); @@ -317,7 +318,7 @@ if (name->equals(bootstrapLoader->NoClassDefFoundError)) { vm->unknownError("Unable to load NoClassDefFoundError"); } - vm->noClassDefFoundError("unable to load %s", name->printString()); + vm->noClassDefFoundError(name); } if (cl && doResolve) cl->resolveClass(); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.h Mon Oct 27 18:56:29 2008 @@ -285,7 +285,7 @@ /// createBootstrapLoader - Creates the bootstrap loader, first thing /// to do before any execution of a JVM. /// - JnjvmBootstrapLoader(uint32 memLimit); + JnjvmBootstrapLoader(bool staticCompilation); JnjvmBootstrapLoader() {} virtual JavaString* UTF8ToStr(const UTF8* utf8); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Mon Oct 27 18:56:29 2008 @@ -444,13 +444,15 @@ field.ptrOffset = sl->getElementOffset(i + 1); } - JnjvmModule* Mod = classDef->classLoader->getModule(); - VirtualTable* VT = Mod->makeVT((Class*)classDef, false); - uint64 size = mvm::MvmModule::getTypeSize(structType); classDef->virtualSize = (uint32)size; - classDef->virtualVT = VT; virtualSizeConstant = ConstantInt::get(Type::Int32Ty, size); + + JnjvmModule* Mod = classDef->classLoader->getModule(); + if (!Mod->isStaticCompiling()) { + classDef->virtualVT = Mod->makeVT((Class*)classDef, false); + } + } @@ -483,13 +485,13 @@ field.ptrOffset = sl->getElementOffset(i + 1); } - - JnjvmModule* Mod = cl->classLoader->getModule(); - VirtualTable* VT = Mod->makeVT((Class*)classDef, true); - uint64 size = mvm::MvmModule::getTypeSize(structType); cl->staticSize = size; - cl->staticVT = VT; + + JnjvmModule* Mod = cl->classLoader->getModule(); + if (!Mod->isStaticCompiling()) { + cl->staticVT = Mod->makeVT((Class*)classDef, true); + } } return staticType; } Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Mon Oct 27 18:56:29 2008 @@ -222,6 +222,10 @@ return staticCompilation; } + void setIsStaticCompiling(bool sc) { + staticCompilation = sc; + } + static llvm::ConstantInt* JavaArraySizeOffsetConstant; static llvm::ConstantInt* JavaArrayElementsOffsetConstant; static llvm::ConstantInt* JavaObjectLockOffsetConstant; Modified: vmkit/trunk/lib/N3/VMCore/N3.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3.h (original) +++ vmkit/trunk/lib/N3/VMCore/N3.h Mon Oct 27 18:56:29 2008 @@ -79,7 +79,7 @@ static const UTF8* floatName; static const UTF8* doubleName; static const UTF8* testInfinity; - + }; } // end namespace n3 Modified: vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp (original) +++ vmkit/trunk/lib/N3/VMCore/N3Initialise.cpp Mon Oct 27 18:56:29 2008 @@ -341,6 +341,10 @@ ((N3*)this)->runMain(argc, argv); } +void VirtualMachine::compile(const char* argv) { + assert(0 && "This virtual machine does not perform static compilation yet!\n"); +} + mvm::VirtualMachine* mvm::VirtualMachine::createCLIVM(mvm::CompilationUnit* C) { N3* vm = N3::allocate("", N3::bootstrapVM); return vm; Modified: vmkit/trunk/lib/N3/VMCore/VirtualMachine.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/N3/VMCore/VirtualMachine.h?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/lib/N3/VMCore/VirtualMachine.h (original) +++ vmkit/trunk/lib/N3/VMCore/VirtualMachine.h Mon Oct 27 18:56:29 2008 @@ -127,6 +127,7 @@ VMThread* bootstrapThread; virtual void runApplication(int argc, char** argv); + virtual void compile(const char* name); }; Modified: vmkit/trunk/tools/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/Makefile?rev=58302&r1=58301&r2=58302&view=diff ============================================================================== --- vmkit/trunk/tools/Makefile (original) +++ vmkit/trunk/tools/Makefile Mon Oct 27 18:56:29 2008 @@ -8,7 +8,7 @@ ##===----------------------------------------------------------------------===## LEVEL = .. -PARALLEL_DIRS = vmkit +PARALLEL_DIRS = vmkit vmjc include $(LEVEL)/Makefile.config Added: vmkit/trunk/tools/vmjc/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/Makefile?rev=58302&view=auto ============================================================================== --- vmkit/trunk/tools/vmjc/Makefile (added) +++ vmkit/trunk/tools/vmjc/Makefile Mon Oct 27 18:56:29 2008 @@ -0,0 +1,21 @@ +##===- tools/vmjc/Makefile --------------------------------*- Makefile -*-===## +# +# The VMKit project +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## +LEVEL = ../.. + +include $(LEVEL)/Makefile.config + +TOOLNAME = vmjc +USEDLIBS = Allocator CommonThread Mvm JnJVM Classpath $(GCLIB) +LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo + +ifeq ($(ISOLATE_BUILD), 1) + USEDLIBS += Isolate +endif + +include $(LEVEL)/Makefile.common Propchange: vmkit/trunk/tools/vmjc/Makefile ------------------------------------------------------------------------------ svn:executable = * Added: vmkit/trunk/tools/vmjc/vmjc.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=58302&view=auto ============================================================================== --- vmkit/trunk/tools/vmjc/vmjc.cpp (added) +++ vmkit/trunk/tools/vmjc/vmjc.cpp Mon Oct 27 18:56:29 2008 @@ -0,0 +1,145 @@ +//===----------------- vmjc.cpp - Java static compiler --------------------===// +// +// The VMKit project +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This utility may be invoked in the following manner: +// vmjc [options] x.bc - Read Java bytecode from the x.class file, write llvm +// asm to the x.ll file. +// Options: +// --help - Output information about command line switches +// +//===----------------------------------------------------------------------===// + +#include "llvm/Module.h" +#include "llvm/PassManager.h" +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/Assembly/PrintModulePass.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/Streams.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/System/Signals.h" + +#include "MvmGC.h" +#include "mvm/JIT.h" +#include "mvm/Object.h" +#include "mvm/VirtualMachine.h" +#include "mvm/Threads/Thread.h" + +#include +#include +#include + +using namespace llvm; + +static cl::opt +InputFilename(cl::Positional, cl::desc(""), cl::init("-")); + +static cl::opt +OutputFilename("o", cl::desc("Override output filename"), + cl::value_desc("filename")); + +static cl::opt +Force("f", cl::desc("Overwrite output files")); + +static cl::opt +DontPrint("disable-output", cl::desc("Don't output the .ll file"), cl::Hidden); + +int main(int argc, char **argv) { + llvm_shutdown_obj X; // Call llvm_shutdown() on exit. + int base; + try { + cl::ParseCommandLineOptions(argc, argv, "vmkit .class -> .ll compiler\n"); + sys::PrintStackTraceOnErrorSignal(); + + std::ostream *Out = &std::cout; // Default to printing to stdout. + std::string ErrorMessage; + + + if (InputFilename == "-") { + cl::PrintHelpMessage(); + return 0; + } + + mvm::MvmModule::initialise(); + mvm::Object::initialise(); + mvm::Thread::initialise(); + Collector::initialise(0, &base); + + mvm::CompilationUnit* CU = mvm::VirtualMachine::initialiseJVM(true); + mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(CU); + vm->compile(InputFilename.c_str()); + + + if (DontPrint) { + // Just use stdout. We won't actually print anything on it. + } else if (OutputFilename != "") { // Specified an output filename? + if (OutputFilename != "-") { // Not stdout? + if (!Force && std::ifstream(OutputFilename.c_str())) { + // If force is not specified, make sure not to overwrite a file! + cerr << argv[0] << ": error opening '" << OutputFilename + << "': file exists! Sending to standard output.\n"; + } else { + Out = new std::ofstream(OutputFilename.c_str()); + } + } + } else { + if (InputFilename == "-") { + OutputFilename = "-"; + } else { + std::string IFN = InputFilename; + int Len = IFN.length(); + if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') { + // Source ends in .bc + OutputFilename = std::string(IFN.begin(), IFN.end()-3)+".ll"; + } else { + OutputFilename = IFN+".ll"; + } + + if (!Force && std::ifstream(OutputFilename.c_str())) { + // If force is not specified, make sure not to overwrite a file! + cerr << argv[0] << ": error opening '" << OutputFilename + << "': file exists! Sending to standard output.\n"; + } else { + Out = new std::ofstream(OutputFilename.c_str()); + + // Make sure that the Out file gets unlinked from the disk if we get a + // SIGINT + sys::RemoveFileOnSignal(sys::Path(OutputFilename)); + } + } + } + + if (!Out->good()) { + cerr << argv[0] << ": error opening " << OutputFilename + << ": sending to stdout instead!\n"; + Out = &std::cout; + } + + // All that llvm-dis does is write the assembly to a file. + if (!DontPrint) { + PassManager Passes; + raw_os_ostream L(*Out); + Passes.add(createPrintModulePass(&L)); + Passes.run(*CU->TheModule); + } + + if (Out != &std::cout) { + ((std::ofstream*)Out)->close(); + delete Out; + } + return 0; + } catch (const std::string& msg) { + cerr << argv[0] << ": " << msg << "\n"; + } catch (...) { + cerr << argv[0] << ": Unexpected unknown exception occurred.\n"; + } + return 1; +} + From nicolas.geoffray at lip6.fr Tue Oct 28 04:47:02 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 28 Oct 2008 11:47:02 -0000 Subject: [vmkit-commits] [vmkit] r58325 - /vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Message-ID: <200810281147.m9SBl2XW017923@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 28 06:47:00 2008 New Revision: 58325 URL: http://llvm.org/viewvc/llvm-project?rev=58325&view=rev Log: Change the PHI nodes of a normal dest when the changed instruction is an InvokeInst. 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=58325&r1=58324&r2=58325&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Oct 28 06:47:00 2008 @@ -278,6 +278,16 @@ PHI->addIncoming(Val, falseCl); Temp++; } + + // And here we set the phi nodes of the normal dest of the Invoke + // instruction. The phi nodes have now the trueCl as basic block. + Temp = NBB->getInstList().begin(); + while (PHINode* PHI = dyn_cast(Temp)) { + Value* Val = PHI->getIncomingValueForBlock(CI->getParent()); + PHI->removeIncomingValue(CI->getParent(), false); + PHI->addIncoming(Val, trueCl); + Temp++; + } } else { res = CallInst::Create(module->InitialiseClassFunction, Args.begin(), Args.end(), "", @@ -351,6 +361,17 @@ PHI->addIncoming(Val, falseCl); Temp++; } + + // And here we set the phi nodes of the normal dest of the Invoke + // instruction. The phi nodes have now the trueCl as basic block. + Temp = NBB->getInstList().begin(); + while (PHINode* PHI = dyn_cast(Temp)) { + Value* Val = PHI->getIncomingValueForBlock(CI->getParent()); + PHI->removeIncomingValue(CI->getParent(), false); + PHI->addIncoming(Val, trueCl); + Temp++; + } + } else { res = CallInst::Create(resolver, Args.begin(), Args.end(), "", falseCl); From nicolas.geoffray at lip6.fr Tue Oct 28 05:07:40 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 28 Oct 2008 12:07:40 -0000 Subject: [vmkit-commits] [vmkit] r58327 - in /vmkit/trunk/lib/JnJVM/VMCore: JavaJIT.cpp JnjvmModule.cpp JnjvmModule.h Message-ID: <200810281207.m9SC7eQB018600@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 28 07:07:40 2008 New Revision: 58327 URL: http://llvm.org/viewvc/llvm-project?rev=58327&view=rev Log: Provide a global variable wrapper for native functions, so that we do not use IntToPtr instructions. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.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=58327&r1=58326&r2=58327&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Oct 28 07:07:40 2008 @@ -181,11 +181,19 @@ natPtr = natPtr ? natPtr : NativeUtil::nativeLookup(compilingClass, compilingMethod, jnjvm); + if (!natPtr && !module->isStaticCompiling()) { + fprintf(stderr, "Native function %s not found. Probably " + "not implemented by JnJVM?\n", compilingMethod->printString()); + JavaJIT::printBacktrace(); + JavaThread::get()->isolate->unknownError("can not find native method %s", + compilingMethod->printString()); + } Function* func = llvmFunction; if (jnjvm) { - module->executionEngine->addGlobalMapping(func, natPtr); + if (!module->isStaticCompiling()) + module->executionEngine->addGlobalMapping(func, natPtr); return llvmFunction; } @@ -282,15 +290,10 @@ nativeArgs.push_back(i); } - - LLVMSignatureInfo* LSI = - module->getSignatureInfo(compilingMethod->getSignature()); - const llvm::Type* valPtrType = LSI->getNativePtrType(); - Value* valPtr = - ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, (uint64)natPtr), - valPtrType); + Value* nativeFunc = module->getNativeFunction(compilingMethod, natPtr); + nativeFunc = new LoadInst(nativeFunc, "", currentBlock); - Value* result = llvm::CallInst::Create(valPtr, nativeArgs.begin(), + Value* result = llvm::CallInst::Create(nativeFunc, nativeArgs.begin(), nativeArgs.end(), "", currentBlock); if (returnType != Type::VoidTy) Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58327&r1=58326&r2=58327&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Oct 28 07:07:40 2008 @@ -147,7 +147,8 @@ java_class_iterator I = javaClasses.find(cl); if (I == End) { - JavaObject* obj = cl->getClassDelegatee(JavaThread::get()->isolate); + JavaObject* obj = isStaticCompiling() ? 0 : + cl->getClassDelegatee(JavaThread::get()->isolate); Constant* cons = ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64(obj)), JnjvmModule::JavaObjectType); @@ -210,6 +211,31 @@ return varGV; } +Value* JnjvmModule::getNativeFunction(JavaMethod* meth, void* ptr) { + llvm::GlobalVariable* 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(); + + Constant* cons = + ConstantExpr::getIntToPtr(ConstantInt::get(Type::Int64Ty, uint64_t(ptr)), + valPtrType); + + varGV = new GlobalVariable(valPtrType, !staticCompilation, + GlobalValue::ExternalLinkage, + cons, "", this); + + nativeFunctions.insert(std::make_pair(meth, varGV)); + } else { + varGV = I->second; + } + return varGV; +} + #ifndef WITHOUT_VTABLE VirtualTable* JnjvmModule::allocateVT(Class* cl, uint32 index) { Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58327&r1=58326&r2=58327&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Tue Oct 28 07:07:40 2008 @@ -185,6 +185,7 @@ std::map constantPools; std::map strings; std::map enveloppes; + std::map nativeFunctions; typedef std::map::iterator native_class_iterator; @@ -207,6 +208,9 @@ typedef std::map::iterator enveloppe_iterator; + typedef std::map::iterator + native_function_iterator; + bool staticCompilation; @@ -381,6 +385,7 @@ llvm::Value* getEnveloppe(Enveloppe* enveloppe); llvm::Value* getString(JavaString* str); llvm::Value* getConstantPool(JavaConstantPool* ctp); + llvm::Value* getNativeFunction(JavaMethod* meth, void* natPtr); private: static llvm::Module* initialModule; From nicolas.geoffray at lip6.fr Tue Oct 28 05:31:41 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 28 Oct 2008 12:31:41 -0000 Subject: [vmkit-commits] [vmkit] r58328 - /vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Message-ID: <200810281231.m9SCVfBp019395@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 28 07:31:40 2008 New Revision: 58328 URL: http://llvm.org/viewvc/llvm-project?rev=58328&view=rev Log: And ending ATHROW may as well be an invoke when the function is 'synchronized'. 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=58328&r1=58327&r2=58328&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaJIT.cpp Tue Oct 28 07:31:40 2008 @@ -855,9 +855,17 @@ pred_iterator PE = pred_end(endBlock); if (PI == PE && returnType != Type::VoidTy) { Instruction* I = currentBlock->getTerminator(); - assert(isa(I) && "non terminator before buggy return"); - I->eraseFromParent(); - BranchInst::Create(endBlock, currentBlock); + + assert((isa(I) || isa(I)) && + "Malformed end Java block"); + + if (isa(I)) { + I->eraseFromParent(); + BranchInst::Create(endBlock, currentBlock); + } else if (InvokeInst* II = dyn_cast(I)) { + II->setNormalDest(endBlock); + } + endNode->addIncoming(Constant::getNullValue(returnType), currentBlock); } From nicolas.geoffray at lip6.fr Tue Oct 28 10:15:43 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 28 Oct 2008 17:15:43 -0000 Subject: [vmkit-commits] [vmkit] r58333 - in /vmkit/trunk/lib/JnJVM/VMCore: JnjvmClassLoader.cpp JnjvmModule.cpp JnjvmModule.h Message-ID: <200810281715.m9SHFims030484@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 28 12:15:43 2008 New Revision: 58333 URL: http://llvm.org/viewvc/llvm-project?rev=58333&view=rev Log: The initial module is the bootstrap loader. Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=58333&r1=58332&r2=58333&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Tue Oct 28 12:15:43 2008 @@ -42,7 +42,6 @@ JnjvmBootstrapLoader::JnjvmBootstrapLoader(bool staticCompilation) { - JnjvmModule::initialise(); TheModule = new JnjvmModule("Bootstrap JnJVM"); TheModuleProvider = new JnjvmModuleProvider(getModule()); getModule()->setIsStaticCompiling(staticCompilation); Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=58333&r1=58332&r2=58333&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Oct 28 12:15:43 2008 @@ -909,9 +909,9 @@ Module* JnjvmModule::initialModule; void JnjvmModule::initialise() { - initialModule = new Module("Initial jnjvm module"); - jnjvm::llvm_runtime::makeLLVMModuleContents(initialModule); - Module* module = initialModule; + jnjvm::llvm_runtime::makeLLVMModuleContents(this); + Module* module = this; + initialModule = this; VTType = module->getTypeByName("VT"); @@ -1002,6 +1002,7 @@ mvm::MvmModule::executionEngine->getTargetData()->getStringRepresentation(); setDataLayout(str); staticCompilation = sc; + if (!VTType) initialise(); Module* module = initialModule; Modified: vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h?rev=58333&r1=58332&r2=58333&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JnjvmModule.h Tue Oct 28 12:15:43 2008 @@ -375,7 +375,7 @@ static LLVMAssessorInfo& getTypedefInfo(Typedef* type); explicit JnjvmModule(const std::string &ModuleID, bool sc = false); - static void initialise(); + void initialise(); llvm::Value* getNativeClass(CommonClass* cl); llvm::Value* getJavaClass(CommonClass* cl); From nicolas.geoffray at lip6.fr Tue Oct 28 10:16:42 2008 From: nicolas.geoffray at lip6.fr (Nicolas Geoffray) Date: Tue, 28 Oct 2008 17:16:42 -0000 Subject: [vmkit-commits] [vmkit] r58334 - in /vmkit/trunk: lib/JnJVM/VMCore/JavaClass.cpp lib/JnJVM/VMCore/JavaClass.h lib/JnJVM/VMCore/Jnjvm.cpp lib/JnJVM/VMCore/NativeUtil.cpp lib/JnJVM/VMCore/Reader.cpp lib/JnJVM/VMCore/Reader.h lib/JnJVM/VMCore/Zip.h tools/vmjc/Makefile tools/vmjc/vmjc.cpp Message-ID: <200810281716.m9SHGg6F030588@zion.cs.uiuc.edu> Author: geoffray Date: Tue Oct 28 12:16:42 2008 New Revision: 58334 URL: http://llvm.org/viewvc/llvm-project?rev=58334&view=rev Log: New fixes for static compilation. Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp vmkit/trunk/lib/JnJVM/VMCore/Reader.h vmkit/trunk/lib/JnJVM/VMCore/Zip.h vmkit/trunk/tools/vmjc/Makefile vmkit/trunk/tools/vmjc/vmjc.cpp Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.cpp Tue Oct 28 12:16:42 2008 @@ -520,7 +520,8 @@ JavaObject* UserClass::doNew(Jnjvm* vm) { assert(this && "No class when allocating."); - assert(this->isReady() && "Uninitialized class when allocating."); + assert((this->isReady() || classLoader->getModule()->isStaticCompiling()) + && "Uninitialized class when allocating."); JavaObject* res = (JavaObject*)vm->gcAllocator.allocateManagedObject(getVirtualSize(), getVirtualVT()); Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/JavaClass.h Tue Oct 28 12:16:42 2008 @@ -660,8 +660,10 @@ /// class ClassArray : public CommonClass { - /// Reader is a friend because it allocates arrays without a vm. + /// Reader and Jnjvm are friends because they may allocate arrays without + /// a vm. friend class Reader; + friend class Jnjvm; private: /// doNew - Allocate a new array with the given allocator. /// Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Tue Oct 28 12:16:42 2008 @@ -830,6 +830,22 @@ } +static void compileClass(Class* cl) { + + for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) { + JavaMethod& meth = cl->virtualMethods[i]; + if (!isAbstract(meth.access)) + cl->classLoader->TheModuleProvider->parseFunction(&meth); + } + + for (uint32 i = 0; i < cl->nbStaticMethods; ++i) { + JavaMethod& meth = cl->staticMethods[i]; + if (!isAbstract(meth.access)) + cl->classLoader->TheModuleProvider->parseFunction(&meth); + } +} + + void Jnjvm::compile(const char* name) { bootstrapLoader->analyseClasspathEnv(classpath); @@ -837,21 +853,62 @@ JavaThread thread(0, this, oldThread->baseSP); bootstrapThread = &thread; - - - const UTF8* utf8 = bootstrapLoader->asciizConstructUTF8(name); - UserClass* cl = bootstrapLoader->loadName(utf8, true, true); - for (uint32 i = 0; i < cl->nbVirtualMethods; ++i) { - JavaMethod& meth = cl->virtualMethods[i]; - bootstrapLoader->TheModuleProvider->parseFunction(&meth); - } + uint32 size = strlen(name); + if (size > 4 && + (!strcmp(&name[size - 4], ".jar") || !strcmp(&name[size - 4], ".zip"))) { - for (uint32 i = 0; i < cl->nbStaticMethods; ++i) { - JavaMethod& meth = cl->staticMethods[i]; - bootstrapLoader->TheModuleProvider->parseFunction(&meth); - } + + std::vector classes; + + ArrayUInt8* bytes = Reader::openFile(bootstrapLoader, name); + if (!bytes) unknownError("Can't find zip file."); + ZipArchive archive(bytes, bootstrapLoader->allocator); + char* realName = (char*)alloca(4096); + for (ZipArchive::table_iterator i = archive.filetable.begin(), + e = archive.filetable.end(); i != e; ++i) { + ZipFile* file = i->second; + + size = strlen(file->filename); + if (size > 6 && !strcmp(&(file->filename[size - 6]), ".class")) { + UserClassArray* array = bootstrapLoader->upcalls->ArrayOfByte; + ArrayUInt8* res = (ArrayUInt8*)array->doNew(file->ucsize, + bootstrapLoader->allocator); + int ok = archive.readFile(res, file); + if (!ok) unknownError("Wrong zip file."); + + + memcpy(realName, file->filename, size); + realName[size - 6] = 0; + const UTF8* utf8 = bootstrapLoader->asciizConstructUTF8(realName); + Class* cl = bootstrapLoader->constructClass(utf8, res); + classes.push_back(cl); + } + } + + // First resolve everyone so that there can not be unknown references in + // constant pools. + for (std::vector::iterator i = classes.begin(), e = classes.end(); + i != e; ++i) { + Class* cl = *i; + cl->resolveClass(); + } + + for (std::vector::iterator i = classes.begin(), e = classes.end(); + i != e; ++i) { + Class* cl = *i; + if (!cl->isInterface()) compileClass(cl); + } + + } else { + + const UTF8* utf8 = bootstrapLoader->asciizConstructUTF8(name); + UserClass* cl = bootstrapLoader->loadName(utf8, true, true); + compileClass(cl); + } + + // Set the linkage to External, so that the printer does not complain. llvm::Module* M = bootstrapLoader->getModule(); for (Module::iterator i = M->begin(), e = M->end(); i != e; ++i) { i->setLinkage(llvm::GlobalValue::ExternalLinkage); Modified: vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/NativeUtil.cpp Tue Oct 28 12:16:42 2008 @@ -188,13 +188,6 @@ if (!res) { buf = jniConsFromMeth3(cl, meth, buf); res = cl->classLoader->loadLib(buf, jnjvm); - if (!res) { - printf("Native function %s not found. Probably " - "not implemented by JnJVM?\n", meth->printString()); - JavaJIT::printBacktrace(); - JavaThread::get()->isolate->unknownError("can not find native method %s", - meth->printString()); - } } } return res; Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Reader.cpp Tue Oct 28 12:16:42 2008 @@ -25,7 +25,7 @@ const int Reader::SeekCur = SEEK_CUR; const int Reader::SeekEnd = SEEK_END; -ArrayUInt8* Reader::openFile(JnjvmBootstrapLoader* loader, char* path) { +ArrayUInt8* Reader::openFile(JnjvmBootstrapLoader* loader, const char* path) { FILE* fp = fopen(path, "r"); ArrayUInt8* res = 0; if (fp != 0) { @@ -41,7 +41,7 @@ } ArrayUInt8* Reader::openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive, - char* filename) { + const char* filename) { ArrayUInt8* ret = 0; ZipFile* file = archive->getFile(filename); if (file != 0) { Modified: vmkit/trunk/lib/JnJVM/VMCore/Reader.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Reader.h?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Reader.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Reader.h Tue Oct 28 12:16:42 2008 @@ -76,8 +76,8 @@ static const int SeekCur; static const int SeekEnd; - static ArrayUInt8* openFile(JnjvmBootstrapLoader* loader, char* path); - static ArrayUInt8* openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive, char* filename); + static ArrayUInt8* openFile(JnjvmBootstrapLoader* loader, const char* path); + static ArrayUInt8* openZip(JnjvmBootstrapLoader* loader, ZipArchive* archive, const char* filename); uint8 readU1() { return bytes->elements[cursor++]; Modified: vmkit/trunk/lib/JnJVM/VMCore/Zip.h URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Zip.h?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/lib/JnJVM/VMCore/Zip.h (original) +++ vmkit/trunk/lib/JnJVM/VMCore/Zip.h Tue Oct 28 12:16:42 2008 @@ -34,6 +34,7 @@ class ZipArchive : public mvm::PermanentObject { friend class JnjvmBootstrapLoader; + friend class Jnjvm; private: mvm::BumpPtrAllocator& allocator; Modified: vmkit/trunk/tools/vmjc/Makefile URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/Makefile?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/tools/vmjc/Makefile (original) +++ vmkit/trunk/tools/vmjc/Makefile Tue Oct 28 12:16:42 2008 @@ -12,7 +12,7 @@ TOOLNAME = vmjc USEDLIBS = Allocator CommonThread Mvm JnJVM Classpath $(GCLIB) -LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo +LINK_COMPONENTS = jit nativecodegen scalaropts instrumentation ipa ipo bitwriter ifeq ($(ISOLATE_BUILD), 1) USEDLIBS += Isolate Modified: vmkit/trunk/tools/vmjc/vmjc.cpp URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tools/vmjc/vmjc.cpp?rev=58334&r1=58333&r2=58334&view=diff ============================================================================== --- vmkit/trunk/tools/vmjc/vmjc.cpp (original) +++ vmkit/trunk/tools/vmjc/vmjc.cpp Tue Oct 28 12:16:42 2008 @@ -23,6 +23,7 @@ #include "llvm/Support/ManagedStatic.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/Streams.h" +#include "llvm/Support/SystemUtils.h" #include "llvm/Support/raw_ostream.h" #include "llvm/System/Signals.h" @@ -71,7 +72,8 @@ mvm::Object::initialise(); mvm::Thread::initialise(); Collector::initialise(0, &base); - + Collector::enable(0); + mvm::CompilationUnit* CU = mvm::VirtualMachine::initialiseJVM(true); mvm::VirtualMachine* vm = mvm::VirtualMachine::createJVM(CU); vm->compile(InputFilename.c_str()); @@ -97,9 +99,9 @@ int Len = IFN.length(); if (IFN[Len-3] == '.' && IFN[Len-2] == 'b' && IFN[Len-1] == 'c') { // Source ends in .bc - OutputFilename = std::string(IFN.begin(), IFN.end()-3)+".ll"; + OutputFilename = std::string(IFN.begin(), IFN.end()-3)+".bc"; } else { - OutputFilename = IFN+".ll"; + OutputFilename = IFN+".bc"; } if (!Force && std::ifstream(OutputFilename.c_str())) { @@ -121,14 +123,9 @@ << ": sending to stdout instead!\n"; Out = &std::cout; } - - // All that llvm-dis does is write the assembly to a file. - if (!DontPrint) { - PassManager Passes; - raw_os_ostream L(*Out); - Passes.add(createPrintModulePass(&L)); - Passes.run(*CU->TheModule); - } + + if (Force || !CheckBitcodeOutputToConsole(Out,true)) + WriteBitcodeToFile(CU->TheModule, *Out); if (Out != &std::cout) { ((std::ofstream*)Out)->close();