[vmkit-commits] [vmkit] r55368 - in /vmkit/branches/isolate/lib/JnJVM: Classpath/ Isolate/ VMCore/
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Tue Aug 26 02:30:55 PDT 2008
Author: geoffray
Date: Tue Aug 26 04:30:54 2008
New Revision: 55368
URL: http://llvm.org/viewvc/llvm-project?rev=55368&view=rev
Log:
Reorganizing code to be able to share Java code between isolates.
SingleVM still works, MultiVM does not.
Added:
vmkit/branches/isolate/lib/JnJVM/Isolate/
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp
vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.h
vmkit/branches/isolate/lib/JnJVM/Isolate/Makefile
vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h
Modified:
vmkit/branches/isolate/lib/JnJVM/Classpath/Classpath.cpp
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc
vmkit/branches/isolate/lib/JnJVM/Classpath/Makefile
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaConstantPool.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaObject.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaString.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaThread.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.h
vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h
vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.h
vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/Makefile
vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.h
vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp
vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/Classpath.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/Classpath.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/Classpath.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/Classpath.cpp Tue Aug 26 04:30:54 2008
@@ -44,7 +44,7 @@
#endif
jclass Cl) {
- CommonClass* cl = NativeUtil::resolvedImplClass(Cl, true);
+ UserCommonClass* cl = NativeUtil::resolvedImplClass(Cl, true);
if (cl->lookupMethodDontThrow(Jnjvm::clinitName, Jnjvm::clinitType, true, false))
return true;
else
@@ -57,8 +57,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 +68,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 +79,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 +90,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 +101,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 +112,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 +123,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 +134,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 +145,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,9 +157,9 @@
#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));
+ JavaMethod* meth = (JavaMethod*)(vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons));
meth->invokeIntSpecial(vm, res);
return (jobject)res;
}
@@ -165,11 +174,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* name = base->getName();
const UTF8* arrayName = AssessorDesc::constructArrayName(loader, 0, 1, name);
- ClassArray* array = loader->constructArray(arrayName);
+ UserClassArray* array = loader->constructArray(arrayName);
ArrayObject* res = ArrayObject::acons(arrayLength, array, &(vm->allocator));
return (jobject) res;
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathConstructor.cpp.inc Tue Aug 26 04:30:54 2008
@@ -32,7 +32,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));
JnjvmClassLoader* loader = meth->classDef->classLoader;
return (jobject)(NativeUtil::getParameterTypes(loader, meth));
}
@@ -42,7 +43,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 +66,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);
@@ -84,8 +86,8 @@
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,7 +106,8 @@
#endif
jobject cons) {
verifyNull(cons);
- JavaMethod* meth = (JavaMethod*)Classpath::constructorSlot->getVirtualInt32Field((JavaObject*)cons);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaMethod* meth = (JavaMethod*)vm->upcalls->constructorSlot->getInt32Field((JavaObject*)cons);
return (jobjectArray)NativeUtil::getExceptionTypes(meth);
}
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathMethod.cpp.inc Tue Aug 26 04:30:54 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,7 +60,8 @@
#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);
JnjvmClassLoader* loader = meth->classDef->classLoader;
return (jobject)(NativeUtil::getParameterTypes(loader, meth));
}
@@ -74,17 +83,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);
+ UserCommonClass* cl;
+#ifdef MULTIPLE_VM
+ jclass Cl = (jclass)vm->upcalls->methodClass->getInt32Field((JavaObject*)Meth);
+ cl = NativeUtil::resolvedImplClass(Cl, false);
+
+#else
+ cl = meth->classDef;
+#endif
+ if (!(obj->classOf->isAssignableFrom(cl))) {
+ vm->illegalArgumentExceptionForMethod(meth, cl, obj->classOf);
}
} else {
- vm->initialiseClass(cl);
+ cl->initialiseClass(vm);
}
JavaObject** ptr = (JavaObject**)(void*)(args->elements);
@@ -113,7 +130,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); \
@@ -129,43 +146,43 @@
} else if (retType == AssessorDesc::dBool) {
uint32 val = 0;
RUN_METH(Int);
- res = Classpath::boolClass->doNew(vm);
- Classpath::boolValue->setVirtualInt8Field(res, val);
+ res = vm->upcalls->boolClass->doNew(vm);
+ vm->upcalls->boolValue->setInt8Field(res, val);
} else if (retType == AssessorDesc::dByte) {
uint32 val = 0;
RUN_METH(Int);
- res = Classpath::byteClass->doNew(vm);
- Classpath::byteValue->setVirtualInt8Field(res, val);
+ res = vm->upcalls->byteClass->doNew(vm);
+ vm->upcalls->byteValue->setInt8Field(res, val);
} else if (retType == AssessorDesc::dChar) {
uint32 val = 0;
RUN_METH(Int);
- res = Classpath::charClass->doNew(vm);
- Classpath::charValue->setVirtualInt16Field(res, val);
+ res = vm->upcalls->charClass->doNew(vm);
+ vm->upcalls->charValue->setInt16Field(res, val);
} else if (retType == AssessorDesc::dShort) {
uint32 val = 0;
RUN_METH(Int);
- res = Classpath::shortClass->doNew(vm);
- Classpath::shortValue->setVirtualInt16Field(res, val);
+ res = vm->upcalls->shortClass->doNew(vm);
+ vm->upcalls->shortValue->setInt16Field(res, val);
} else if (retType == AssessorDesc::dInt) {
uint32 val = 0;
RUN_METH(Int);
- res = Classpath::intClass->doNew(vm);
- Classpath::intValue->setVirtualInt32Field(res, val);
+ res = vm->upcalls->intClass->doNew(vm);
+ vm->upcalls->intValue->setInt32Field(res, val);
} else if (retType == AssessorDesc::dLong) {
sint64 val = 0;
RUN_METH(Long);
- res = Classpath::longClass->doNew(vm);
- Classpath::longValue->setVirtualLongField(res, val);
+ res = vm->upcalls->longClass->doNew(vm);
+ vm->upcalls->longValue->setLongField(res, val);
} else if (retType == AssessorDesc::dFloat) {
float val = 0;
RUN_METH(Float);
- res = Classpath::floatClass->doNew(vm);
- Classpath::floatValue->setVirtualFloatField(res, val);
+ res = vm->upcalls->floatClass->doNew(vm);
+ vm->upcalls->floatValue->setFloatField(res, val);
} else if (retType == AssessorDesc::dDouble) {
double val = 0;
RUN_METH(Double);
- res = Classpath::doubleClass->doNew(vm);
- Classpath::doubleValue->setVirtualDoubleField(res, val);
+ res = vm->upcalls->doubleClass->doNew(vm);
+ vm->upcalls->doubleValue->setDoubleField(res, val);
} else if (retType == AssessorDesc::dTab || retType == AssessorDesc::dRef) {
JavaObject* val = 0;
RUN_METH(JavaObject);
@@ -187,7 +204,8 @@
#endif
jobject _meth) {
verifyNull(_meth);
- JavaMethod* meth = (JavaMethod*)Classpath::methodSlot->getVirtualInt32Field((JavaObject*)_meth);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaMethod* meth = (JavaMethod*)vm->upcalls->methodSlot->getInt32Field((JavaObject*)_meth);
return (jobjectArray)NativeUtil::getExceptionTypes(meth);
}
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClass.cpp.inc Tue Aug 26 04:30:54 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) {
-
+ Jnjvm* vm = JavaThread::get()->isolate;
JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader);
- CommonClass* cl = JCL->lookupClassFromJavaString((JavaString*)str,
+ 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,23 @@
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);
+ JavaObject* tmp = vm->upcalls->newConstructor->doNew(vm);
+ vm->upcalls->initConstructor->invokeIntSpecial(vm, tmp, Cl, meth);
ret->elements[index] = tmp;
}
return (jobject)ret;
@@ -109,22 +110,22 @@
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,
+ JavaObject* tmp = vm->upcalls->newMethod->doNew(vm);
+ vm->upcalls->initMethod->invokeIntSpecial(vm, tmp, Cl,
vm->UTF8ToStr(meth->name), meth);
ret->elements[index] = tmp;
}
@@ -140,8 +141,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 +152,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 +167,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 +180,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 +191,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 +209,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 +221,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 +238,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 +256,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 +269,23 @@
#endif
jclass Cl, 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::fieldArrayClass, &(vm->allocator));
+ if (cl->isArray()) {
+ 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,
+ JavaObject* tmp = vm->upcalls->newField->doNew(vm);
+ vm->upcalls->initField->invokeIntSpecial(vm, tmp, Cl,
vm->UTF8ToStr(field->name), field);
ret->elements[index] = tmp;
}
@@ -293,14 +300,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,11 +320,11 @@
#endif
jclass Cl) {
Jnjvm* vm = JavaThread::get()->isolate;
- Class* cl = (Class*)NativeUtil::resolvedImplClass(Cl, false);
+ UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false);
cl->resolveInnerOuterClasses();
- Class* outer = cl->getOuterClass();
+ UserClass* outer = cl->getOuterClass();
if (outer) {
- return (jclass)vm->getClassDelegatee(outer);
+ return (jclass)outer->getClassDelegatee(vm);
} else {
return 0;
}
@@ -330,14 +337,14 @@
#endif
jclass Cl, bool publicOnly) {
Jnjvm* vm = JavaThread::get()->isolate;
- Class* cl = (Class*)NativeUtil::resolvedImplClass(Cl, false);
+ UserClass* cl = (UserClass*)NativeUtil::resolvedImplClass(Cl, false);
cl->resolveInnerOuterClasses();
- std::vector<Class*>* innerClasses = cl->getInnerClasses();
- ArrayObject* res = ArrayObject::acons(innerClasses->size(), Classpath::constructorArrayClass, &(vm->allocator));
+ std::vector<UserClass*>* innerClasses = cl->getInnerClasses();
+ ArrayObject* res = ArrayObject::acons(innerClasses->size(), vm->upcalls->constructorArrayClass, &(vm->allocator));
uint32 index = 0;
- for (std::vector<Class*>::iterator i = innerClasses->begin(),
+ for (std::vector<UserClass*>::iterator i = innerClasses->begin(),
e = innerClasses->end(); i!= e; i++) {
- res->elements[index++] = vm->getClassDelegatee(*i);
+ res->elements[index++] = (*i)->getClassDelegatee(vm);
}
return (jobject)res;
@@ -361,7 +368,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/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMClassLoader.cpp.inc Tue Aug 26 04:30:54 2008
@@ -37,7 +37,7 @@
if (!ass)
vm->unknownError("unknown byte primitive %c", byteId);
- return (jobject)ass->classType->getClassDelegatee();
+ return (jobject)ass->classType->getClassDelegatee(vm);
}
@@ -53,9 +53,9 @@
JavaString* name = (JavaString*)_name;
const UTF8* utf8 = name->strToUTF8(vm);
JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader);
- CommonClass* cl = JCL->lookupClass(utf8);
+ UserCommonClass* cl = JCL->lookupClass(utf8);
- if (cl) return (jclass)(cl->getClassDelegatee());
+ if (cl) return (jclass)(cl->getClassDelegatee(vm));
else return 0;
}
@@ -66,13 +66,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);
+ UserCommonClass* cl = JCL->lookupClassFromJavaString(str, doResolve, false);
if (cl != 0) {
- return (jclass)cl->getClassDelegatee();
+ return (jclass)cl->getClassDelegatee(vm);
} else {
return 0;
}
@@ -89,12 +90,13 @@
jint off,
jint len,
jobject pd) {
+ Jnjvm* vm = JavaThread::get()->isolate;
JnjvmClassLoader* JCL = JnjvmClassLoader::getJnjvmLoaderFromJavaObject((JavaObject*)loader);
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/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMField.cpp.inc Tue Aug 26 04:30:54 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,11 @@
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);
JnjvmClassLoader* loader = field->classDef->classLoader;
- CommonClass* cl = field->getSignature()->assocClass(loader);
- return (jclass)cl->getClassDelegatee();
+ UserCommonClass* cl = field->getSignature()->assocClass(loader);
+ return (jclass)cl->getClassDelegatee(vm);
}
JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(
@@ -44,29 +57,27 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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);
+ return (sint32)field->getInt32Field(Obj);
case CHAR_ID :
- return isStatic(field->access) ?
- (uint32)field->getStaticInt16Field() :
- (uint32)field->getVirtualInt16Field((JavaObject*)obj);
+ return (uint32)field->getInt16Field(Obj);
case BYTE_ID :
- return isStatic(field->access) ?
- (sint32)field->getStaticInt8Field() :
- (sint32)field->getVirtualInt8Field((JavaObject*)obj);
+ return (sint32)field->getInt8Field(Obj);
case SHORT_ID :
- return isStatic(field->access) ?
- (sint32)field->getStaticInt16Field() :
- (sint32)field->getVirtualInt16Field((JavaObject*)obj);
+ return (sint32)field->getInt16Field(Obj);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -79,33 +90,29 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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) ?
- (sint64)field->getStaticInt32Field() :
- (sint64)field->getVirtualInt32Field((JavaObject*)obj);
+ return (sint64)field->getInt32Field(Obj);
case CHAR_ID :
- return isStatic(field->access) ?
- (uint64)field->getStaticInt16Field() :
- (uint64)field->getVirtualInt16Field((JavaObject*)obj);
+ return (uint64)field->getInt16Field(Obj);
case BYTE_ID :
- return isStatic(field->access) ?
- (sint64)field->getStaticInt8Field() :
- (sint64)field->getVirtualInt8Field((JavaObject*)obj);
+ return (sint64)field->getInt8Field(Obj);
case SHORT_ID :
- return isStatic(field->access) ?
- (sint64)field->getStaticInt16Field() :
- (sint64)field->getVirtualInt16Field((JavaObject*)obj);
+ return (sint64)field->getInt16Field(Obj);
case LONG_ID :
- return isStatic(field->access) ?
- (sint64)field->getStaticLongField() :
- (sint64)field->getVirtualLongField((JavaObject*)obj);
+ return (sint64)field->getLongField(Obj);
default:
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -117,17 +124,21 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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);
+ return (uint8)field->getInt8Field(Obj);
default:
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -141,37 +152,31 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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) ?
- (jfloat)field->getStaticInt8Field() :
- (jfloat)field->getVirtualInt8Field((JavaObject*)obj);
+ return (jfloat)field->getInt8Field(Obj);
case INT_ID :
- return isStatic(field->access) ?
- (jfloat)field->getStaticInt32Field() :
- (jfloat)field->getVirtualInt32Field((JavaObject*)obj);
+ return (jfloat)field->getInt32Field((JavaObject*)obj);
case SHORT_ID :
- return isStatic(field->access) ?
- (jfloat)field->getStaticInt16Field() :
- (jfloat)field->getVirtualInt16Field((JavaObject*)obj);
+ return (jfloat)field->getInt16Field((JavaObject*)obj);
case LONG_ID :
- return isStatic(field->access) ?
- (jfloat)field->getStaticLongField() :
- (jfloat)field->getVirtualLongField((JavaObject*)obj);
+ return (jfloat)field->getLongField((JavaObject*)obj);
case CHAR_ID :
- return isStatic(field->access) ?
- (jfloat)(uint32)field->getStaticInt16Field() :
- (jfloat)(uint32)field->getVirtualInt16Field((JavaObject*)obj);
+ return (jfloat)(uint32)field->getInt16Field((JavaObject*)obj);
case FLOAT_ID :
- return isStatic(field->access) ?
- (jfloat)field->getStaticFloatField() :
- (jfloat)field->getVirtualFloatField((JavaObject*)obj);
+ return (jfloat)field->getFloatField((JavaObject*)obj);
default:
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -183,17 +188,21 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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);
+ return (sint8)field->getInt8Field(Obj);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -206,17 +215,21 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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);
+ return (uint16)field->getInt16Field((JavaObject*)obj);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -230,21 +243,23 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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);
+ return (sint16)field->getInt16Field(Obj);
case BYTE_ID :
- return isStatic(field->access) ?
- (sint16)field->getStaticInt8Field() :
- (sint16)field->getVirtualInt8Field((JavaObject*)obj);
+ return (sint16)field->getInt8Field(Obj);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -257,41 +272,33 @@
JNIEnv *env,
#endif
jobject Field, jobject obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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) ?
- (jdouble)(sint64)field->getStaticInt8Field() :
- (jdouble)(sint64)field->getVirtualInt8Field((JavaObject*)obj);
+ return (jdouble)(sint64)field->getInt8Field(Obj);
case INT_ID :
- return isStatic(field->access) ?
- (jdouble)(sint64)field->getStaticInt32Field() :
- (jdouble)(sint64)field->getVirtualInt32Field((JavaObject*)obj);
+ return (jdouble)(sint64)field->getInt32Field(Obj);
case SHORT_ID :
- return isStatic(field->access) ?
- (jdouble)(sint64)field->getStaticInt16Field() :
- (jdouble)(sint64)field->getVirtualInt16Field((JavaObject*)obj);
+ return (jdouble)(sint64)field->getInt16Field(Obj);
case LONG_ID :
- return isStatic(field->access) ?
- (jdouble)(sint64)field->getStaticLongField() :
- (jdouble)(sint64)field->getVirtualLongField((JavaObject*)obj);
+ return (jdouble)(sint64)field->getLongField(Obj);
case CHAR_ID :
- return isStatic(field->access) ?
- (jdouble)(uint64)field->getStaticInt16Field() :
- (jdouble)(uint64)field->getVirtualInt16Field((JavaObject*)obj);
+ return (jdouble)(uint64)field->getInt16Field(Obj);
case FLOAT_ID :
- return isStatic(field->access) ?
- (jdouble)field->getStaticFloatField() :
- (jdouble)field->getVirtualFloatField((JavaObject*)obj);
+ return (jdouble)field->getFloatField(Obj);
case DOUBLE_ID :
- return isStatic(field->access) ?
- (jdouble)field->getStaticDoubleField() :
- (jdouble)field->getVirtualDoubleField((JavaObject*)obj);
+ return (jdouble)field->getDoubleField(Obj);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -303,86 +310,75 @@
JNIEnv *env,
#endif
jobject Field, jobject _obj) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
Typedef* type = field->getSignature();
const AssessorDesc* ass = type->funcs;
- JavaObject* obj = (JavaObject*)_obj;
- Jnjvm* vm = JavaThread::get()->isolate;
+
+ JavaObject* Obj = (JavaObject*)_obj;
+
+ if (isStatic(field->access)) {
+ UserClass* cl = internalGetClass(vm, field, Field);
+ cl->initialiseClass(vm);
+ Obj = cl->getStaticInstance();
+ }
if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ field->classDef->initialiseClass(vm);
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);
+ uint8 val = field->getInt8Field(Obj);
+ res = vm->upcalls->boolClass->doNew(vm);
+ vm->upcalls->boolValue->setInt8Field(res, val);
break;
}
case BYTE_ID : {
- sint8 val = (isStatic(field->access) ?
- field->getStaticInt8Field() :
- field->getVirtualInt8Field(obj));
- res = Classpath::byteClass->doNew(vm);
- Classpath::byteValue->setVirtualInt8Field(res, val);
+ sint8 val = field->getInt8Field(Obj);
+ res = vm->upcalls->byteClass->doNew(vm);
+ vm->upcalls->byteValue->setInt8Field(res, val);
break;
}
case CHAR_ID : {
- uint16 val = (isStatic(field->access) ?
- field->getStaticInt16Field() :
- field->getVirtualInt16Field(obj));
- res = Classpath::charClass->doNew(vm);
- Classpath::charValue->setVirtualInt16Field(res, val);
+ uint16 val = field->getInt16Field(Obj);
+ res = vm->upcalls->charClass->doNew(vm);
+ vm->upcalls->charValue->setInt16Field(res, val);
break;
}
case SHORT_ID : {
- sint16 val = (isStatic(field->access) ?
- field->getStaticInt16Field() :
- field->getVirtualInt16Field(obj));
- res = Classpath::shortClass->doNew(vm);
- Classpath::shortValue->setVirtualInt16Field(res, val);
+ sint16 val = field->getInt16Field(Obj);
+ res = vm->upcalls->shortClass->doNew(vm);
+ vm->upcalls->shortValue->setInt16Field(res, val);
break;
}
case INT_ID : {
- sint32 val = (isStatic(field->access) ?
- field->getStaticInt32Field() :
- field->getVirtualInt32Field(obj));
- res = Classpath::intClass->doNew(vm);
- Classpath::intValue->setVirtualInt32Field(res, val);
+ sint32 val = field->getInt32Field(Obj);
+ res = vm->upcalls->intClass->doNew(vm);
+ vm->upcalls->intValue->setInt32Field(res, val);
break;
}
case LONG_ID : {
- sint64 val = (isStatic(field->access) ?
- field->getStaticLongField() :
- field->getVirtualLongField(obj));
- res = Classpath::longClass->doNew(vm);
- Classpath::longValue->setVirtualLongField(res, val);
+ sint64 val = field->getLongField(Obj);
+ res = vm->upcalls->longClass->doNew(vm);
+ vm->upcalls->longValue->setLongField(res, val);
break;
}
case FLOAT_ID : {
- float val = (isStatic(field->access) ?
- field->getStaticFloatField() :
- field->getVirtualFloatField(obj));
- res = Classpath::floatClass->doNew(vm);
- Classpath::floatValue->setVirtualFloatField(res, val);
+ float val = field->getFloatField(Obj);
+ res = vm->upcalls->floatClass->doNew(vm);
+ vm->upcalls->floatValue->setFloatField(res, val);
break;
}
case DOUBLE_ID : {
- double val = (isStatic(field->access) ?
- field->getStaticDoubleField() :
- field->getVirtualDoubleField(obj));
- res = Classpath::doubleClass->doNew(vm);
- Classpath::doubleValue->setVirtualDoubleField(res, val);
+ double val = field->getDoubleField(Obj);
+ res = vm->upcalls->doubleClass->doNew(vm);
+ vm->upcalls->doubleValue->setDoubleField(res, val);
break;
}
case OBJECT_ID :
case ARRAY_ID :
- res = (isStatic(field->access) ?
- field->getStaticObjectField() :
- field->getVirtualObjectField(obj));
+ res = field->getObjectField(Obj);
break;
default:
JavaThread::get()->isolate->unknownError("should not be here");
@@ -395,54 +391,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;
+
+ 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*)_buf)[0]) :
- field->setVirtualInt8Field((JavaObject*)obj, ((uint8*)_buf)[0]);
+ return field->setInt8Field(Obj, ((uint8*)_buf)[0]);
case BYTE_ID :
- return isStatic(field->access) ?
- field->setStaticInt8Field(((sint8*)_buf)[0]) :
- field->setVirtualInt8Field((JavaObject*)obj, ((sint8*)_buf)[0]);
+ return field->setInt8Field(Obj, ((sint8*)_buf)[0]);
case CHAR_ID :
- return isStatic(field->access) ?
- field->setStaticInt16Field(((uint16*)_buf)[0]) :
- field->setVirtualInt16Field((JavaObject*)obj, ((uint16*)_buf)[0]);
+ return field->setInt16Field(Obj, ((uint16*)_buf)[0]);
case SHORT_ID :
- return isStatic(field->access) ?
- field->setStaticInt16Field(((sint16*)_buf)[0]) :
- field->setVirtualInt16Field((JavaObject*)obj, ((sint16*)_buf)[0]);
+ return field->setInt16Field(Obj, ((sint16*)_buf)[0]);
case INT_ID :
- return isStatic(field->access) ?
- field->setStaticInt32Field(((sint32*)_buf)[0]) :
- field->setVirtualInt32Field((JavaObject*)obj, ((sint32*)_buf)[0]);
+ return field->setInt32Field(Obj, ((sint32*)_buf)[0]);
case LONG_ID :
- return isStatic(field->access) ?
- field->setStaticLongField(((sint64*)_buf)[0]) :
- field->setVirtualLongField((JavaObject*)obj, ((sint64*)_buf)[0]);
+ return field->setLongField(Obj, ((sint64*)_buf)[0]);
case FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField(((float*)_buf)[0]) :
- field->setVirtualFloatField((JavaObject*)obj, ((float*)_buf)[0]);
+ return field->setFloatField(Obj, ((float*)_buf)[0]);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField(((double*)_buf)[0]) :
- field->setVirtualDoubleField((JavaObject*)obj, ((double*)_buf)[0]);
+ return field->setDoubleField(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]);
+ return field->setObjectField(Obj, ((JavaObject**)_buf)[0]);
default :
JavaThread::get()->isolate->unknownError("should not be here");
}
@@ -453,17 +437,20 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jboolean 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);
+ const AssessorDesc* ass = field->getSignature()->funcs;
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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);
+ return field->setInt8Field(Obj, (uint8)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -474,39 +461,31 @@
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-jobject Field, jobject _obj, jbyte val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+jobject Field, jobject obj, jbyte val) {
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- JavaObject* obj = (JavaObject*)_obj;
+ 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) ?
- field->setStaticInt8Field((sint8)val) :
- field->setVirtualInt8Field((JavaObject*)obj, (sint8)val);
+ return field->setInt8Field(Obj, (sint8)val);
case SHORT_ID :
- return isStatic(field->access) ?
- field->setStaticInt16Field((sint16)val) :
- field->setVirtualInt16Field((JavaObject*)obj, (sint16)val);
+ return field->setInt16Field(Obj, (sint16)val);
case INT_ID :
- return isStatic(field->access) ?
- field->setStaticInt32Field((sint32)val) :
- field->setVirtualInt32Field((JavaObject*)obj, (sint32)val);
+ return field->setInt32Field(Obj, (sint32)val);
case LONG_ID :
- return isStatic(field->access) ?
- field->setStaticLongField((sint64)val) :
- field->setVirtualLongField((JavaObject*)obj, (sint64)val);
+ return field->setLongField(Obj, (sint64)val);
case FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField((float)val) :
- field->setVirtualFloatField((JavaObject*)obj, (float)val);
+ return field->setFloatField(Obj, (float)val);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)val);
+ return field->setDoubleField(Obj, (double)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -517,33 +496,29 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jchar val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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) ?
- field->setStaticInt16Field((uint16)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (uint16)val);
+ return field->setInt16Field(Obj, (uint16)val);
case INT_ID :
- return isStatic(field->access) ?
- field->setStaticInt32Field((uint32)val) :
- field->setVirtualInt32Field((JavaObject*)obj, (uint32)val);
+ return field->setInt32Field(Obj, (uint32)val);
case LONG_ID :
- return isStatic(field->access) ?
- field->setStaticLongField((uint64)val) :
- field->setVirtualLongField((JavaObject*)obj, (uint64)val);
+ return field->setLongField(Obj, (uint64)val);
case FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField((float)(uint32)val) :
- field->setVirtualFloatField((JavaObject*)obj, (float)(uint32)val);
+ return field->setFloatField(Obj, (float)(uint32)val);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)(uint64)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)(uint64)val);
+ return field->setDoubleField(Obj, (double)(uint64)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -554,33 +529,29 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jshort val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ 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) ?
- field->setStaticInt16Field((sint16)val) :
- field->setVirtualInt16Field((JavaObject*)obj, (sint16)val);
+ return field->setInt16Field(Obj, (sint16)val);
case INT_ID :
- return isStatic(field->access) ?
- field->setStaticInt32Field((sint32)val) :
- field->setVirtualInt32Field((JavaObject*)obj, (sint32)val);
+ return field->setInt32Field(Obj, (sint32)val);
case LONG_ID :
- return isStatic(field->access) ?
- field->setStaticLongField((sint64)val) :
- field->setVirtualLongField((JavaObject*)obj, (sint64)val);
+ return field->setLongField(Obj, (sint64)val);
case FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField((float)val) :
- field->setVirtualFloatField((JavaObject*)obj, (float)val);
+ return field->setFloatField(Obj, (float)val);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)val);
+ return field->setDoubleField(Obj, (double)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -591,29 +562,26 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jint val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
+ 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) ?
- field->setStaticInt32Field((sint32)val) :
- field->setVirtualInt32Field((JavaObject*)obj, (sint32)val);
+ return field->setInt32Field(Obj, (sint32)val);
case LONG_ID :
- return isStatic(field->access) ?
- field->setStaticLongField((sint64)val) :
- field->setVirtualLongField((JavaObject*)obj, (sint64)val);
+ return field->setLongField(Obj, (sint64)val);
case FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField((float)val) :
- field->setVirtualFloatField((JavaObject*)obj, (float)val);
+ return field->setFloatField(Obj, (float)val);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)val);
+ return field->setDoubleField(Obj, (double)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -624,25 +592,24 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jlong val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
+ 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 LONG_ID :
- return isStatic(field->access) ?
- field->setStaticLongField((sint64)val) :
- field->setVirtualLongField((JavaObject*)obj, (sint64)val);
+ return field->setLongField(Obj, (sint64)val);
case FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField((float)val) :
- field->setVirtualFloatField((JavaObject*)obj, (float)val);
+ return field->setFloatField(Obj, (float)val);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)val);
+ return field->setDoubleField(Obj, (double)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -653,21 +620,22 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jfloat val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
+ 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 FLOAT_ID :
- return isStatic(field->access) ?
- field->setStaticFloatField((float)val) :
- field->setVirtualFloatField((JavaObject*)obj, (float)val);
+ return field->setFloatField(Obj, (float)val);
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)val);
+ return field->setDoubleField(Obj, (double)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -678,17 +646,20 @@
JNIEnv *env,
#endif
jobject Field, jobject obj, jdouble val) {
- JavaField* field = (JavaField*)Classpath::fieldSlot->getVirtualInt32Field((JavaObject*)Field);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ JavaField* field = (JavaField*)vm->upcalls->fieldSlot->getInt32Field((JavaObject*)Field);
const AssessorDesc* ass = field->getSignature()->funcs;
-
- if (isStatic(field->access))
- JavaThread::get()->isolate->initialiseClass(field->classDef);
+ JavaObject* Obj = (JavaObject*)obj;
+
+ if (isStatic(field->access)) {
+ UserClass* cl = internalGetClass(vm, field, Field);
+ cl->initialiseClass(vm);
+ Obj = cl->getStaticInstance();
+ }
switch (ass->numId) {
case DOUBLE_ID :
- return isStatic(field->access) ?
- field->setStaticDoubleField((double)val) :
- field->setVirtualDoubleField((JavaObject*)obj, (double)val);
+ return field->setDoubleField(Obj, (double)val);
default :
JavaThread::get()->isolate->illegalArgumentException("");
}
@@ -700,7 +671,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/branches/isolate/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMObject.cpp.inc Tue Aug 26 04:30:54 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/branches/isolate/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMStackWalker.cpp.inc Tue Aug 26 04:30:54 2008
@@ -28,33 +28,33 @@
extern "C" {
-ArrayObject* recGetClassContext(int** stack, uint32 size, uint32 first, uint32 rec) {
+ArrayObject* recGetClassContext(Jnjvm* vm, int** stack, uint32 size, uint32 first, uint32 rec) {
if (size != first) {
JavaMethod* meth = JavaJIT::IPToJavaMethod(stack[first]);
if (meth) {
- ArrayObject* res = recGetClassContext(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));
}
}
-
+#ifndef MULTIPLE_VM
JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassContext(
#ifdef NATIVE_JNI
JNIEnv *env,
jclass clazz,
#endif
) {
+ Jnjvm* vm = JavaThread::get()->isolate;
int* ips[100];
int real_size = mvm::jit::getBacktrace((void**)(void*)ips, 100);
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++]);
@@ -64,7 +64,7 @@
}
}
- return (jobject)recGetClassContext(ips, real_size, first, 0);
+ return (jobject)recGetClassContext(vm, ips, real_size, first, 0);
}
JNIEXPORT jobject JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader(
@@ -73,14 +73,16 @@
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();
}
+#endif
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/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystem.cpp.inc Tue Aug 26 04:30:54 2008
@@ -40,17 +40,17 @@
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();
+ UserClassArray* ts = (UserClassArray*)src->classOf;
+ UserClassArray* td = (UserClassArray*)dst->classOf;
+ UserCommonClass* dstType = td->baseClass();
AssessorDesc* dstFuncs = td->funcs();
AssessorDesc* srcFuncs = ts->funcs();
- CommonClass* srcPrim = srcFuncs->classType;
- CommonClass* dstPrim = dstFuncs->classType;
+ UserCommonClass* srcPrim = vm->getPrimitiveClass(srcFuncs);
+ UserCommonClass* dstPrim = vm->getPrimitiveClass(dstFuncs);
if (len > src->size) {
vm->indexOutOfBounds(src, len);
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMSystemProperties.cpp.inc Tue Aug 26 04:30:54 2008
@@ -28,8 +28,8 @@
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, prop, vm->asciizToStr(key),
+ vm->asciizToStr(val));
}
static void setUnameProp(Jnjvm* vm, JavaObject* prop) {
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc Tue Aug 26 04:30:54 2008
@@ -56,11 +56,11 @@
#else
Collector::inject_my_thread(&argc);
#endif
- CommonClass* vmthClass = vmThread->classOf;
- JavaObject* thread = Classpath::assocThread->getVirtualObjectField(vmThread);
+ UserCommonClass* vmthClass = 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;
@@ -107,14 +107,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 +131,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 +167,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/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/ClasspathVMThrowable.cpp.inc Tue Aug 26 04:30:54 2008
@@ -37,16 +37,17 @@
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;
}
+
+#ifndef MULTIPLE_VM
JavaObject* consStackElement(JavaMethod* meth, int* ip) {
Jnjvm* vm = JavaThread::get()->isolate;
JavaObject* methodName = vm->UTF8ToStr(meth->name);
@@ -64,8 +65,8 @@
bool native = isNative(meth->access);
- JavaObject* res = Classpath::newStackTraceElement->doNew(vm);
- Classpath::initStackTraceElement->invokeIntSpecial(vm, res, sourceName,
+ JavaObject* res = vm->upcalls->newStackTraceElement->doNew(vm);
+ vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, res, sourceName,
(uint32)ip, className,
methodName, native);
return res;
@@ -83,7 +84,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 +93,14 @@
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)) {
+ if (meth && !meth->classDef->subclassOf(vm->upcalls->newThrowable)) {
first = i - 1;
break;
}
@@ -108,4 +110,6 @@
return res;
}
+#endif
}
+
Modified: vmkit/branches/isolate/lib/JnJVM/Classpath/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Classpath/Makefile?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Classpath/Makefile (original)
+++ vmkit/branches/isolate/lib/JnJVM/Classpath/Makefile Tue Aug 26 04:30:54 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
Added: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp?rev=55368&view=auto
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp (added)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.cpp Tue Aug 26 04:30:54 2008
@@ -0,0 +1,49 @@
+//===--- IsolateCommonClass.cpp - User visible classes with isolates -------===//
+//
+// JnJVM
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "IsolateCommonClass.h"
+#include "IsolateSharedLoader.h"
+#include "JavaAllocator.h"
+#include "JavaClass.h"
+
+using namespace jnjvm;
+
+UserClass::UserClass(JnjvmClassLoader* JCL, const UTF8* name,
+ ArrayUInt8* bytes) {
+ Class* cl = JnjvmSharedLoader::sharedLoader->constructSharedClass(name, bytes);
+ if (!cl) {
+ cl = allocator_new(JCL->allocator, Class)(JCL, name, bytes);
+ }
+
+ classDef = cl;
+ classLoader = JCL;
+ delegatee = 0;
+ staticInstance = 0;
+}
+
+UserClassArray::UserClassArray(JnjvmClassLoader* JCL, const UTF8* name) {
+ ClassArray* cl = JnjvmSharedLoader::sharedLoader->constructSharedClassArray(name);
+ if (!cl) {
+ cl = allocator_new(JCL->allocator, ClassArray)(JCL, name);
+ }
+ classDef = cl;
+ classLoader = JCL;
+ delegatee = 0;
+ baseClass = 0;
+}
+
+UserClassPrimitive::UserClassPrimitive(JnjvmClassLoader* JCL, const UTF8* name) {
+ ClassPrimitive* cl = JnjvmSharedLoader::sharedLoader->constructSharedClassPrimitive(name);
+ if (!cl) {
+ cl = new ClassPrimitive(JCL, name);
+ }
+ classDef = cl;
+ classLoader = JCL;
+ delegatee = 0;
+}
Added: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h?rev=55368&view=auto
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h (added)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateCommonClass.h Tue Aug 26 04:30:54 2008
@@ -0,0 +1,115 @@
+//===---- IsolateCommonClass.h - User visible classes with isolates -------===//
+//
+// JnJVM
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ISOLATE_COMMON_CLASS_H
+#define ISOLATE_COMMON_CLASS_H
+
+#include "mvm/Object.h"
+
+namespace jnjvm {
+
+class ArrayUInt8;
+class AssessorDesc;
+class CommonClass;
+class Class;
+class ClassArray;
+class ClassPrimitive;
+class JavaField;
+class JavaMethod;
+class JavaObject;
+class Jnjvm;
+class JnjvmClassLoader;
+class UserClass;
+class UTF8;
+
+class UserCommonClass : public mvm::Object {
+public:
+ CommonClass* classDef;
+ JnjvmClassLoader* classLoader;
+ JavaObject* delegatee;
+ uint8 status;
+
+ virtual void TRACER;
+
+ bool isOfTypeName(const UTF8* name);
+ bool isAssignableFrom(UserCommonClass* cl);
+
+ /// subclassOf - If this class is a regular class, is it a subclass of the
+ /// given class?
+ ///
+ bool subclassOf(UserCommonClass* cl);
+
+ bool isArray();
+ bool isPrimitive();
+ bool isInterface();
+ uint8 getAccess();
+ const UTF8* getName();
+
+ void getDeclaredConstructors(std::vector<JavaMethod*>& res, bool publicOnly);
+ void getDeclaredFields(std::vector<JavaField*>& res, bool publicOnly);
+ void getDeclaredMethods(std::vector<JavaMethod*>& res, bool publicOnly);
+
+ void initialiseClass(Jnjvm* vm);
+ JavaObject* getClassDelegatee(Jnjvm* vm, JavaObject* pd = 0);
+
+ void resolveClass();
+ UserClass* getSuper();
+
+ std::vector<UserClass*>* getInterfaces();
+
+ JavaMethod* lookupMethodDontThrow(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse);
+ JavaMethod* lookupMethod(const UTF8* name, const UTF8* type,
+ bool isStatic, bool recurse);
+
+ uint64 getVirtualSize();
+};
+
+class UserClass : public UserCommonClass {
+public:
+ static VirtualTable* VT;
+ JavaObject* staticInstance;
+
+ virtual void TRACER;
+
+ UserClass(JnjvmClassLoader* JCL, const UTF8* name, ArrayUInt8* bytes);
+
+ JavaObject* doNew(Jnjvm* vm);
+
+ std::vector<UserClass*>* getInnerClasses();
+ UserClass* getOuterClass();
+ void resolveInnerOuterClasses();
+ JavaObject* getStaticInstance();
+
+};
+
+class UserClassArray : public UserCommonClass {
+public:
+ static VirtualTable* VT;
+ UserCommonClass* _baseClass;
+
+ virtual void TRACER;
+ UserClassArray(JnjvmClassLoader* JCL, const UTF8* name);
+
+ UserCommonClass* baseClass();
+
+ AssessorDesc* funcs();
+};
+
+class UserClassPrimitive : public UserCommonClass {
+ static VirtualTable* VT;
+public:
+
+ virtual void TRACER;
+ UserClassPrimitive(JnjvmClassLoader* JCL, const UTF8* name);
+};
+
+} // end namespace jnjvm
+
+#endif // JNJVM_CLASS_ISOLATE_H
Added: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp?rev=55368&view=auto
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp (added)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.cpp Tue Aug 26 04:30:54 2008
@@ -0,0 +1,82 @@
+//===---- IsolateSharedLoader.cpp - Shared loader for isolates ------------===//
+//
+// JnJVM
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "IsolateSharedLoader.h"
+#include "JavaAllocator.h"
+#include "JavaClass.h"
+#include "JnjvmClassLoader.h"
+#include "JnjvmModule.h"
+#include "JnjvmModuleProvider.h"
+#include "LockedMap.h"
+
+using namespace jnjvm;
+
+JnjvmSharedLoader* JnjvmSharedLoader::createSharedLoader() {
+
+ JnjvmSharedLoader* JCL = gc_new(JnjvmSharedLoader)();
+ JCL->TheModule = new JnjvmModule("Bootstrap JnJVM");
+ JCL->TheModuleProvider = new JnjvmModuleProvider(JCL->TheModule);
+
+ JCL->allocator = new JavaAllocator();
+
+ JCL->hashUTF8 = new UTF8Map(JCL->allocator, 0);
+ JCL->classes = allocator_new(allocator, ClassMap)();
+ JCL->nameClasses = allocator_new(allocator, SharedClassNameMap)();
+ JCL->byteClasses = allocator_new(allocator, SharedClassByteMap)();
+ JCL->javaTypes = new TypeMap();
+ JCL->javaSignatures = new SignMap();
+
+ return JCL;
+}
+
+Class* JnjvmSharedLoader::constructSharedClass(const UTF8* name,
+ ArrayUInt8* bytes) {
+ byteClasses->lock->lock();
+ SharedClassByteMap::iterator End = byteClasses->map.end();
+ SharedClassByteMap::iterator I = byteClasses->map.find(bytes);
+ Class* res = 0;
+ if (I == End) {
+ res = allocator_new(allocator, Class)(this, name, bytes);
+ byteClasses->map.insert(std::make_pair(bytes, res));
+ } else {
+ res = ((Class*)(I->second));
+ }
+ byteClasses->lock->unlock();
+ return res;
+}
+
+ClassArray* JnjvmSharedLoader::constructSharedClassArray(const UTF8* name) {
+ nameClasses->lock->lock();
+ SharedClassNameMap::iterator End = nameClasses->map.end();
+ SharedClassNameMap::iterator I = nameClasses->map.find(name);
+ ClassArray* res = 0;
+ if (I == End) {
+ res = allocator_new(allocator, ClassArray)(this, name);
+ nameClasses->map.insert(std::make_pair(name, res));
+ } else {
+ res = ((ClassArray*)(I->second));
+ }
+ nameClasses->lock->unlock();
+ return res;
+}
+
+ClassPrimitive* JnjvmSharedLoader::constructSharedClassPrimitive(const UTF8* name) {
+ nameClasses->lock->lock();
+ SharedClassNameMap::iterator End = nameClasses->map.end();
+ SharedClassNameMap::iterator I = nameClasses->map.find(name);
+ ClassPrimitive* res = 0;
+ if (I == End) {
+ res = new ClassPrimitive(this, name);
+ nameClasses->map.insert(std::make_pair(name, res));
+ } else {
+ res = ((ClassPrimitive*)(I->second));
+ }
+ nameClasses->lock->unlock();
+ return res;
+}
Added: vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.h?rev=55368&view=auto
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.h (added)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/IsolateSharedLoader.h Tue Aug 26 04:30:54 2008
@@ -0,0 +1,53 @@
+//===---- IsolateSharedLoader.h - Shared loader for isolates --------------===//
+//
+// JnJVM
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ISOLATE_SHARED_LOADER_H
+#define ISOLATE_SHARED_LOADER_H
+
+#include "JnjvmClassLoader.h"
+#include "SharedMaps.h"
+
+namespace jnjvm {
+
+class JnjvmSharedLoader : public JnjvmClassLoader {
+private:
+
+ /// internalLoad - Load the class with the given name.
+ ///
+ virtual UserClass* internalLoad(const UTF8* utf8) {
+ fprintf(stderr, "Don't use me");
+ exit(1);
+ }
+
+ SharedClassByteMap* byteClasses;
+ SharedClassNameMap* nameClasses;
+
+public:
+
+ /// 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);
+ ClassArray* constructSharedClassArray(const UTF8* name);
+ ClassPrimitive* constructSharedClassPrimitive(const UTF8* name);
+
+ static JnjvmSharedLoader* createSharedLoader();
+
+ static JnjvmSharedLoader* sharedLoader;
+};
+
+} // end namespace jnjvm
+
+#endif //ISOLATE_SHARED_LOADER_H
Added: vmkit/branches/isolate/lib/JnJVM/Isolate/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/Makefile?rev=55368&view=auto
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/Makefile (added)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/Makefile Tue Aug 26 04:30:54 2008
@@ -0,0 +1,14 @@
+##===- lib/JnJVM/Classpath/Makefile ------------------------*- Makefile -*-===##
+#
+# The vmkit project
+#
+# This file is distributed under the University of Illinois Open Source
+# License. See LICENSE.TXT for details.
+#
+##===----------------------------------------------------------------------===##
+LEVEL = ../../..
+
+LIBRARYNAME = Isolate
+include $(LEVEL)/Makefile.common
+
+CXX.Flags += -I../VMCore
Added: vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h?rev=55368&view=auto
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h (added)
+++ vmkit/branches/isolate/lib/JnJVM/Isolate/SharedMaps.h Tue Aug 26 04:30:54 2008
@@ -0,0 +1,58 @@
+//===------- SharedMaps.h - Maps for the shared class loader --------------===//
+//
+// JnJVM
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "LockedMap.h"
+
+using namespace jnjvm;
+
+
+struct ltarray {
+ bool operator()(const ArrayUInt8* a1, const ArrayUInt8* a2) {
+ if (a1->size < a2->size) return true;
+ else if (a1->size > a2->size) return false;
+ else return memcmp((const char*)a1->elements, (const char*)a2->elements,
+ a1->size * sizeof(uint8)) < 0;
+ }
+};
+
+
+class SharedClassByteMap :
+ public LockedMap<const ArrayUInt8*, Class*, ltarray, JnjvmClassLoader* > {
+public:
+ static VirtualTable* VT;
+
+ SharedClassByteMap() {
+ lock = mvm::Lock::allocNormal();
+ }
+
+ ~SharedClassByteMap() {
+ delete lock;
+ }
+
+ virtual void TRACER;
+};
+
+
+class SharedClassNameMap :
+ public LockedMap<const UTF8*, CommonClass*, ltutf8, JnjvmClassLoader* > {
+public:
+
+ static VirtualTable* VT;
+
+ SharedClassNameMap() {
+ lock = mvm::Lock::allocNormal();
+ }
+
+ ~SharedClassNameMap() {
+ delete lock;
+ }
+
+ virtual void TRACER;
+
+};
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.cpp Tue Aug 26 04:30:54 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)
@@ -160,7 +135,8 @@
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/branches/isolate/lib/JnJVM/VMCore/JavaArray.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaArray.h Tue Aug 26 04:30:54 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
@@ -156,7 +146,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/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.cpp Tue Aug 26 04:30:54 2008
@@ -212,8 +212,8 @@
this->condVar = mvm::Cond::allocCond();
this->status = loaded;
this->classLoader = loader;
- this->isArray = isArray;
- this->isPrimitive = false;
+ this->array = isArray;
+ this->primitive = false;
#ifndef MULTIPLE_VM
this->delegatee = 0;
#endif
@@ -224,7 +224,7 @@
display = (CommonClass**)malloc(sizeof(CommonClass*));
display[0] = this;
- isPrimitive = true;
+ primitive = true;
status = ready;
access = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC;
}
@@ -407,7 +407,7 @@
bool CommonClass::inheritName(const UTF8* Tname) {
if (name->equals(Tname)) {
return true;
- } else if (isPrimitive) {
+ } else if (isPrimitive()) {
return false;
} else if (super) {
if (super->inheritName(Tname)) return true;
@@ -422,7 +422,7 @@
bool CommonClass::isOfTypeName(const UTF8* Tname) {
if (inheritName(Tname)) {
return true;
- } else if (isArray) {
+ } else if (isArray()) {
CommonClass* curS = this;
uint32 prof = 0;
uint32 len = Tname->size;
@@ -432,7 +432,7 @@
CommonClass* cl = ((ClassArray*)curS)->baseClass();
++prof;
cl->resolveClass();
- res = curS->isArray && cl && (prof < len);
+ res = curS->isArray() && cl && (prof < len);
curS = cl;
}
@@ -461,11 +461,11 @@
bool CommonClass::instantiationOfArray(ClassArray* cl) {
if (this == cl) return true;
else {
- if (isArray) {
+ if (isArray()) {
CommonClass* baseThis = ((ClassArray*)this)->baseClass();
CommonClass* baseCl = ((ClassArray*)cl)->baseClass();
- if (isInterface(baseThis->access) && isInterface(baseCl->access)) {
+ if (baseThis->isInterface() && baseCl->isInterface()) {
return baseThis->implements(baseCl);
} else {
return baseThis->isAssignableFrom(baseCl);
@@ -486,9 +486,9 @@
bool CommonClass::isAssignableFrom(CommonClass* cl) {
if (this == cl) {
return true;
- } else if (isInterface(cl->access)) {
+ } else if (cl->isInterface()) {
return this->implements(cl);
- } else if (cl->isArray) {
+ } else if (cl->isArray()) {
return this->instantiationOfArray((ClassArray*)cl);
} else {
return this->subclassOf(cl);
@@ -527,57 +527,6 @@
}
-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);
- }
- 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) {
method_map& map = isStatic(access) ? staticMethods : virtualMethods;
@@ -735,7 +684,7 @@
release();
JavaThread::get()->isolate->unknownError("try to resolve a not-read class");
} else if (status == loaded || ownerClass()) {
- if (isArray) {
+ if (isArray()) {
ClassArray* arrayCl = (ClassArray*)this;
CommonClass* baseClass = arrayCl->baseClass();
baseClass->resolveClass();
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaClass.h Tue Aug 26 04:30:54 2008
@@ -178,6 +178,10 @@
//
//===----------------------------------------------------------------------===//
+
+ uint32 getVirtualSize() {
+ return virtualSize;
+ }
/// virtualTableSize - The size of the virtual table of this class.
///
@@ -187,18 +191,42 @@
///
uint32 access;
+ uint32 getAccess() {
+ return access;
+ }
+
/// isArray - Is the class an array class?
///
- bool isArray;
+ bool array;
+ bool isArray() {
+ return array;
+ }
+
/// isPrimitive - Is the class a primitive class?
///
- bool isPrimitive;
+ bool primitive;
+
+ bool isPrimitive() {
+ return primitive;
+ }
+
+ bool isInterface() {
+ return jnjvm::isInterface(access);
+ }
+
+ std::vector<Class*> * getInterfaces() {
+ return &interfaces;
+ }
/// name - The name of the class.
///
const UTF8* name;
+ const UTF8* getName() {
+ return name;
+ }
+
/// status - The loading/resolve/initialization state of the class.
///
JavaState status;
@@ -206,6 +234,10 @@
/// super - The parent of this class.
///
CommonClass * super;
+
+ CommonClass* getSuper() {
+ return super;
+ }
/// superUTF8 - The name of the parent of this class.
///
@@ -377,29 +409,27 @@
/// 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,12 +462,6 @@
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);
@@ -532,20 +556,11 @@
///
#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();
#endif
+
/// Class - Create a class in the given virtual machine and with the given
/// name.
@@ -893,46 +908,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->getStatus()) >= inClinit); \
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->getStatus()) >= inClinit); \
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);
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaConstantPool.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaConstantPool.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaConstantPool.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaConstantPool.cpp Tue Aug 26 04:30:54 2008
@@ -459,7 +459,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/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaInitialise.cpp Tue Aug 26 04:30:54 2008
@@ -45,8 +45,6 @@
INIT(JavaThread);
INIT(Jnjvm);
INIT(ClassMap);
- INIT(StaticInstanceMap);
- INIT(DelegateeMap);
INIT(JnjvmBootstrapLoader);
INIT(JnjvmClassLoader);
#ifdef MULTIPLE_VM
@@ -72,14 +70,15 @@
static void initialiseStatics() {
- JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader =
+ JnjvmBootstrapLoader* JCL = JnjvmClassLoader::bootstrapLoader =
JnjvmBootstrapLoader::createBootstrapLoader();
// Array initialization
const UTF8* utf8OfChar = JCL->asciizConstructUTF8("[C");
- JavaArray::ofChar = JCL->constructArray(utf8OfChar);
- ((UTF8*)utf8OfChar)->classOf = JavaArray::ofChar;
-
+ JCL->upcalls->ArrayOfChar = JCL->constructArray(utf8OfChar);
+ ((UTF8*)utf8OfChar)->classOf = JCL->upcalls->ArrayOfChar;
+ JCL->hashUTF8->array = JCL->upcalls->ArrayOfChar;
+
ClassArray::InterfacesArray.push_back(
JCL->loadName(JCL->asciizConstructUTF8("java/lang/Cloneable"), false,
false));
@@ -92,27 +91,27 @@
JCL->loadName(JCL->asciizConstructUTF8("java/lang/Object"), false,
false);
- JavaArray::ofChar->interfaces = ClassArray::InterfacesArray;
- JavaArray::ofChar->super = ClassArray::SuperArray;
+ JCL->upcalls->ArrayOfChar->interfaces = ClassArray::InterfacesArray;
+ JCL->upcalls->ArrayOfChar->super = ClassArray::SuperArray;
- JavaArray::ofByte = JCL->constructArray(JCL->asciizConstructUTF8("[B"));
- JavaArray::ofString =
+ JCL->upcalls->ArrayOfByte = JCL->constructArray(JCL->asciizConstructUTF8("[B"));
+ JCL->upcalls->ArrayOfString =
JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/String;"));
- JavaArray::ofObject =
+ JCL->upcalls->ArrayOfObject =
JCL->constructArray(JCL->asciizConstructUTF8("[Ljava/lang/Object;"));
- JavaArray::ofInt = JCL->constructArray(JCL->asciizConstructUTF8("[I"));
+ JCL->upcalls->ArrayOfInt = JCL->constructArray(JCL->asciizConstructUTF8("[I"));
- JavaArray::ofBool = JCL->constructArray(JCL->asciizConstructUTF8("[Z"));
+ JCL->upcalls->ArrayOfBool = JCL->constructArray(JCL->asciizConstructUTF8("[Z"));
- JavaArray::ofLong = JCL->constructArray(JCL->asciizConstructUTF8("[J"));
+ JCL->upcalls->ArrayOfLong = JCL->constructArray(JCL->asciizConstructUTF8("[J"));
- JavaArray::ofFloat = JCL->constructArray(JCL->asciizConstructUTF8("[F"));
+ JCL->upcalls->ArrayOfFloat = JCL->constructArray(JCL->asciizConstructUTF8("[F"));
- JavaArray::ofDouble = JCL->constructArray(JCL->asciizConstructUTF8("[D"));
+ JCL->upcalls->ArrayOfDouble = JCL->constructArray(JCL->asciizConstructUTF8("[D"));
- JavaArray::ofShort = JCL->constructArray(JCL->asciizConstructUTF8("[S"));
+ JCL->upcalls->ArrayOfShort = JCL->constructArray(JCL->asciizConstructUTF8("[S"));
// End array initialization
@@ -170,17 +169,13 @@
#undef DEF_UTF8
+ Classpath::initialiseClasspath(JCL);
}
-extern "C" void ClasspathBoot();
-
void mvm::VirtualMachine::initialiseJVM() {
if (!JnjvmClassLoader::bootstrapLoader) {
initialiseVT();
- initialiseStatics();
-
- ClasspathBoot();
- Classpath::initialiseClasspath(JnjvmClassLoader::bootstrapLoader);
+ initialiseStatics();
}
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJIT.h Tue Aug 26 04:30:54 2008
@@ -259,8 +259,8 @@
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/branches/isolate/lib/JnJVM/VMCore/JavaJITOpcodes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJITOpcodes.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJITOpcodes.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaJITOpcodes.cpp Tue Aug 26 04:30:54 2008
@@ -2086,9 +2086,6 @@
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);
break;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaMetaJIT.cpp Tue Aug 26 04:30:54 2008
@@ -32,7 +32,7 @@
CommonClass* cl = loader->loadName(loader->asciizConstructUTF8(className),
true, true);
- vm->initialiseClass(cl);
+ cl->initialiseClass(vm);
bool stat = access == ACC_STATIC ? true : false;
JavaMethod* method = cl->lookupMethod(loader->asciizConstructUTF8(func),
loader->asciizConstructUTF8(sign), stat,
@@ -94,7 +94,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
verifyNull(obj); \
Signdef* sign = getSignature(); \
@@ -108,7 +108,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj);\
@@ -123,7 +123,7 @@
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, va_list ap) {\
if (!classDef->isReady()) { \
classDef->classLoader->loadName(classDef->name, true, true); \
- vm->initialiseClass(classDef); \
+ classDef->initialiseClass(vm); \
} \
\
Signdef* sign = getSignature(); \
@@ -137,7 +137,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj);\
@@ -151,7 +151,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj);\
@@ -163,7 +163,7 @@
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, void* buf) {\
if (!classDef->isReady()) { \
classDef->classLoader->loadName(classDef->name, true, true); \
- vm->initialiseClass(classDef); \
+ classDef->initialiseClass(vm); \
} \
\
void* func = this->compiledPtr();\
@@ -202,7 +202,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj); \
@@ -214,7 +214,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj);\
@@ -226,7 +226,7 @@
TYPE JavaMethod::invoke##TYPE_NAME##StaticAP(Jnjvm* vm, va_list ap) {\
if (!classDef->isReady()) { \
classDef->classLoader->loadName(classDef->name, true, true); \
- vm->initialiseClass(classDef); \
+ classDef->initialiseClass(vm); \
} \
\
void* func = this->compiledPtr();\
@@ -237,7 +237,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj);\
@@ -249,7 +249,7 @@
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); \
+ classDef->initialiseClass(vm); \
} \
\
verifyNull(obj);\
@@ -261,7 +261,7 @@
TYPE JavaMethod::invoke##TYPE_NAME##StaticBuf(Jnjvm* vm, void* buf) {\
if (!classDef->isReady()) { \
classDef->classLoader->loadName(classDef->name, true, true); \
- vm->initialiseClass(classDef); \
+ classDef->initialiseClass(vm); \
} \
\
void* func = this->compiledPtr();\
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaObject.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaObject.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaObject.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaObject.h Tue Aug 26 04:30:54 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/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaRuntimeJIT.cpp Tue Aug 26 04:30:54 2008
@@ -31,7 +31,7 @@
using namespace jnjvm;
#ifdef MULTIPLE_VM
-extern "C" JavaString* stringLookup(Class* cl, uint32 index) {
+extern "C" JavaString* stringLookup(UserClass* cl, uint32 index) {
JavaConstantPool* ctpInfo = cl->getConstantPool();
const UTF8* utf8 = ctpInfo->UTF8At(ctpInfo->ctpDef[index]);
JavaString* str = JavaThread::get()->isolate->UTF8ToStr(utf8);
@@ -42,8 +42,8 @@
extern "C" void* jnjvmVirtualLookup(CacheNode* cache, JavaObject *obj) {
Enveloppe* enveloppe = cache->enveloppe;
JavaConstantPool* ctpInfo = enveloppe->ctpInfo;
- CommonClass* ocl = obj->classOf;
- CommonClass* cl = 0;
+ UserCommonClass* ocl = obj->classOf;
+ UserCommonClass* cl = 0;
const UTF8* utf8 = 0;
Signdef* sign = 0;
uint32 index = enveloppe->index;
@@ -77,7 +77,7 @@
}
rcache->methPtr = dmeth->compiledPtr();
- rcache->lastCible = (Class*)ocl;
+ rcache->lastCible = (UserClass*)ocl;
}
@@ -93,14 +93,14 @@
return rcache->methPtr;
}
-extern "C" void* fieldLookup(JavaObject* obj, Class* caller, uint32 index,
+extern "C" void* fieldLookup(JavaObject* obj, UserClass* caller, uint32 index,
uint32 stat) {
JavaConstantPool* ctpInfo = caller->getConstantPool();
if (ctpInfo->ctpRes[index]) {
return ctpInfo->ctpRes[index];
}
- CommonClass* cl = 0;
+ UserCommonClass* cl = 0;
const UTF8* utf8 = 0;
Typedef* sign = 0;
@@ -110,9 +110,9 @@
void* ptr = 0;
if (stat) {
- Class* fieldCl = field->classDef;
- JavaThread::get()->isolate->initialiseClass(fieldCl);
- ptr = (void*)((uint64)(fieldCl->staticInstance()) + field->ptrOffset);
+ UserClass* fieldCl = field->classDef;
+ fieldCl->initialiseClass(JavaThread::get()->isolate);
+ ptr = (void*)((uint64)(fieldCl->getStaticInstance()) + field->ptrOffset);
#ifndef MULTIPLE_VM
ctpInfo->ctpRes[index] = ptr;
#endif
@@ -169,7 +169,7 @@
JavaThread::get()->isolate->outOfMemoryError(val);
}
-extern "C" void jnjvmClassCastException(JavaObject* obj, CommonClass* cl) {
+extern "C" void jnjvmClassCastException(JavaObject* obj, UserCommonClass* cl) {
JavaThread::get()->isolate->classCastException("");
}
@@ -178,7 +178,7 @@
}
#ifdef MULTIPLE_VM
-extern "C" JavaObject* getStaticInstance(Class* cl, Jnjvm* vm) {
+extern "C" JavaObject* getStaticInstance(UserClass* cl, Jnjvm* vm) {
std::pair<JavaState, JavaObject*>* val = vm->statics->lookup(cl);
if (!val || !(val->second)) {
vm->initialiseClass(cl);
@@ -188,25 +188,25 @@
}
#endif
-extern "C" CommonClass* initialisationCheck(CommonClass* cl) {
- JavaThread::get()->isolate->initialiseClass(cl);
+extern "C" CommonClass* 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);
+ return cl->getClassDelegatee(vm);
}
-extern "C" Class* newLookup(Class* caller, uint32 index) {
+extern "C" Class* newLookup(UserClass* caller, uint32 index) {
JavaConstantPool* ctpInfo = caller->getConstantPool();
- Class* cl = (Class*)ctpInfo->loadClass(index);
+ UserClass* cl = (UserClass*)ctpInfo->loadClass(index);
return cl;
}
#ifndef WITHOUT_VTABLE
-extern "C" uint32 vtableLookup(JavaObject* obj, Class* caller, uint32 index) {
- CommonClass* cl = 0;
+extern "C" uint32 vtableLookup(JavaObject* obj, UserClass* caller, uint32 index) {
+ UserCommonClass* cl = 0;
const UTF8* utf8 = 0;
Signdef* sign = 0;
@@ -229,7 +229,7 @@
#endif
-static JavaArray* multiCallNewIntern(arrayCtor_t ctor, ClassArray* cl,
+static JavaArray* multiCallNewIntern(arrayCtor_t ctor, UserClassArray* cl,
uint32 len,
sint32* dims,
Jnjvm* vm) {
@@ -237,9 +237,9 @@
JavaArray* _res = ctor(dims[0], cl, vm);
if (len > 1) {
ArrayObject* res = (ArrayObject*)_res;
- CommonClass* _base = cl->baseClass();
- if (_base->isArray) {
- ClassArray* base = (ClassArray*)_base;
+ UserCommonClass* _base = cl->baseClass();
+ if (_base->isArray()) {
+ UserClassArray* base = (UserClassArray*)_base;
AssessorDesc* func = base->funcs();
arrayCtor_t newCtor = func->arrayCtor;
if (dims[0] > 0) {
@@ -260,18 +260,14 @@
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
+ Jnjvm* vm = JavaThread::get()->isolate;
return multiCallNewIntern((arrayCtor_t)ArrayObject::acons, cl, len, dims, vm);
}
@@ -309,19 +305,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 +333,7 @@
return JavaThread::getJavaException();
}
-extern "C" bool JavaThreadCompareException(Class* cl) {
+extern "C" bool JavaThreadCompareException(UserClass* cl) {
return JavaThread::compareException(cl);
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaString.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaString.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaString.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaString.cpp Tue Aug 26 04:30:54 2008
@@ -17,13 +17,13 @@
JavaString* JavaString::stringDup(const UTF8*& utf8, Jnjvm* vm) {
- Class* cl = Classpath::newString;
+ Class* cl = vm->upcalls->newString;
JavaString* res = (JavaString*)malloc(cl->virtualSize);
((void**)res)[0] = cl->virtualVT;
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 +44,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/branches/isolate/lib/JnJVM/VMCore/JavaThread.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaThread.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaThread.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaThread.h Tue Aug 26 04:30:54 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/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.cpp Tue Aug 26 04:30:54 2008
@@ -18,6 +18,7 @@
#include "JavaJIT.h"
#include "JavaThread.h"
#include "JavaTypes.h"
+#include "JavaUpcalls.h"
#include "Jnjvm.h"
using namespace jnjvm;
@@ -81,7 +82,7 @@
}
}
-void AssessorDesc::initialise(JnjvmClassLoader* vm) {
+void AssessorDesc::initialise(JnjvmBootstrapLoader* vm) {
dParg = new AssessorDesc(false, I_PARG, 0, 0, "(", vm, 0, 0, 0,
0);
@@ -92,38 +93,38 @@
dBool = new AssessorDesc(false, I_BOOL, 1, 1, "boolean",
vm,
BOOL_ID, "java/lang/Boolean",
- JavaArray::ofBool,
+ vm->upcalls->ArrayOfBool,
(arrayCtor_t)ArrayUInt8::acons);
dByte = new AssessorDesc(false, I_BYTE, 1, 1, "byte",
vm, BYTE_ID, "java/lang/Byte",
- JavaArray::ofByte,
+ vm->upcalls->ArrayOfByte,
(arrayCtor_t)ArraySInt8::acons);
dChar = new AssessorDesc(false, I_CHAR, 2, 1, "char",
vm, CHAR_ID, "java/lang/Character",
- JavaArray::ofChar,
+ vm->upcalls->ArrayOfChar,
(arrayCtor_t)ArrayUInt16::acons);
dShort = new AssessorDesc(false, I_SHORT, 2, 1, "short",
vm, SHORT_ID,
"java/lang/Short",
- JavaArray::ofShort,
+ vm->upcalls->ArrayOfShort,
(arrayCtor_t)ArraySInt16::acons);
dInt = new AssessorDesc(false, I_INT, 4, 1, "int", vm,
INT_ID, "java/lang/Integer",
- JavaArray::ofInt,
+ vm->upcalls->ArrayOfInt,
(arrayCtor_t)ArraySInt32::acons);
dFloat = new AssessorDesc(false, I_FLOAT, 4, 1, "float",
vm,
FLOAT_ID, "java/lang/Float",
- JavaArray::ofFloat,
+ vm->upcalls->ArrayOfFloat,
(arrayCtor_t)ArrayFloat::acons);
dLong = new AssessorDesc(false, I_LONG, 8, 2, "long",
vm, LONG_ID, "java/lang/Long",
- JavaArray::ofLong,
+ vm->upcalls->ArrayOfLong,
(arrayCtor_t)ArrayLong::acons);
dDouble = new AssessorDesc(false, I_DOUBLE, 8, 2, "double",
vm,
DOUBLE_ID, "java/lang/Double",
- JavaArray::ofDouble,
+ vm->upcalls->ArrayOfDouble,
(arrayCtor_t)ArrayDouble::acons);
dTab = new AssessorDesc(true, I_TAB, sizeof(void*), 1, "array",
vm, ARRAY_ID, 0, 0,
@@ -378,23 +379,23 @@
AssessorDesc* AssessorDesc::classToPrimitive(CommonClass* cl) {
const UTF8* name = cl->name;
- if (name == dFloat->assocClassName) {
+ if (name->equals(dFloat->assocClassName)) {
return dFloat;
- } else if (name == dInt->assocClassName) {
+ } else if (name->equals(dInt->assocClassName)) {
return dInt;
- } else if (name == dShort->assocClassName) {
+ } else if (name->equals(dShort->assocClassName)) {
return dShort;
- } else if (name == dChar->assocClassName) {
+ } else if (name->equals(dChar->assocClassName)) {
return dChar;
- } else if (name == dDouble->assocClassName) {
+ } else if (name->equals(dDouble->assocClassName)) {
return dDouble;
- } else if (name == dByte->assocClassName) {
+ } else if (name->equals(dByte->assocClassName)) {
return dByte;
- } else if (name == dBool->assocClassName) {
+ } else if (name->equals(dBool->assocClassName)) {
return dBool;
- } else if (name == dLong->assocClassName) {
+ } else if (name->equals(dLong->assocClassName)) {
return dLong;
- } else if (name == dVoid->assocClassName) {
+ } else if (name->equals(dVoid->assocClassName)) {
return dVoid;
} else {
return 0;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaTypes.h Tue Aug 26 04:30:54 2008
@@ -19,10 +19,12 @@
class ClassArray;
class CommonClass;
+class UserCommonClass;
class JavaArray;
class JavaJIT;
class JavaObject;
class Jnjvm;
+class JnjvmBootstrapLoader;
class JnjvmClassLoader;
class UTF8;
@@ -188,7 +190,7 @@
/// initialise - Construct all assessors.
///
- static void initialise(JnjvmClassLoader* loader);
+ static void initialise(JnjvmBootstrapLoader* loader);
/// printString - Print the assessor for debugging purposes.
@@ -251,7 +253,7 @@
/// assocClass - Given the loaded, try to load the class represented by this
/// Typedef.
///
- CommonClass* assocClass(JnjvmClassLoader* loader);
+ UserCommonClass* assocClass(JnjvmClassLoader* loader);
/// humanPrintArgs - Prints the list of typedef in a human readable form.
///
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.cpp Tue Aug 26 04:30:54 2008
@@ -36,6 +36,7 @@
using namespace jnjvm;
+#ifndef MULTIPLE_VM
Class* Classpath::newThread;
Class* Classpath::newVMThread;
JavaField* Classpath::assocThread;
@@ -177,36 +178,54 @@
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;
+
+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);
+ 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);
+ 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(rootGroup->classDef->name, true, true);
- vm->initialiseClass(rootGroup->classDef);
- JavaObject* RG = rootGroup->getStaticObjectField();
- group->setVirtualObjectField(th, RG);
+ rootGroup->classDef->initialiseClass(vm);
+ JavaObject* Stat = rootGroup->classDef->getStaticInstance();
+ JavaObject* RG = rootGroup->getObjectField(Stat);
+ group->setObjectField(th, RG);
groupAddThread->invokeIntSpecial(vm, RG, th);
}
void Classpath::mapInitialThread(Jnjvm* vm) {
JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
JCL->loadName(newThread->name, true, true);
- vm->initialiseClass(newThread);
+ 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);
+ JavaObject* vmth = vmThread->getObjectField(th);
+ vmdataVMThread->setObjectField(vmth, (JavaObject*)myth);
finaliseCreateInitialThread->invokeIntStatic(vm, th);
}
@@ -520,6 +539,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);
@@ -554,7 +585,7 @@
extern "C" uint8 isArray(JavaObject* klass) {
CommonClass* cl =
- (CommonClass*)((Classpath::vmdataClass->getVirtualObjectField(klass)));
+ (CommonClass*)((Classpath::vmdataClass->getObjectField(klass)));
- return (uint8)cl->isArray;
+ return (uint8)cl->isArray();
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JavaUpcalls.h Tue Aug 26 04:30:54 2008
@@ -10,6 +10,7 @@
#ifndef JNJVM_JAVA_UPCALLS_H
#define JNJVM_JAVA_UPCALLS_H
+#include "JnjvmConfig.h"
#define UPCALL_CLASS(vm, name) \
vm->loadName(vm->asciizConstructUTF8(name), false, false)
@@ -53,151 +54,167 @@
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 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* groupAddThread;
+ ISOLATE_STATIC JavaField* name;
+ ISOLATE_STATIC JavaField* priority;
+ ISOLATE_STATIC JavaField* daemon;
+ ISOLATE_STATIC JavaField* group;
+ ISOLATE_STATIC JavaField* running;
+ ISOLATE_STATIC JavaField* rootGroup;
+ ISOLATE_STATIC JavaField* vmThread;
+ ISOLATE_STATIC JavaMethod* uncaughtException;
+
+ 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* ArrayOfString;
+ 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;
- 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/branches/isolate/lib/JnJVM/VMCore/Jni.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Jni.cpp Tue Aug 26 04:30:54 2008
@@ -63,7 +63,7 @@
BEGIN_EXCEPTION
JnjvmClassLoader* loader = 0;
- Class* currentClass = JavaJIT::getCallingClass();
+ UserClass* currentClass = JavaJIT::getCallingClass();
if (currentClass) loader = currentClass->classLoader;
else loader = JnjvmClassLoader::bootstrapLoader;
@@ -71,9 +71,10 @@
sint32 len = utf8->size;
- CommonClass* cl = loader->lookupClassFromUTF8(utf8, 0, len, true, true);
- JavaThread::get()->isolate->initialiseClass(cl);
- return (jclass)(cl->getClassDelegatee());
+ UserCommonClass* cl = loader->lookupClassFromUTF8(utf8, 0, len, true, true);
+ Jnjvm* vm = JavaThread::get()->isolate;
+ 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,9 +137,9 @@
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);
+ UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
+ if (cl->isArray()) assert(0 && "implement me");
+ JavaObject* res = ((UserClass*)cl)->doNew(vm);
JavaMethod* init =
cl->lookupMethod(Jnjvm::initName,
cl->classLoader->asciizConstructUTF8("(Ljava/lang/String;)V"), 0, 1);
@@ -209,9 +211,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,7 +226,7 @@
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);
@@ -255,7 +257,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,7 +297,7 @@
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);
JavaMethod* meth = cl->lookupMethod(
@@ -830,7 +833,7 @@
BEGIN_EXCEPTION
// TODO: find a better place to store the UTF8
- CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
+ UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
return (jfieldID)
cl->lookupField(cl->classLoader->asciizConstructUTF8(name),
cl->classLoader->asciizConstructUTF8(sig), 0, 1);
@@ -847,7 +850,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 +863,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 +876,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 +889,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 +902,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 +915,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 +928,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 +941,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- return field->getVirtualFloatField(o);
+ return field->getFloatField(o);
END_EXCEPTION
return 0;
@@ -951,7 +954,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 +967,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualObjectField(o, (JavaObject*)value);
+ field->setObjectField(o, (JavaObject*)value);
END_EXCEPTION
}
@@ -977,7 +980,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualInt8Field(o, (uint8)value);
+ field->setInt8Field(o, (uint8)value);
END_EXCEPTION
}
@@ -989,7 +992,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualInt8Field(o, (uint8)value);
+ field->setInt8Field(o, (uint8)value);
END_EXCEPTION
}
@@ -1001,7 +1004,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualInt16Field(o, (uint16)value);
+ field->setInt16Field(o, (uint16)value);
END_EXCEPTION
}
@@ -1013,7 +1016,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualInt16Field(o, (sint16)value);
+ field->setInt16Field(o, (sint16)value);
END_EXCEPTION
}
@@ -1025,7 +1028,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualInt32Field(o, (sint32)value);
+ field->setInt32Field(o, (sint32)value);
END_EXCEPTION
}
@@ -1037,7 +1040,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualLongField(o, (sint64)value);
+ field->setLongField(o, (sint64)value);
END_EXCEPTION
}
@@ -1049,7 +1052,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualFloatField(o, (float)value);
+ field->setFloatField(o, (float)value);
END_EXCEPTION
}
@@ -1061,7 +1064,7 @@
JavaField* field = (JavaField*)fieldID;
JavaObject* o = (JavaObject*)obj;
- field->setVirtualDoubleField(o, (float)value);
+ field->setDoubleField(o, (float)value);
END_EXCEPTION
}
@@ -1073,7 +1076,7 @@
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);
JavaMethod* meth = cl->lookupMethod(
@@ -1323,7 +1326,7 @@
BEGIN_EXCEPTION
// TODO: find a better place to store the UTF8
- CommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
+ UserCommonClass* cl = NativeUtil::resolvedImplClass(clazz, true);
return (jfieldID)
cl->lookupField(cl->classLoader->asciizConstructUTF8(name),
cl->classLoader->asciizConstructUTF8(sig), true, true);
@@ -1338,7 +1341,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 +1355,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 +1369,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 +1383,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 +1397,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 +1411,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 +1425,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 +1439,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 +1453,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 +1468,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 +1482,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 +1496,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 +1510,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 +1524,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 +1538,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 +1552,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 +1566,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 +1580,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 +1663,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);
+ UserClassArray* array = loader->constructArray(arrayName);
ArrayObject* res = ArrayObject::acons(length, array, &(vm->allocator));
if (initialElement) {
memset(res->elements, (int)initialElement,
@@ -1673,7 +1712,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 +1727,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 +1742,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 +1757,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 +1772,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 +1787,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 +1802,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 +1817,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 +2198,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/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.cpp Tue Aug 26 04:30:54 2008
@@ -87,49 +87,45 @@
typedef void (*clinit_t)(Jnjvm* vm);
-void Jnjvm::initialiseClass(CommonClass* cl) {
- JavaState* status = cl->getStatus();
+void CommonClass::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) {
+ status = clinitParent;
+ release();
+ if (super) {
+ super->initialiseClass(vm);
}
- cl->classLoader->TheModule->resolveStaticClass((Class*)cl);
+ classLoader->TheModule->resolveStaticClass((Class*)this);
- *status = inClinit;
- JavaMethod* meth = cl->lookupMethodDontThrow(clinitName, clinitType, true,
- false);
+ status = inClinit;
+ JavaMethod* meth = lookupMethodDontThrow(Jnjvm::clinitName,
+ Jnjvm::clinitType, true,
+ false);
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());
if (meth) {
JavaObject* exc = 0;
try{
clinit_t pred = (clinit_t)(intptr_t)meth->compiledPtr();
- pred(JavaThread::get()->isolate);
+ pred(vm);
} 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,18 +133,18 @@
}
}
- *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();
}
}
}
@@ -173,18 +169,18 @@
}
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 +188,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,
+ error(upcalls->ClassCastException,
+ upcalls->InitClassCastException,
msg);
}
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->printString(), cl->printString());
}
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->printString(), cl->printString());
}
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 +308,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 +316,22 @@
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* CommonClass::getClassDelegatee(Jnjvm* vm, JavaObject* pd) {
+ acquire();
+ if (!(delegatee)) {
+ JavaObject* delegatee = vm->upcalls->newClass->doNew(vm);
if (!pd) {
- Classpath::initClass->invokeIntSpecial(this, val, cl);
+ vm->upcalls->initClass->invokeIntSpecial(vm, delegatee, this);
} else {
- Classpath::initClassWithProtectionDomain->invokeIntSpecial(this, val, cl,
- pd);
+ vm->upcalls->initClassWithProtectionDomain->invokeIntSpecial(vm,
+ delegatee,
+ this, pd);
}
+ this->delegatee = delegatee;
}
- cl->release();
- return val;
+ release();
+ return delegatee;
}
-#endif
Jnjvm::~Jnjvm() {
#ifdef MULTIPLE_GC
@@ -455,7 +431,8 @@
if (archive.getOfscd() != -1) {
ZipFile* file = archive.getFile(PATH_MANIFEST);
if (file) {
- ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, JavaArray::ofByte, &vm->allocator);
+ ClassArray* 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);
@@ -654,71 +631,71 @@
JnjvmClassLoader* Jnjvm::loadAppClassLoader() {
if (appClassLoader == 0) {
- JavaObject* loader = Classpath::getSystemClassLoader->invokeJavaObjectStatic(this);
+ JavaObject* loader = upcalls->getSystemClassLoader->invokeJavaObjectStatic(this);
appClassLoader = JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader);
}
return appClassLoader;
}
void Jnjvm::mapInitialThread() {
- Classpath::mapInitialThread(this);
+ upcalls->mapInitialThread(this);
}
void Jnjvm::loadBootstrap() {
JnjvmClassLoader* loader = JnjvmClassLoader::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->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,
+ upcalls->setContextClassLoader->invokeIntSpecial(this, obj,
appClassLoader->getJavaClassLoader());
// load and initialise math since it is responsible for dlopen'ing
// libjavalang.so and we are optimizing some math operations
CommonClass* math =
loader->loadName(loader->asciizConstructUTF8("java/lang/Math"), true, true);
- initialiseClass(math);
+ math->initialiseClass(this);
}
void Jnjvm::executeClass(const char* className, ArrayObject* args) {
@@ -733,9 +710,9 @@
JavaThread::clearException();
JavaObject* obj = JavaThread::currentThread();
JavaObject* group =
- Classpath::group->getVirtualObjectField(obj);
+ upcalls->group->getObjectField(obj);
try{
- Classpath::uncaughtException->invokeIntSpecial(this, group, obj,
+ upcalls->uncaughtException->invokeIntSpecial(this, group, obj,
exc);
}catch(...) {
printf("Even uncaught exception throwed an exception!\n");
@@ -789,9 +766,9 @@
executePremain(i->first, args, instrumenter);
}
}
-
- ArrayObject* args = ArrayObject::acons(argc - 2, JavaArray::ofString,
- &allocator);
+
+ ClassArray* 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]);
}
@@ -839,10 +816,8 @@
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)();
-#endif
+ isolate->bootstrapLoader = JnjvmClassLoader::bootstrapLoader;
+ isolate->upcalls = isolate->bootstrapLoader->upcalls;
return isolate;
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Jnjvm.h Tue Aug 26 04:30:54 2008
@@ -21,20 +21,24 @@
#include "mvm/Threads/Locks.h"
#include "JavaAllocator.h"
+#include "JavaTypes.h"
namespace jnjvm {
class ArrayObject;
class ArrayUInt8;
class Attribut;
-class Class;
-class ClassArray;
-class CommonClass;
+class UserClass;
+class UserClassArray;
+class Classpath;
+class UserCommonClass;
+class UserClassPrimitive;
class JavaField;
class JavaMethod;
class JavaObject;
class JavaString;
class JavaThread;
+class JnjvmBootstrapLoader;
class JnjvmClassLoader;
class JnjvmModule;
class JnjvmModuleProvider;
@@ -113,11 +117,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.
@@ -222,6 +226,15 @@
Collector* GC;
#endif
+ /// bootstraLoader - Bootstrap loader for base classes of this virtual
+ /// machine.
+ ///
+ JnjvmBootstrapLoader* bootstrapLoader;
+
+ /// upcalls - Upcalls to call Java methods and access Java fields.
+ ///
+ Classpath* upcalls;
+
/// threadSystem - The thread system to manage non-daemon threads and
/// control the end of the JVM's execution.
///
@@ -274,18 +287,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,26 +300,20 @@
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 unknownError(const char* fmt, ...);
- void noSuchFieldError(CommonClass* cl, const UTF8* name);
- void noSuchMethodError(CommonClass* cl, const UTF8* name);
+ void noSuchFieldError(UserCommonClass* cl, const UTF8* name);
+ void noSuchMethodError(UserCommonClass* cl, const UTF8* name);
void classFormatError(const char* fmt, ...);
void noClassDefFoundError(JavaObject* obj);
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 +322,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();
@@ -364,7 +354,14 @@
/// User-visible function, inherited by the VirtualMachine class.
///
virtual void runApplication(int argc, char** argv);
-
+
+#ifdef MULTIPLE_VM
+ UserClassPrimitive* getPrimitiveClass(const AssessorDesc* ass);
+#else
+ UserClassPrimitive* getPrimitiveClass(const AssessorDesc* ass) {
+ return (UserClassPrimitive*)ass->classType;
+ }
+#endif
};
} // end namespace jnjvm
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.cpp Tue Aug 26 04:30:54 2008
@@ -14,6 +14,7 @@
#include "debug.h"
#include "JavaAllocator.h"
+#include "JavaClass.h"
#include "JavaConstantPool.h"
#include "JavaThread.h"
#include "JavaUpcalls.h"
@@ -28,10 +29,6 @@
JnjvmBootstrapLoader* JnjvmClassLoader::bootstrapLoader = 0;
-#ifdef MULTIPLE_VM
-JnjvmSharedLoader* JnjvmClassLoader::sharedLoader = 0;
-#endif
-
extern const char* GNUClasspathGlibj;
extern const char* GNUClasspathLibs;
@@ -44,7 +41,7 @@
JCL->allocator = new JavaAllocator();
- JCL->hashUTF8 = new UTF8Map(JCL->allocator);
+ JCL->hashUTF8 = new UTF8Map(JCL->allocator, JCL->upcalls->ArrayOfChar);
JCL->classes = allocator_new(allocator, ClassMap)();
JCL->javaTypes = new TypeMap();
JCL->javaSignatures = new SignMap();
@@ -64,25 +61,6 @@
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();
-
- return JCL;
-}
-#endif
-
JnjvmClassLoader::JnjvmClassLoader(JnjvmClassLoader& JCL, JavaObject* loader, Jnjvm* I) {
TheModule = JCL.TheModule;
TheModuleProvider = JCL.TheModuleProvider;
@@ -129,9 +107,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 +118,32 @@
}
}
- 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;
JavaObject* obj = (JavaObject*)
- Classpath::loadInClassLoader->invokeJavaObjectVirtual(isolate, javaLoader,
+ upcalls->loadInClassLoader->invokeJavaObjectVirtual(isolate, javaLoader,
str);
- cl = (CommonClass*)(Classpath::vmdataClass->getVirtualObjectField(obj));
+ 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,14 +157,14 @@
return cl;
}
-CommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
+UserCommonClass* JnjvmClassLoader::lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
unsigned int len,
bool doResolve,
bool doThrow) {
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;
@@ -242,57 +221,44 @@
}
}
-CommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str,
+UserCommonClass* JnjvmClassLoader::lookupClassFromJavaString(JavaString* str,
bool doResolve, bool doThrow) {
return lookupClassFromUTF8(str->value, str->offset, str->count,
doResolve, doThrow);
}
-CommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) {
+UserCommonClass* JnjvmClassLoader::lookupClass(const UTF8* utf8) {
return classes->lookup(utf8);
}
-static CommonClass* arrayDup(const UTF8*& name, JnjvmClassLoader* loader) {
- ClassArray* cl = allocator_new(loader->allocator, ClassArray)(loader, name);
+static UserCommonClass* arrayDup(const UTF8*& name, JnjvmClassLoader* loader) {
+ UserClassArray* cl = allocator_new(loader->allocator, UserClassArray)(loader, name);
return cl;
}
-ClassArray* JnjvmClassLoader::constructArray(const UTF8* name) {
+UserClassArray* JnjvmClassLoader::constructArray(const UTF8* name) {
if (javaLoader != 0) {
JnjvmClassLoader * ld =
ClassArray::arrayLoader(name, this, 1, name->size - 1);
- ClassArray* res =
+ UserClassArray* res =
(ClassArray*)ld->classes->lookupOrCreate(name, this, arrayDup);
return res;
} else {
- return (ClassArray*)classes->lookupOrCreate(name, this, arrayDup);
+ return (UserClassArray*)classes->lookupOrCreate(name, this, arrayDup);
}
}
-Class* JnjvmSharedLoader::constructSharedClass(const UTF8* name,
- ArrayUInt8* bytes) {
-
- return 0;
-}
-
-
-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;
- }
-#endif
classes->lock->lock();
ClassMap::iterator End = classes->map.end();
ClassMap::iterator I = classes->map.find(name);
- Class* res = 0;
+ UserClass* res = 0;
if (I == End) {
- res = allocator_new(allocator, Class)(this, name, bytes);
+ res = allocator_new(allocator, UserClass)(this, name, bytes);
classes->map.insert(std::make_pair(name, res));
} else {
- res = ((Class*)(I->second));
+ res = ((UserClass*)(I->second));
}
classes->lock->unlock();
return res;
@@ -329,13 +295,14 @@
if (loader == 0)
return bootstrapLoader;
-
+
+ Classpath* upcalls = 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));
+ (upcalls->vmdataClassLoader->setObjectField(loader, (JavaObject*)JCL));
}
return JCL;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmClassLoader.h Tue Aug 26 04:30:54 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.
@@ -136,33 +136,33 @@
/// 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,
+ UserCommonClass* lookupClassFromUTF8(const UTF8* utf8, unsigned int start,
unsigned int len, 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);
/// 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.
@@ -187,12 +187,6 @@
///
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.
@@ -212,33 +206,6 @@
};
-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:
-
- /// 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();
-};
-
-
/// JnjvmBootstrapLoader - This class is for the bootstrap class loader, which
/// loads base classes, ie glibj.zip or rt.jar and -Xbootclasspath.
///
@@ -246,7 +213,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 +262,10 @@
///
static JnjvmBootstrapLoader* createBootstrapLoader();
-
+ /// upcalls - Upcall classes, fields and methods so that C++ code can call
+ /// Java code.
+ ///
+ Classpath* upcalls;
};
} // end namespace jnjvm
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.cpp Tue Aug 26 04:30:54 2008
@@ -164,7 +164,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 +175,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
}
@@ -409,7 +408,7 @@
const Type* LLVMClassInfo::getStaticType() {
if (!staticType) {
- Class* cl = (Class*)classDef;
+ UserClass* cl = (UserClass*)classDef;
std::vector<const llvm::Type*> fields;
JavaField** array = (JavaField**)
alloca(sizeof(JavaField*) * (classDef->staticFields.size() + 1));
@@ -446,7 +445,6 @@
cl->staticSize = size;
cl->staticVT = VT;
-#ifndef MULTIPLE_VM
JavaObject* val =
(JavaObject*)JavaThread::get()->isolate->allocator.allocateObject(cl->staticSize,
cl->staticVT);
@@ -458,7 +456,6 @@
}
cl->_staticInstance = val;
-#endif
}
return staticType;
}
@@ -467,7 +464,7 @@
#ifndef MULTIPLE_VM
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);
@@ -481,11 +478,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);
+ fprintf(stderr, "implement me\n");
+ abort();
#endif
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModule.h Tue Aug 26 04:30:54 2008
@@ -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)
{}
};
@@ -408,7 +404,7 @@
}
static LLVMCommonClassInfo* getClassInfo(CommonClass* cl) {
- if (cl->isArray || cl->isPrimitive) {
+ if (cl->isArray() || cl->isPrimitive()) {
return cl->getInfo<LLVMCommonClassInfo>();
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/JnjvmModuleProvider.cpp Tue Aug 26 04:30:54 2008
@@ -39,7 +39,7 @@
JavaMethod* meth = cl->lookupMethod(utf8, sign->keyName, isStatic, true);
if (!isVirtual(meth->access))
- JavaThread::get()->isolate->initialiseClass(cl);
+ cl->initialiseClass(JavaThread::get()->isolate);
meth->compiledPtr();
@@ -99,7 +99,7 @@
"The method's offset is greater than the virtual table size");
((void**)meth->classDef->virtualVT)[offset] = val;
} else {
- JavaThread::get()->isolate->initialiseClass(meth->classDef);
+ meth->classDef->initialiseClass(JavaThread::get()->isolate);
}
return false;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.cpp Tue Aug 26 04:30:54 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/branches/isolate/lib/JnJVM/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/LockedMap.h Tue Aug 26 04:30:54 2008
@@ -97,15 +97,17 @@
mvm::Lock* lock;
JavaAllocator* allocator;
+ ClassArray* 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, ClassArray* 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/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/LowerConstantCalls.cpp Tue Aug 26 04:30:54 2008
@@ -175,7 +175,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);
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Makefile
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Makefile?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Makefile (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Makefile Tue Aug 26 04:30:54 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/branches/isolate/lib/JnJVM/VMCore/NativeUtil.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.cpp Tue Aug 26 04:30:54 2008
@@ -226,11 +226,13 @@
return res;
}
-CommonClass* NativeUtil::resolvedImplClass(jclass clazz, bool doClinit) {
+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 =
+ (CommonClass*)vm->upcalls->vmdataClass->getObjectField(Cl);
cl->resolveClass();
- if (doClinit) JavaThread::get()->isolate->initialiseClass(cl);
+ if (doClinit) cl->initialiseClass(vm);
return cl;
}
@@ -258,12 +260,12 @@
if (funcs == AssessorDesc::dShort) {
if (value == AssessorDesc::dShort) {
- ((uint16*)buf)[0] = Classpath::shortValue->getVirtualInt16Field(obj);
+ ((uint16*)buf)[0] = vm->upcalls->shortValue->getInt16Field(obj);
buf++;
return;
} else if (value == AssessorDesc::dByte) {
((sint16*)buf)[0] =
- (sint16)Classpath::byteValue->getVirtualInt8Field(obj);
+ (sint16)vm->upcalls->byteValue->getInt8Field(obj);
buf++;
return;
} else {
@@ -271,7 +273,7 @@
}
} else if (funcs == AssessorDesc::dByte) {
if (value == AssessorDesc::dByte) {
- ((uint8*)buf)[0] = Classpath::byteValue->getVirtualInt8Field(obj);
+ ((uint8*)buf)[0] = vm->upcalls->byteValue->getInt8Field(obj);
buf++;
return;
} else {
@@ -279,7 +281,7 @@
}
} else if (funcs == AssessorDesc::dBool) {
if (value == AssessorDesc::dBool) {
- ((uint8*)buf)[0] = Classpath::boolValue->getVirtualInt8Field(obj);
+ ((uint8*)buf)[0] = vm->upcalls->boolValue->getInt8Field(obj);
buf++;
return;
} else {
@@ -288,13 +290,13 @@
} else if (funcs == AssessorDesc::dInt) {
sint32 val = 0;
if (value == AssessorDesc::dInt) {
- val = Classpath::intValue->getVirtualInt32Field(obj);
+ val = vm->upcalls->intValue->getInt32Field(obj);
} else if (value == AssessorDesc::dByte) {
- val = (sint32)Classpath::byteValue->getVirtualInt8Field(obj);
+ val = (sint32)vm->upcalls->byteValue->getInt8Field(obj);
} else if (value == AssessorDesc::dChar) {
- val = (uint32)Classpath::charValue->getVirtualInt16Field(obj);
+ val = (uint32)vm->upcalls->charValue->getInt16Field(obj);
} else if (value == AssessorDesc::dShort) {
- val = (sint32)Classpath::shortValue->getVirtualInt16Field(obj);
+ val = (sint32)vm->upcalls->shortValue->getInt16Field(obj);
} else {
vm->illegalArgumentException("");
}
@@ -304,7 +306,7 @@
} else if (funcs == AssessorDesc::dChar) {
uint16 val = 0;
if (value == AssessorDesc::dChar) {
- val = (uint16)Classpath::charValue->getVirtualInt16Field(obj);
+ val = (uint16)vm->upcalls->charValue->getInt16Field(obj);
} else {
vm->illegalArgumentException("");
}
@@ -314,17 +316,17 @@
} else if (funcs == AssessorDesc::dFloat) {
float val = 0;
if (value == AssessorDesc::dFloat) {
- val = (float)Classpath::floatValue->getVirtualFloatField(obj);
+ val = (float)vm->upcalls->floatValue->getFloatField(obj);
} else if (value == AssessorDesc::dByte) {
- val = (float)(sint32)Classpath::byteValue->getVirtualInt8Field(obj);
+ val = (float)(sint32)vm->upcalls->byteValue->getInt8Field(obj);
} else if (value == AssessorDesc::dChar) {
- val = (float)(uint32)Classpath::charValue->getVirtualInt16Field(obj);
+ val = (float)(uint32)vm->upcalls->charValue->getInt16Field(obj);
} else if (value == AssessorDesc::dShort) {
- val = (float)(sint32)Classpath::shortValue->getVirtualInt16Field(obj);
+ val = (float)(sint32)vm->upcalls->shortValue->getInt16Field(obj);
} else if (value == AssessorDesc::dInt) {
- val = (float)(sint32)Classpath::intValue->getVirtualInt32Field(obj);
+ val = (float)(sint32)vm->upcalls->intValue->getInt32Field(obj);
} else if (value == AssessorDesc::dLong) {
- val = (float)Classpath::longValue->getVirtualLongField(obj);
+ val = (float)vm->upcalls->longValue->getLongField(obj);
} else {
vm->illegalArgumentException("");
}
@@ -334,19 +336,19 @@
} else if (funcs == AssessorDesc::dDouble) {
double val = 0;
if (value == AssessorDesc::dDouble) {
- val = (double)Classpath::doubleValue->getVirtualDoubleField(obj);
+ val = (double)vm->upcalls->doubleValue->getDoubleField(obj);
} else if (value == AssessorDesc::dFloat) {
- val = (double)Classpath::floatValue->getVirtualFloatField(obj);
+ val = (double)vm->upcalls->floatValue->getFloatField(obj);
} else if (value == AssessorDesc::dByte) {
- val = (double)(sint64)Classpath::byteValue->getVirtualInt8Field(obj);
+ val = (double)(sint64)vm->upcalls->byteValue->getInt8Field(obj);
} else if (value == AssessorDesc::dChar) {
- val = (double)(uint64)Classpath::charValue->getVirtualInt16Field(obj);
+ val = (double)(uint64)vm->upcalls->charValue->getInt16Field(obj);
} else if (value == AssessorDesc::dShort) {
- val = (double)(sint16)Classpath::shortValue->getVirtualInt16Field(obj);
+ val = (double)(sint16)vm->upcalls->shortValue->getInt16Field(obj);
} else if (value == AssessorDesc::dInt) {
- val = (double)(sint32)Classpath::intValue->getVirtualInt32Field(obj);
+ val = (double)(sint32)vm->upcalls->intValue->getInt32Field(obj);
} else if (value == AssessorDesc::dLong) {
- val = (double)(sint64)Classpath::longValue->getVirtualLongField(obj);
+ val = (double)(sint64)vm->upcalls->longValue->getLongField(obj);
} else {
vm->illegalArgumentException("");
}
@@ -356,15 +358,15 @@
} else if (funcs == AssessorDesc::dLong) {
sint64 val = 0;
if (value == AssessorDesc::dByte) {
- val = (sint64)Classpath::byteValue->getVirtualInt8Field(obj);
+ val = (sint64)vm->upcalls->byteValue->getInt8Field(obj);
} else if (value == AssessorDesc::dChar) {
- val = (sint64)(uint64)Classpath::charValue->getVirtualInt16Field(obj);
+ val = (sint64)(uint64)vm->upcalls->charValue->getInt16Field(obj);
} else if (value == AssessorDesc::dShort) {
- val = (sint64)Classpath::shortValue->getVirtualInt16Field(obj);
+ val = (sint64)vm->upcalls->shortValue->getInt16Field(obj);
} else if (value == AssessorDesc::dInt) {
- val = (sint64)Classpath::intValue->getVirtualInt32Field(obj);
+ val = (sint64)vm->upcalls->intValue->getInt32Field(obj);
} else if (value == AssessorDesc::dLong) {
- val = (sint64)Classpath::intValue->getVirtualLongField(obj);
+ val = (sint64)vm->upcalls->intValue->getLongField(obj);
} else {
vm->illegalArgumentException("");
}
@@ -378,13 +380,15 @@
}
JavaObject* NativeUtil::getClassType(JnjvmClassLoader* loader, Typedef* type) {
+ Jnjvm* vm = JavaThread::get()->isolate;
CommonClass* res = type->assocClass(loader);
- return res->getClassDelegatee();
+ 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;
@@ -399,22 +403,23 @@
ArrayObject* NativeUtil::getExceptionTypes(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();
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);
cl->resolveClass();
- JavaObject* obj = cl->getClassDelegatee();
+ JavaObject* obj = cl->getClassDelegatee(vm);
res->elements[i] = obj;
}
return res;
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.h?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.h (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/NativeUtil.h Tue Aug 26 04:30:54 2008
@@ -29,7 +29,7 @@
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);
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/Reader.cpp Tue Aug 26 04:30:54 2008
@@ -15,6 +15,7 @@
#include "Jnjvm.h"
#include "JavaArray.h"
#include "JavaThread.h"
+#include "JavaUpcalls.h"
#include "Reader.h"
#include "Zip.h"
@@ -31,18 +32,21 @@
fseek(fp, 0, SeekEnd);
long nbb = ftell(fp);
fseek(fp, 0, SeekSet);
- res = ArrayUInt8::acons(nbb, JavaArray::ofByte, loader->allocator);
+ ClassArray* array = loader->bootstrapLoader->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(JnjvmClassLoader* 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);
+ ClassArray* array = loader->bootstrapLoader->upcalls->ArrayOfByte;
+ ArrayUInt8* res = ArrayUInt8::acons(file->ucsize, array, loader->allocator);
if (archive->readFile(res, file) != 0) {
ret = res;
}
Modified: vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp?rev=55368&r1=55367&r2=55368&view=diff
==============================================================================
--- vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp (original)
+++ vmkit/branches/isolate/lib/JnJVM/VMCore/VirtualTables.cpp Tue Aug 26 04:30:54 2008
@@ -33,8 +33,6 @@
INIT(JavaThread);
INIT(Jnjvm);
INIT(ClassMap);
- INIT(StaticInstanceMap);
- INIT(DelegateeMap);
INIT(JnjvmBootstrapLoader);
INIT(JnjvmClassLoader);
#ifdef MULTIPLE_VM
@@ -116,18 +114,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;
More information about the vmkit-commits
mailing list