[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/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Thu Oct 2 16:28:37 PDT 2008
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<JavaMethod*> 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<JavaMethod*>::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<JavaMethod*> 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<JavaMethod*>::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<JavaField*> 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<JavaField*>::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<Class*> & interfaces = cl->interfaces;
- ArrayObject* ret = ArrayObject::acons(interfaces.size(), Classpath::classArrayClass, &(vm->allocator));
+ UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, false);
+ std::vector<UserClass*> * interfaces = cl->getInterfaces();
+ ArrayObject* ret = ArrayObject::acons(interfaces->size(), vm->upcalls->classArrayClass, &(vm->allocator));
sint32 index = 0;
- for (std::vector<Class*>::iterator i = interfaces.begin(), e = interfaces.end();
+ for (std::vector<UserClass*>::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<Class*>* innerClasses = cl->getInnerClasses();
- ArrayObject* res = ArrayObject::acons(innerClasses->size(), Classpath::constructorArrayClass, &(vm->allocator));
- uint32 index = 0;
- for (std::vector<Class*>::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<UserClass*>* innerClasses = cl->getInnerClasses();
+ ArrayObject* res = ArrayObject::acons(innerClasses->size(), vm->upcalls->constructorArrayClass, &(vm->allocator));
+ uint32 index = 0;
+ for (std::vector<UserClass*>::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(; cur<max && i < size; cur++) {
+ void* obj = (void*)(*cur);
+ obj = Collector::begOf(obj);
+ if (obj && ((mvm::Object*)obj)->getVirtualTable() == 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<elmt> { \
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(; cur<max; cur++) {
+ void* obj = (void*)(*cur);
+ obj = Collector::begOf(obj);
+ if (obj && ((mvm::Object*)obj)->getVirtualTable() == 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<Class*> 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<Class*>::iterator i = interfaces.begin(),
- e = interfaces.end(); i!= e; i++) {
- cur = (*i)->lookupMethodDontThrow(name, type, isStatic, recurse);
+ std::vector<Class*>* interfaces = getInterfaces();
+ for (std::vector<Class*>::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<Class*>::iterator i = interfaces.begin(),
- e = interfaces.end(); i!= e; i++) {
- cur = (*i)->lookupFieldDontThrow(name, type, isStatic, recurse);
+ std::vector<Class*>* interfaces = getInterfaces();
+ for (std::vector<Class*>::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<Class*>::iterator i = interfaces.begin(),
+ for (std::vector<UserClass*>::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<JavaState, JavaObject*>* 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<JavaState, JavaObject*>* 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<JavaState, JavaObject*>* val = vm->statics->lookup(cl);
- if (!val) {
- val = new std::pair<JavaState, JavaObject*>(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<const UTF8*>* 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<Attribut*>& 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<Class*> interfaces;
+
+ std::vector<Class*> * 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<Class*> interfaces;
+
+ const UTF8* getSuperUTF8() {
+ return superUTF8;
+ }
/// interfacesUTF8 - The names of the interfaces this class implements.
///
std::vector<const UTF8*> interfacesUTF8;
+ std::vector<const UTF8*>* 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<Ty*>(JInfo);
}
-#ifdef MULTIPLE_VM
- bool isSharedClass() {
- return classLoader == JnjvmClassLoader::sharedLoader;
- }
-#endif
-
void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly);
void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly);
void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly);
+ void setInterfaces(std::vector<Class*> 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<Attribut*> attributs;
-
+
+#ifndef MULTIPLE_VM
/// innerClasses - The inner classes of this class.
///
std::vector<Class*> 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<Class*>* 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<Class*> 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<typename Ty>
@@ -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<Value*> 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<Value*> indexes2; //[3];
+#ifdef MULTIPLE_VM
+ std::vector<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Typedef*>::iterator type =
compilingMethod->getSignature()->args.begin();
- std::vector<Value*>::iterator i = args.begin();
+ std::vector<Value*>::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<Value*> 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<Exception*> 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<Value*> 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<Value*, const AssessorDesc*> > newStack;
+ std::vector< std::pair<Value*, bool> > 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<Value*, const AssessorDesc*> >::iterator i =
+ for (std::vector< std::pair<Value*, bool> >::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<Value*, const AssessorDesc*> >::iterator stackit =
+ std::vector< std::pair<Value*, bool> >::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<Value*>& 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<Value*>& 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<Value*> 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<Value*> 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<Value*> 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<Value*> Args;
+#ifdef MULTIPLE_VM
+ std::vector<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<llvm::Value*, const AssessorDesc*> > 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<llvm::Value*, bool> > stack;
+ void push(llvm::Value* val, bool unsign) {
+ stack.push_back(std::make_pair(val, unsign));
}
- void push(std::pair<llvm::Value*, const AssessorDesc*> pair) {
- assert(LLVMAssessorInfo::AssessorInfo[pair.second->numId].llvmType ==
- pair.first->getType());
+ void push(std::pair<llvm::Value*, bool> 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<llvm::Value*, const AssessorDesc*> popPair() {
- std::pair<llvm::Value*, const AssessorDesc*> ret = stack.back();
+ std::pair<llvm::Value*, bool> popPair() {
+ std::pair<llvm::Value*, bool> 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<Value*, const AssessorDesc*> one = popPair();
- std::pair<Value*, const AssessorDesc*> two = popPair();
+ std::pair<Value*, bool> one = popPair();
+ std::pair<Value*, bool> two = popPair();
push(one);
push(two);
push(one);
@@ -693,9 +715,9 @@
}
case DUP_X2 : {
- std::pair<Value*, const AssessorDesc*> one = popPair();
- std::pair<Value*, const AssessorDesc*> two = popPair();
- std::pair<Value*, const AssessorDesc*> three = popPair();
+ std::pair<Value*, bool> one = popPair();
+ std::pair<Value*, bool> two = popPair();
+ std::pair<Value*, bool> three = popPair();
push(one);
push(three);
push(two);
@@ -709,9 +731,9 @@
break;
case DUP2_X1 : {
- std::pair<Value*, const AssessorDesc*> one = popPair();
- std::pair<Value*, const AssessorDesc*> two = popPair();
- std::pair<Value*, const AssessorDesc*> three = popPair();
+ std::pair<Value*, bool> one = popPair();
+ std::pair<Value*, bool> two = popPair();
+ std::pair<Value*, bool> three = popPair();
push(two);
push(one);
@@ -724,10 +746,10 @@
}
case DUP2_X2 : {
- std::pair<Value*, const AssessorDesc*> one = popPair();
- std::pair<Value*, const AssessorDesc*> two = popPair();
- std::pair<Value*, const AssessorDesc*> three = popPair();
- std::pair<Value*, const AssessorDesc*> four = popPair();
+ std::pair<Value*, bool> one = popPair();
+ std::pair<Value*, bool> two = popPair();
+ std::pair<Value*, bool> three = popPair();
+ std::pair<Value*, bool> four = popPair();
push(two);
push(one);
@@ -741,8 +763,8 @@
}
case SWAP : {
- std::pair<Value*, const AssessorDesc*> one = popPair();
- std::pair<Value*, const AssessorDesc*> two = popPair();
+ std::pair<Value*, bool> one = popPair();
+ std::pair<Value*, bool> 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<Value*> 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<Value*> 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<Value*> 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<Typedef*>::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<JavaState, JavaObject*>* 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<Typedef*>* 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<Typedef*>*,
+ 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<typename Ty>
+ Ty *getInfo() {
+ if (!JInfo) {
+ JInfo = new Ty(this);
+ }
- /// printString - Print the assessor for debugging purposes.
- ///
- const char* printString() const;
+ assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
+ "Invalid concrete type or multiple inheritence for getInfo");
+ return static_cast<Ty*>(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<Typedef*>*,
- 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", "<init>",
"(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<void*> Jnjvm::nativeLibs;
+JnjvmBootstrapLoader* Jnjvm::bootstrapLoader;
+std::map<const char, UserClassPrimitive*> 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<const char, UserClassArray*> arrayClasses;
private:
+ ISOLATE_STATIC std::map<const char, UserClassPrimitive*> 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<void*> nativeLibs;
+ ISOLATE_STATIC std::vector<void*> 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
- /// "<clinit>" 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<UserClass*> 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<UserClass*> 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<Value*> 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<Typedef*>::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<Typedef*>::iterator i = signature->args.begin(),
+ for (std::vector<Typedef*>::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<const llvm::Type*> 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<const llvm::Type*> 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<const char, LLVMAssessorInfo> 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<const char, LLVMAssessorInfo> 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<LLVMCommonClassInfo>();
}
@@ -427,6 +436,8 @@
return ctp->getInfo<LLVMConstantPoolInfo>();
}
+ 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<const uint32, const UTF8*> 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<const UTF8*, CommonClass*, ltutf8, JnjvmClassLoader* > {
+ public LockedMap<const UTF8*, UserCommonClass*, ltutf8, JnjvmClassLoader* > {
public:
static VirtualTable* VT;
@@ -245,41 +247,6 @@
};
-class StaticInstanceMap :
- public LockedMap<Class*, std::pair<JavaState, JavaObject*>*, std::less<Class*>, 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<CommonClass*, JavaObject*, std::less<CommonClass*>, 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 <iostream>
using namespace llvm;
using namespace jnjvm;
@@ -34,7 +36,6 @@
char LowerConstantCalls::ID = 0;
static RegisterPass<LowerConstantCalls> 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<CallInst>(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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<ConstantExpr>(CI->getOperand(2));
+ ConstantExpr* CE = dyn_cast<ConstantExpr>(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<Value*> args;
args.push_back(objCl);
args.push_back(CE);
@@ -225,10 +228,84 @@
break;
}
}
+
+ else if (V == jnjvm::JnjvmModule::GetConstantPoolAtFunction) {
+ Function* resolver = dyn_cast<Function>(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<InvokeInst>(CI);
+ assert(Invoke && "Last instruction is not an invoke");
+ NBB = Invoke->getNormalDest();
+ }
+
+ std::vector<Value*> indexes; //[3];
+#ifdef MULTIPLE_VM
+ ConstantInt* Cons = dyn_cast<ConstantInt>(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<Value*> 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<InvokeInst>(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<PHINode>(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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Value*> 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<Typedef*>& 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 <llvm/Constants.h>
#include <llvm/DerivedTypes.h>
#include <llvm/Function.h>
@@ -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<const llvm::Type *> 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<const llvm::Type *> 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<const llvm::Type*>(), 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<const llvm::Type*> 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<const llvm::Type*> 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<const Type*> 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<const llvm::Type*> 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<const llvm::Type*> 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<const llvm::Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<ParamAttrsWithIndex, 4> 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<const Type*> 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<ParamAttrsWithIndex, 4> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> args;
- const FunctionType* type = FunctionType::get(Type::VoidTy, args, false);
-
- jniProceedPendingExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN5n37CLIJit26jniProceedPendingExceptionEv",
- module);
- }*/
- // Create printExecutionLLVM
- {
- std::vector<const Type*> 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<const Type*> 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<const Type*> args;
- const FunctionType* type = FunctionType::get(Type::VoidTy, args, false);
- clearExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN2n38VMThread14clearExceptionEv",
- module);
- }
-
-
- // Create compareExceptionLLVM
- {
- std::vector<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> 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<const Type*> args;
- const FunctionType* type = FunctionType::get(mvm::jit::ptrType,
- args, false);
-
- getCppExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN2n38VMThread15getCppExceptionEv",
- module);
- }
-
- // Create getCLIExceptionLLVM
- {
- std::vector<const Type*> args;
- const FunctionType* type = FunctionType::get(VMObject::llvmType,
- args, false);
-
- getCLIExceptionLLVM = Function::Create(type, GlobalValue::ExternalLinkage,
- "_ZN2n38VMThread15getCLIExceptionEv",
- module);
- }
-
- // Create newStringLLVM
- {
- std::vector<const Type*> 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 <stdio.h>
+
+#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<const llvm::Type*> &args,
const llvm::Type* arg) {
const llvm::StructType* STy = llvm::dyn_cast<llvm::StructType>(arg);
@@ -832,14 +799,16 @@
std::vector<VMCommonClass*>::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
+
+
More information about the vmkit-commits
mailing list