[vmkit-commits] [vmkit] r180294 - Port to GNU Classpath 0.99
Peter Senna Tschudin
peter.senna at gmail.com
Thu Apr 25 09:51:19 PDT 2013
Author: peter.senna
Date: Thu Apr 25 11:49:46 2013
New Revision: 180294
URL: http://llvm.org/viewvc/llvm-project?rev=180294&view=rev
Log:
Port to GNU Classpath 0.99
(cherry picked from commit ceed20f214aa31de4c47ef685ee68c3f066031c3)
Modified:
vmkit/trunk/lib/j3/ClassLib/ClasspathConstructor.inc
vmkit/trunk/lib/j3/ClassLib/ClasspathField.inc
vmkit/trunk/lib/j3/ClassLib/ClasspathMethod.inc
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.cpp
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.h
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h
vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
vmkit/trunk/tests/ThreadTest.java
Modified: vmkit/trunk/lib/j3/ClassLib/ClasspathConstructor.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ClasspathConstructor.inc?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ClasspathConstructor.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ClasspathConstructor.inc Thu Apr 25 11:49:46 2013
@@ -25,75 +25,109 @@ using namespace j3;
extern "C" {
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getParameterTypes(
+bool getClassAndMethodPointerByVMConstructor(JavaObject* vmCons, UserCommonClass** cls, JavaMethod** m)
+ __attribute__ ((noinline));
+
+bool getClassAndMethodPointerByVMConstructor(JavaObject* vmCons, UserCommonClass** cls, JavaMethod** m) {
+ JavaObject* res = 0;
+ JavaField* field = 0;
+ JavaField* fieldSlot = 0;
+ UserCommonClass* cl = 0;
+ // Local object references
+ llvm_gcroot(vmCons, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
+ cl = JavaObject::getClass(vmCons);
+ if (cl->isClass()) {
+ const UTF8* name = cl->classLoader->hashUTF8->lookupAsciiz("clazz");
+ const UTF8* type = cl->classLoader->hashUTF8->lookupAsciiz("Ljava/lang/Class;");
+ const UTF8* nameSlot = cl->classLoader->hashUTF8->lookupAsciiz("slot");
+ const UTF8* typeSlot = cl->classLoader->hashUTF8->lookupAsciiz("I");
+ if (name && nameSlot && type && typeSlot) {
+ field = cl->asClass()->lookupField(name, type, false, true,0);
+ fieldSlot = cl->asClass()->lookupField(nameSlot, typeSlot, false, true,0);
+ res = field->getInstanceObjectField(vmCons);
+ int slot = fieldSlot->getInstanceInt32Field(vmCons);
+ *cls = JavaObjectClass::getClass((JavaObjectClass*)res);
+ *m = &((*cls)->asClass()->virtualMethods[slot]);
+ return true;
+ }
+ }
+ END_NATIVE_EXCEPTION
+ return false;
+}
+
+JNIEXPORT jobject JNICALL Java_java_lang_reflect_VMConstructor_getParameterTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* cons) {
+JavaObject* cons) {
- JavaObject* res = 0;
+ JavaObject* res = 0;
+ UserCommonClass* cls = 0;
+ JavaMethod* method = 0;
+ // Local object references
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(res, 0);
- llvm_gcroot(cons, 0);
- llvm_gcroot(res, 0);
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
- BEGIN_NATIVE_EXCEPTION(0)
-
- verifyNull(cons);
- UserClass* cl = JavaObjectConstructor::getClass(cons);
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
- JnjvmClassLoader* loader = cl->classLoader;
+ if (getClassAndMethodPointerByVMConstructor(cons, &cls,&method)) {
+ res = method->getParameterTypes(cls->classLoader);
+ } // FIXME (INTI) : Throw an exception here
- res = meth->getParameterTypes(loader);
- END_NATIVE_EXCEPTION
+ END_NATIVE_EXCEPTION
- return (jobject)res;
+ return (jobject)res;
}
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal(
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMConstructor_getModifiersInternal(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* cons) {
+JavaObject* cons) {
- llvm_gcroot(cons, 0);
- jint res = 0;
+ jint res = 0;
- BEGIN_NATIVE_EXCEPTION(0)
+ UserCommonClass* cls = 0;
+ JavaMethod* method = 0;
+ // Local object references
+ llvm_gcroot(cons, 0);
- verifyNull(cons);
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
- res = meth->access;
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
- END_NATIVE_EXCEPTION
+ if (getClassAndMethodPointerByVMConstructor(cons, &cls,&method)) {
+ res = method->access;
+ } // FIXME (INTI) : Throw an exception here
- return res;
+ END_NATIVE_EXCEPTION
+
+ return res;
}
-JavaObject* proceedConstructor(JavaObjectConstructor* cons,
- ArrayObject* args,
- JavaObject* Clazz, jint index)
+JavaObject* proceedRealConstructor(ArrayObject* args,
+ UserCommonClass* clazz, JavaMethod* method)
__attribute__ ((noinline));
-JavaObject* proceedConstructor(JavaObjectConstructor* cons,
- ArrayObject* args,
- JavaObject* Clazz, jint index) {
+JavaObject* proceedRealConstructor(ArrayObject* args,
+ UserCommonClass* clazz, JavaMethod* method) {
JavaObject* res = 0;
JavaObject* excp = 0;
- llvm_gcroot(cons, 0);
llvm_gcroot(args, 0);
- llvm_gcroot(Clazz, 0);
llvm_gcroot(res, 0);
llvm_gcroot(excp, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
- UserClass* cl = JavaObjectConstructor::getClass(cons);
sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
- Signdef* sign = meth->getSignature();
+ Signdef* sign = method->getSignature();
sint32 size = sign->nbArguments;
- if (isAbstract(cl->access)) vm->instantiationException(cl);
+ if (isAbstract(clazz->access)) vm->instantiationException(clazz);
vmkit::ThreadAllocator allocator;
// Allocate a buffer to store the arguments.
@@ -101,8 +135,7 @@ JavaObject* proceedConstructor(JavaObjec
(jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
if (nbArgs == size) {
- UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Clazz, false);
- UserClass* cl = _cl->asClass();
+ UserClass* cl = clazz->asClass();
if (cl) {
cl->initialiseClass(vm);
res = cl->doNew(vm);
@@ -119,7 +152,7 @@ JavaObject* proceedConstructor(JavaObjec
JavaThread* th = JavaThread::get();
TRY {
- meth->invokeIntSpecialBuf(vm, cl, res, buf);
+ method->invokeIntSpecialBuf(vm, cl, res, buf);
} CATCH {
excp = th->getJavaException();
} END_CATCH;
@@ -147,73 +180,76 @@ JavaObject* proceedConstructor(JavaObjec
return res;
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Constructor_constructNative(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMConstructor_construct(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* cons, ArrayObject* args, JavaObject* Clazz, jint index) {
+JavaObject* cons, ArrayObject* args) {
JavaObject* res = 0;
+ JavaMethod* m = 0;
+ UserCommonClass* cls = 0;
llvm_gcroot(res, 0);
llvm_gcroot(cons, 0);
llvm_gcroot(args, 0);
- llvm_gcroot(Clazz, 0);
BEGIN_NATIVE_EXCEPTION(0)
-
- res = proceedConstructor(cons, args, Clazz, index);
-
+ if (getClassAndMethodPointerByVMConstructor(cons,&cls, &m)){
+ res = proceedRealConstructor(args, cls, m);
+ } // FIXME (INTI) : Throw an exception here
END_NATIVE_EXCEPTION
-
return res;
}
JNIEXPORT
-ArrayObject* JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(
+ArrayObject* JNICALL Java_java_lang_reflect_VMConstructor_getExceptionTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* cons) {
+JavaObject* cons) {
ArrayObject* res = 0;
-
+ JavaMethod* m = 0;
+ UserCommonClass* cls = 0;
llvm_gcroot(res, 0);
llvm_gcroot(cons, 0);
BEGIN_NATIVE_EXCEPTION(0)
- verifyNull(cons);
- UserClass* cl = JavaObjectConstructor::getClass(cons);
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
- JnjvmClassLoader* loader = cl->classLoader;
-
- res = (ArrayObject*)meth->getExceptionTypes(loader);
+ verifyNull(cons);
+ if (getClassAndMethodPointerByVMConstructor(cons, &cls, & m)) {
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = (ArrayObject*)m->getExceptionTypes(loader);
+ } // FIXME (INTI) : Throw an exception here
END_NATIVE_EXCEPTION
+
return res;
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Constructor_getSignature(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMConstructor_getSignature(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectConstructor* Meth) {
+JavaObject* Meth) {
JavaObject* result = 0;
-
+ JavaMethod* m = 0;
+ UserCommonClass* cls = 0;
llvm_gcroot(result, 0);
llvm_gcroot(Meth, 0);
BEGIN_NATIVE_EXCEPTION(0)
- verifyNull(Meth);
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(Meth);
- Jnjvm* vm = JavaThread::get()->getJVM();
- result = vm->internalUTF8ToStr(meth->type);
+ verifyNull(Meth);
+ if (getClassAndMethodPointerByVMConstructor(Meth, &cls, & m)) {
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ result = vm->internalUTF8ToStr(m->type);
+ } // FIXME (INTI) : Throw an exception here
- END_NATIVE_EXCEPTION
+ END_NATIVE_EXCEPTION
return result;
}
Modified: vmkit/trunk/lib/j3/ClassLib/ClasspathField.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ClasspathField.inc?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ClasspathField.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ClasspathField.inc Thu Apr 25 11:49:46 2013
@@ -19,31 +19,68 @@ using namespace j3;
extern "C" {
+bool getClassAndFieldPointerByVMField(JavaObject* vmField, UserCommonClass** cls, JavaField** m)
+ __attribute__ ((noinline));
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal(
+bool getClassAndFieldPointerByVMField(JavaObject* vmField, UserCommonClass** cls, JavaField** m) {
+ JavaObject* res = 0;
+ JavaField* field = 0;
+ JavaField* fieldSlot = 0;
+ UserCommonClass* cl = 0;
+ // Local object references
+ llvm_gcroot(vmField, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
+ cl = JavaObject::getClass(vmField);
+ if (cl->isClass()) {
+ const UTF8* name = cl->classLoader->hashUTF8->lookupAsciiz("clazz");
+ const UTF8* type = cl->classLoader->hashUTF8->lookupAsciiz("Ljava/lang/Class;");
+ const UTF8* nameSlot = cl->classLoader->hashUTF8->lookupAsciiz("slot");
+ const UTF8* typeSlot = cl->classLoader->hashUTF8->lookupAsciiz("I");
+ if (name && nameSlot && type && typeSlot) {
+ field = cl->asClass()->lookupField(name, type, false, true,0);
+ fieldSlot = cl->asClass()->lookupField(nameSlot, typeSlot, false, true,0);
+ res = field->getInstanceObjectField(vmField);
+ int slot = fieldSlot->getInstanceInt32Field(vmField);
+ *cls = JavaObjectClass::getClass((JavaObjectClass*)res);
+ *m = &((*cls)->asClass()->virtualFields[slot]);
+ return true;
+ }
+ }
+ END_NATIVE_EXCEPTION
+ return false;
+}
+
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getModifiersInternal(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field) {
+JavaObject* Field) {
jint res = 0;
llvm_gcroot(Field, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaField* field = JavaObjectField::getInternalField(Field);
- res = field->access;
+ UserCommonClass* cls = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (getClassAndFieldPointerByVMField(Field, &cls, &field)) {
+ res = field->access;
+ } // FIXME : throw an exception in other case
+
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_getType(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_getType(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field) {
+JavaObject* Field) {
JavaObject* res = 0;
@@ -53,22 +90,25 @@ JavaObjectField* Field) {
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
- JnjvmClassLoader* loader = cl->classLoader;
- UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);
- res = fieldCl->getClassDelegatee(vm);
+
+ UserCommonClass* cls = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (getClassAndFieldPointerByVMField(Field, &cls, &field)) {
+ JnjvmClassLoader* loader = cls->classLoader;
+ UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);
+ res = fieldCl->getClassDelegatee(vm);
+ } // FIXME : throw an exception in other case
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getInt(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jint res = 0;
@@ -78,13 +118,18 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
const Typedef* type = field->getSignature();
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -129,11 +174,11 @@ JavaObjectField* Field, JavaObject* obj)
}
-JNIEXPORT jlong JNICALL Java_java_lang_reflect_Field_getLong(
+JNIEXPORT jlong JNICALL Java_java_lang_reflect_VMField_getLong(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jlong res = 0;
@@ -143,12 +188,18 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -199,11 +250,11 @@ JavaObjectField* Field, JavaObject* obj)
return res;
}
-JNIEXPORT jboolean JNICALL Java_java_lang_reflect_Field_getBoolean(
+JNIEXPORT jboolean JNICALL Java_java_lang_reflect_VMField_getBoolean(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jboolean res = 0;
@@ -213,12 +264,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -245,11 +303,11 @@ JavaObjectField* Field, JavaObject* obj)
}
-JNIEXPORT jfloat JNICALL Java_java_lang_reflect_Field_getFloat(
+JNIEXPORT jfloat JNICALL Java_java_lang_reflect_VMField_getFloat(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jfloat res = 0;
llvm_gcroot(Field, 0);
@@ -258,12 +316,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -320,11 +385,11 @@ JavaObjectField* Field, JavaObject* obj)
return res;
}
-JNIEXPORT jbyte JNICALL Java_java_lang_reflect_Field_getByte(
+JNIEXPORT jbyte JNICALL Java_java_lang_reflect_VMField_getByte(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jbyte res = 0;
llvm_gcroot(Field, 0);
@@ -333,12 +398,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -364,11 +436,11 @@ JavaObjectField* Field, JavaObject* obj)
return res;
}
-JNIEXPORT jchar JNICALL Java_java_lang_reflect_Field_getChar(
+JNIEXPORT jchar JNICALL Java_java_lang_reflect_VMField_getChar(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jchar res = 0;
llvm_gcroot(Field, 0);
@@ -377,12 +449,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -409,11 +488,11 @@ JavaObjectField* Field, JavaObject* obj)
}
-JNIEXPORT jshort JNICALL Java_java_lang_reflect_Field_getShort(
+JNIEXPORT jshort JNICALL Java_java_lang_reflect_VMField_getShort(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jshort res = 0;
@@ -423,12 +502,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -460,11 +546,11 @@ JavaObjectField* Field, JavaObject* obj)
return res;
}
-JNIEXPORT jdouble JNICALL Java_java_lang_reflect_Field_getDouble(
+JNIEXPORT jdouble JNICALL Java_java_lang_reflect_VMField_getDouble(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
jdouble res = 0;
llvm_gcroot(Field, 0);
@@ -473,12 +559,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -540,11 +633,11 @@ JavaObjectField* Field, JavaObject* obj)
return res;
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_get(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_get(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj) {
+JavaObject* Field, JavaObject* obj) {
JavaObject* res = 0;
@@ -555,12 +648,19 @@ JavaObjectField* Field, JavaObject* obj)
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -622,11 +722,11 @@ JavaObjectField* Field, JavaObject* obj)
return res;
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_set(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_set(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
+JavaObject* Field, JavaObject* obj, JavaObject* val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -635,14 +735,21 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
jvalue buf;
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -713,11 +820,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setBoolean(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jboolean val) {
+JavaObject* Field, JavaObject* obj, jboolean val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -725,12 +832,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -755,11 +869,11 @@ JavaObjectField* Field, JavaObject* obj,
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setByte(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setByte(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jbyte val) {
+JavaObject* Field, JavaObject* obj, jbyte val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -767,12 +881,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -826,11 +947,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setChar(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jchar val) {
+JavaObject* Field, JavaObject* obj, jchar val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -838,12 +959,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -890,11 +1018,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setShort(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jshort val) {
+JavaObject* Field, JavaObject* obj, jshort val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -902,12 +1030,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -954,11 +1089,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setInt(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jint val) {
+JavaObject* Field, JavaObject* obj, jint val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -966,12 +1101,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -1013,11 +1155,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setLong(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jlong val) {
+JavaObject* Field, JavaObject* obj, jlong val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -1025,12 +1167,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -1066,11 +1215,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setFloat(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jfloat val) {
+JavaObject* Field, JavaObject* obj, jfloat val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -1078,12 +1227,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
@@ -1113,11 +1269,11 @@ JavaObjectField* Field, JavaObject* obj,
END_NATIVE_EXCEPTION
}
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble(
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setDouble(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectField* Field, JavaObject* obj, jdouble val) {
+JavaObject* Field, JavaObject* obj, jdouble val) {
llvm_gcroot(Field, 0);
llvm_gcroot(obj, 0);
@@ -1125,12 +1281,19 @@ JavaObjectField* Field, JavaObject* obj,
BEGIN_NATIVE_EXCEPTION(0)
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = JavaObjectField::getClass(Field);
- JavaField* field = JavaObjectField::getInternalField(Field);
+ //UserClass* cl = JavaObjectField::getClass(Field);
+ //JavaField* field = JavaObjectField::getInternalField(Field);
+
+ UserCommonClass* cl = 0;
+ JavaField* field = 0;//JavaObjectField::getInternalField(Field);
+ if (!getClassAndFieldPointerByVMField(Field, &cl, &field)) {
+ // FIXME : throw an exception in other case
+ }
+
bool stat = isStatic(field->access);
if (stat) {
- cl->initialiseClass(vm);
+ cl->asClass()->initialiseClass(vm);
} else {
verifyNull(obj);
}
Modified: vmkit/trunk/lib/j3/ClassLib/ClasspathMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/ClasspathMethod.inc?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/ClasspathMethod.inc (original)
+++ vmkit/trunk/lib/j3/ClassLib/ClasspathMethod.inc Thu Apr 25 11:49:46 2013
@@ -25,30 +25,69 @@ using namespace j3;
extern "C" {
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Method_getModifiersInternal(
+bool getClassAndMethodPointerFromVMMethod(JavaObject* vmMethod, UserCommonClass** cls, JavaMethod** m)
+ __attribute__ ((noinline));
+
+bool getClassAndMethodPointerFromVMMethod(JavaObject* vmMethod, UserCommonClass** cls, JavaMethod** m) {
+ JavaObject* res = 0;
+ JavaField* field = 0;
+ JavaField* fieldSlot = 0;
+ UserCommonClass* cl = 0;
+ // Local object references
+ llvm_gcroot(vmMethod, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
+ cl = JavaObject::getClass(vmMethod);
+ if (cl->isClass()) {
+ const UTF8* name = cl->classLoader->hashUTF8->lookupAsciiz("clazz");
+ const UTF8* type = cl->classLoader->hashUTF8->lookupAsciiz("Ljava/lang/Class;");
+ const UTF8* nameSlot = cl->classLoader->hashUTF8->lookupAsciiz("slot");
+ const UTF8* typeSlot = cl->classLoader->hashUTF8->lookupAsciiz("I");
+ if (name && nameSlot && type && typeSlot) {
+ field = cl->asClass()->lookupField(name, type, false, true,0);
+ fieldSlot = cl->asClass()->lookupField(nameSlot, typeSlot, false, true,0);
+ res = field->getInstanceObjectField(vmMethod);
+ int slot = fieldSlot->getInstanceInt32Field(vmMethod);
+ *cls = JavaObjectClass::getClass((JavaObjectClass*)res);
+ if (!*cls) return false;
+ *m = &((*cls)->asClass()->virtualMethods[slot]);
+ if (!*m) return false;
+ return true;
+ }
+ }
+ END_NATIVE_EXCEPTION
+ return false;
+}
+
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMMethod_getModifiersInternal(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth) {
+JavaObject* Meth) {
jint res = 0;
llvm_gcroot(Meth, 0);
BEGIN_NATIVE_EXCEPTION(0)
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
- res = meth->access;
+ JavaMethod* meth = 0;//JavaObjectMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = 0;
+ if (getClassAndMethodPointerFromVMMethod(Meth, &cls, &meth)) {
+ res = meth->access;
+ } // FIXME : throw an exception in other case
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getReturnType(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getReturnType(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth) {
+JavaObject* Meth) {
JavaObject* res = 0;
llvm_gcroot(Meth, 0);
@@ -56,10 +95,15 @@ JavaObjectMethod* Meth) {
BEGIN_NATIVE_EXCEPTION(0)
- UserClass* cl = JavaObjectMethod::getClass(Meth);
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
- JnjvmClassLoader* loader = cl->classLoader;
- res = meth->getReturnType(loader);
+ //UserClass* cl = JavaObjectMethod::getClass(Meth);
+ //JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
+
+ JavaMethod* meth = 0;//JavaObjectMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = 0;
+ if (getClassAndMethodPointerFromVMMethod(Meth, &cls, &meth)) {
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = meth->getReturnType(loader);
+ } // FIXME : throw an exception in other case
END_NATIVE_EXCEPTION
@@ -67,11 +111,11 @@ JavaObjectMethod* Meth) {
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getParameterTypes(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getParameterTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth) {
+JavaObject* Meth) {
JavaObject* res = 0;
llvm_gcroot(Meth, 0);
@@ -79,23 +123,30 @@ JavaObjectMethod* Meth) {
BEGIN_NATIVE_EXCEPTION(0)
- UserClass* cl = JavaObjectMethod::getClass(Meth);
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
- JnjvmClassLoader* loader = cl->classLoader;
+ //UserClass* cl = JavaObjectMethod::getClass(Meth);
+ //JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
+
+ JavaMethod* meth = 0;//JavaObjectMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = 0;
+ if (getClassAndMethodPointerFromVMMethod(Meth, &cls, &meth)) {
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = meth->getParameterTypes(loader);
+ } // FIXME : throw an exception in other case
+
- res = meth->getParameterTypes(loader);
END_NATIVE_EXCEPTION
return res;
}
-JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
- ArrayObject* args, JavaObject* Cl, jint index)
+
+JavaObject* proceedVMMethod(JavaObject* Meth, JavaObject* obj,
+ ArrayObject* args)
__attribute__((noinline));
-JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
- ArrayObject* args, JavaObject* Cl, jint index) {
+JavaObject* proceedVMMethod(JavaObject* Meth, JavaObject* obj,
+ ArrayObject* args) {
JavaObject* res = 0;
JavaObject* exc = 0;
@@ -104,12 +155,15 @@ JavaObject* proceedMethod(JavaObjectMeth
llvm_gcroot(Meth, 0);
llvm_gcroot(obj, 0);
llvm_gcroot(args, 0);
- llvm_gcroot(Cl, 0);
llvm_gcroot(exc, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* _cl = 0;//UserCommonClass::resolvedImplClass(vm, Cl, false);
+ JavaMethod* meth = 0;//JavaObjectMethod::getInternalMethod(Meth);
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
+ if (!getClassAndMethodPointerFromVMMethod(Meth, &_cl, &meth)) {
+ // FIXME : throw an exception
+ }
sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
Signdef* sign = meth->getSignature();
@@ -120,7 +174,7 @@ JavaObject* proceedMethod(JavaObjectMeth
(jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
if (nbArgs == size) {
- UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ //UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
UserClass* cl = (UserClass*)_cl;
if (isVirtual(meth->access)) {
@@ -234,33 +288,32 @@ JavaObject* proceedMethod(JavaObjectMeth
#undef RUN_METH
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_invokeNative(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_invoke(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth, JavaObject* obj, ArrayObject* args, JavaObject* Cl, jint index) {
+JavaObject* Meth, JavaObject* obj, ArrayObject* args) {
JavaObject* res = 0;
llvm_gcroot(res, 0);
llvm_gcroot(Meth, 0);
llvm_gcroot(obj, 0);
llvm_gcroot(args, 0);
- llvm_gcroot(Cl, 0);
BEGIN_NATIVE_EXCEPTION(0)
- res = proceedMethod(Meth, obj, args, Cl, index);
+ res = proceedVMMethod(Meth, obj, args);
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT ArrayObject* JNICALL Java_java_lang_reflect_Method_getExceptionTypes(
+JNIEXPORT ArrayObject* JNICALL Java_java_lang_reflect_VMMethod_getExceptionTypes(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth) {
+JavaObject* Meth) {
ArrayObject* res = 0;
llvm_gcroot(Meth, 0);
@@ -269,21 +322,28 @@ JavaObjectMethod* Meth) {
BEGIN_NATIVE_EXCEPTION(0)
verifyNull(Meth);
- UserClass* cl = JavaObjectMethod::getClass(Meth);
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
- JnjvmClassLoader* loader = cl->classLoader;
- res = meth->getExceptionTypes(loader);
+ //UserClass* cl = JavaObjectMethod::getClass(Meth);
+ //JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
+
+ JavaMethod* meth = 0;//JavaObjectMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = 0;
+ if (getClassAndMethodPointerFromVMMethod(Meth, &cls, &meth)) {
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = meth->getExceptionTypes(loader);
+ } // FIXME : throw an exception in other case
+
+
END_NATIVE_EXCEPTION
return res;
}
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getSignature(
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getSignature(
#ifdef NATIVE_JNI
JNIEnv *env,
#endif
-JavaObjectMethod* Meth) {
+JavaObject* Meth) {
JavaObject* result = 0;
llvm_gcroot(Meth, 0);
@@ -292,9 +352,16 @@ JavaObjectMethod* Meth) {
BEGIN_NATIVE_EXCEPTION(0)
verifyNull(Meth);
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
- Jnjvm* vm = JavaThread::get()->getJVM();
- result = vm->internalUTF8ToStr(meth->type);
+ //JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
+
+ JavaMethod* meth = 0;//JavaObjectMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = 0;
+ if (getClassAndMethodPointerFromVMMethod(Meth, &cls, &meth)) {
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ result = vm->internalUTF8ToStr(meth->type);
+ } // FIXME : throw an exception in other case
+
+
END_NATIVE_EXCEPTION
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.cpp?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.cpp Thu Apr 25 11:49:46 2013
@@ -16,64 +16,97 @@
namespace j3 {
-JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor* self) {
+
+JavaMethod* JavaObjectVMConstructor::getInternalMethod(JavaObjectVMConstructor* self) {
llvm_gcroot(self, 0);
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
return &(cls->asClass()->virtualMethods[self->slot]);
}
+JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor* self) {
+ llvm_gcroot(self, 0);
+ return JavaObjectVMConstructor::getInternalMethod(self->vmCons);
+}
-JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
+
+JavaMethod* JavaObjectVMMethod::getInternalMethod(JavaObjectVMMethod* self) {
llvm_gcroot(self, 0);
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
return &(cls->asClass()->virtualMethods[self->slot]);
}
+JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
+ llvm_gcroot(self, 0);
+ return JavaObjectVMMethod::getInternalMethod(self->vmMethod);
+}
+
JavaObjectConstructor* JavaObjectConstructor::createFromInternalConstructor(JavaMethod * cons, int i) {
JavaObjectConstructor* ret = 0;
+ JavaObject* vmConsInstance = 0;
+ UserClass* VMConsClass = 0;
+ UserClass* ConstructorClass = 0;
llvm_gcroot(ret, 0);
-
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(vmConsInstance, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* Cons = vm->upcalls->newConstructor;
- ret = (JavaObjectConstructor*)Cons->doNew(vm);
+ VMConsClass = vm->upcalls->newVMConstructor;
+ vmConsInstance = VMConsClass->doNew(vm);
JavaObject* const* Cl = cons->classDef->getDelegateePtr();
- vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
- Cl, i);
-
+ vm->upcalls->initVMConstructor->invokeIntSpecial(vm, VMConsClass, vmConsInstance, Cl, i);
+ ConstructorClass = vm->upcalls->newConstructor;
+ ret = (JavaObjectConstructor*)ConstructorClass->doNew(vm);
+ vm->upcalls->initConstructor->invokeIntSpecial(vm, ConstructorClass, ret, &vmConsInstance);
return ret;
}
JavaObjectMethod* JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
JavaObjectMethod* ret = 0;
+ JavaObjectVMMethod* vmMeth = 0;
JavaString* str = 0;
llvm_gcroot(ret, 0);
llvm_gcroot(str, 0);
+ llvm_gcroot(vmMeth, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* Meth = vm->upcalls->newMethod;
- ret = (JavaObjectMethod*)Meth->doNew(vm);
+
+ UserClass* VMMeth = vm->upcalls->newVMMethod;
+ vmMeth = (JavaObjectVMMethod*)VMMeth->doNew(vm);
+
+
str = vm->internalUTF8ToStr(meth->name);
JavaObject* const* Cl = meth->classDef->getDelegateePtr();
- vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
- Cl, &str, i);
+ vm->upcalls->initVMMethod->invokeIntSpecial(vm, VMMeth, vmMeth, Cl, &str, i);
+
+ //vmMeth->name = str;
+ //vmMeth->declaringClass = (JavaObject*)Cl; // I don't like this
+ //vmMeth->slot = i;
+
+ UserClass* Meth = vm->upcalls->newMethod;
+ ret = (JavaObjectMethod*)Meth->doNew(vm);
+
+ vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,&vmMeth);
return ret;
}
JavaObjectField* JavaObjectField::createFromInternalField(JavaField* field, int i) {
JavaObjectField* ret = 0;
JavaString* name = 0;
+ JavaObject* vmField = 0;
+
llvm_gcroot(ret, 0);
llvm_gcroot(name, 0);
+ llvm_gcroot(vmField, 0);
Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* Field = vm->upcalls->newField;
- ret = (JavaObjectField*)Field->doNew(vm);
+ UserClass* VMFieldClass = vm->upcalls->newVMField;
+ vmField = VMFieldClass->doNew(vm);
name = vm->internalUTF8ToStr(field->name);
JavaObject* const* Cl = field->classDef->getDelegateePtr();
- vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
- Cl, &name, i);
-
+ vm->upcalls->initVMField->invokeIntSpecial(vm, VMFieldClass, vmField,Cl,&name, i);
+ UserClass* FieldClass = vm->upcalls->newField;
+ ret = (JavaObjectField*)FieldClass->doNew(vm);
+ vm->upcalls->initField->invokeIntSpecial(vm, FieldClass, ret, &vmField);
return ret;
}
}
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.h?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathReflect.h Thu Apr 25 11:49:46 2013
@@ -71,77 +71,137 @@ public:
static int getModifiers(JavaObjectClass* Cl);
};
+class JavaObjectVMField : public JavaObject {
+private:
+ JavaObjectClass* declaringClass;
+ JavaObject* name;
+ uint32 slot;
+ // others
+public:
+ static void staticTracer(JavaObjectVMField* obj, word_t closure) {
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ }
+
+ static JavaField* getInternalField(JavaObjectVMField* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return &(cls->asClass()->virtualFields[self->slot]);
+ }
+
+ static UserClass* getClass(JavaObjectVMField* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return cls->asClass();
+ }
+};
+
class JavaObjectField : public JavaObject {
private:
uint8 flag;
- JavaObjectClass* declaringClass;
- JavaObject* name;
- uint32 slot;
+ JavaObject* p;
+ JavaObjectVMField* vmField;
public:
static void staticTracer(JavaObjectField* obj, word_t closure) {
- vmkit::Collector::markAndTrace(obj, &obj->name, closure);
- vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->p, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->vmField, closure);
}
static JavaField* getInternalField(JavaObjectField* self) {
llvm_gcroot(self, 0);
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
- return &(cls->asClass()->virtualFields[self->slot]);
+ return JavaObjectVMField::getInternalField(self->vmField);
}
static UserClass* getClass(JavaObjectField* self) {
llvm_gcroot(self, 0);
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
- return cls->asClass();
+ return JavaObjectVMField::getClass(self->vmField);
}
static JavaObjectField* createFromInternalField(JavaField* field, int i);
};
+class JavaObjectVMMethod : public JavaObject {
+private:
+ JavaObjectClass* declaringClass;
+ JavaString* name;
+ uint32 slot;
+public:
+ static void staticTracer(JavaObjectVMMethod* obj, word_t closure) {
+ vmkit::Collector::markAndTrace(obj, &obj->name, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ }
+
+ static JavaMethod* getInternalMethod(JavaObjectVMMethod* self);
+
+ static UserClass* getClass(JavaObjectVMMethod* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return cls->asClass();
+ }
+};
+
class JavaObjectMethod : public JavaObject {
private:
uint8 flag;
- JavaObjectClass* declaringClass;
- JavaObject* name;
- uint32 slot;
+ JavaObject* p;
+ JavaObjectVMMethod* vmMethod;
public:
static void staticTracer(JavaObjectMethod* obj, word_t closure) {
- vmkit::Collector::markAndTrace(obj, &obj->name, closure);
- vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->p, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->vmMethod, closure);
}
static JavaMethod* getInternalMethod(JavaObjectMethod* self);
static UserClass* getClass(JavaObjectMethod* self) {
llvm_gcroot(self, 0);
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
- return cls->asClass();
+ return JavaObjectVMMethod::getClass(self->vmMethod);
}
static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
};
-class JavaObjectConstructor : public JavaObject {
+
+class JavaObjectVMConstructor : public JavaObject {
private:
- uint8 flag;
JavaObjectClass* declaringClass;
uint32 slot;
public:
- static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
+ static void staticTracer(JavaObjectVMConstructor* obj, word_t closure) {
vmkit::Collector::markAndTrace(obj, &obj->declaringClass, closure);
}
+
+ static JavaMethod* getInternalMethod(JavaObjectVMConstructor* self);
+
+ static UserClass* getClass(JavaObjectVMConstructor* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return cls->asClass();
+ }
+};
+
+class JavaObjectConstructor : public JavaObject {
+private:
+ uint8 flag;
+ JavaObject* p;
+ JavaObjectVMConstructor* vmCons;
+
+public:
+ static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
+ vmkit::Collector::markAndTrace(obj, &obj->p, closure);
+ vmkit::Collector::markAndTrace(obj, &obj->vmCons, closure);
+ }
static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
static UserClass* getClass(JavaObjectConstructor* self) {
llvm_gcroot(self, 0);
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
- return cls->asClass();
+ return JavaObjectVMConstructor::getClass(self->vmCons);
}
static JavaObjectConstructor* createFromInternalConstructor(JavaMethod* cons, int i);
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.cpp Thu Apr 25 11:49:46 2013
@@ -68,13 +68,19 @@ JavaMethod* Classpath::initString;
JavaMethod* Classpath::getCallingClassLoader;
JavaMethod* Classpath::initConstructor;
Class* Classpath::newConstructor;
+JavaMethod* Classpath::initVMConstructor;
+Class* Classpath::newVMConstructor;
ClassArray* Classpath::constructorArrayClass;
ClassArray* Classpath::constructorArrayAnnotation;
JavaField* Classpath::constructorSlot;
JavaMethod* Classpath::initMethod;
+JavaMethod* Classpath::initVMMethod;
JavaMethod* Classpath::initField;
+JavaMethod* Classpath::initVMField;
Class* Classpath::newField;
+Class* Classpath::newVMField;
Class* Classpath::newMethod;
+Class* Classpath::newVMMethod;
ClassArray* Classpath::methodArrayClass;
ClassArray* Classpath::fieldArrayClass;
JavaField* Classpath::methodSlot;
@@ -495,6 +501,21 @@ extern "C" void nativeJavaObjectConstruc
JavaObjectConstructor::staticTracer(obj, closure);
}
+extern "C" void nativeJavaObjectVMFieldTracer(
+ JavaObjectVMField* obj, word_t closure) {
+ JavaObjectVMField::staticTracer(obj, closure);
+}
+
+extern "C" void nativeJavaObjectVMMethodTracer(
+ JavaObjectVMMethod* obj, word_t closure) {
+ JavaObjectVMMethod::staticTracer(obj, closure);
+}
+
+extern "C" void nativeJavaObjectVMConstructorTracer(
+ JavaObjectVMConstructor* obj, word_t closure) {
+ JavaObjectVMConstructor::staticTracer(obj, closure);
+}
+
extern "C" void nativeJavaObjectVMThreadTracer(
JavaObjectVMThread* obj, word_t closure) {
JavaObjectVMThread::staticTracer(obj, closure);
@@ -581,12 +602,19 @@ void Classpath::initialiseClasspath(Jnjv
UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V", ACC_VIRTUAL);
initConstructor =
- UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",
+ UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",
+ "(Ljava/lang/reflect/VMConstructor;)V", ACC_VIRTUAL);
+
+ initVMConstructor =
+ UPCALL_METHOD(loader, "java/lang/reflect/VMConstructor", "<init>",
"(Ljava/lang/Class;I)V", ACC_VIRTUAL);
newConstructor =
UPCALL_CLASS(loader, "java/lang/reflect/Constructor");
+ newVMConstructor =
+ UPCALL_CLASS(loader, "java/lang/reflect/VMConstructor");
+
constructorArrayClass =
UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);
@@ -598,11 +626,18 @@ void Classpath::initialiseClasspath(Jnjv
initMethod =
UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",
- "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
+ "(Ljava/lang/reflect/VMMethod;)V", ACC_VIRTUAL);
+
+ initVMMethod =
+ UPCALL_METHOD(loader, "java/lang/reflect/VMMethod", "<init>",
+ "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
newMethod =
UPCALL_CLASS(loader, "java/lang/reflect/Method");
+ newVMMethod =
+ UPCALL_CLASS(loader, "java/lang/reflect/VMMethod");
+
methodArrayClass =
UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);
@@ -611,11 +646,18 @@ void Classpath::initialiseClasspath(Jnjv
initField =
UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",
- "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
+ "(Ljava/lang/reflect/VMField;)V", ACC_VIRTUAL);
+
+ initVMField =
+ UPCALL_METHOD(loader, "java/lang/reflect/VMField", "<init>",
+ "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
newField =
UPCALL_CLASS(loader, "java/lang/reflect/Field");
+ newVMField =
+ UPCALL_CLASS(loader, "java/lang/reflect/VMField");
+
fieldArrayClass =
UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);
Modified: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/JavaUpcalls.h Thu Apr 25 11:49:46 2013
@@ -62,6 +62,7 @@ class Class;
class ClassArray;
class JnjvmClassLoader;
+
class Classpath : public vmkit::PermanentObject {
public:
ISOLATE_STATIC UserClass* newClassLoader;
@@ -78,16 +79,22 @@ public:
ISOLATE_STATIC JavaMethod* initString;
ISOLATE_STATIC JavaMethod* getCallingClassLoader;
ISOLATE_STATIC JavaMethod* initConstructor;
+ ISOLATE_STATIC JavaMethod* initVMConstructor;
ISOLATE_STATIC UserClassArray* constructorArrayClass;
ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;
ISOLATE_STATIC UserClass* newConstructor;
+ ISOLATE_STATIC UserClass* newVMConstructor;
ISOLATE_STATIC JavaField* constructorSlot;
ISOLATE_STATIC JavaMethod* initMethod;
+ ISOLATE_STATIC JavaMethod* initVMMethod;
ISOLATE_STATIC JavaMethod* initField;
+ ISOLATE_STATIC JavaMethod* initVMField;
ISOLATE_STATIC UserClassArray* methodArrayClass;
ISOLATE_STATIC UserClassArray* fieldArrayClass;
ISOLATE_STATIC UserClass* newMethod;
+ ISOLATE_STATIC UserClass* newVMMethod;
ISOLATE_STATIC UserClass* newField;
+ ISOLATE_STATIC UserClass* newVMField;
ISOLATE_STATIC JavaField* methodSlot;
ISOLATE_STATIC JavaField* fieldSlot;
ISOLATE_STATIC UserClassArray* classArrayClass;
Modified: vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/j3/ClassLib/OpenJDK/JavaUpcalls.cpp Thu Apr 25 11:49:46 2013
@@ -902,6 +902,18 @@ void Classpath::initialiseClasspath(Jnjv
(word_t)nativeJavaObjectFieldTracer,
"nativeJavaObjectFieldTracer");
+ newVMConstructor->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectVMConstructorTracer,
+ "nativeJavaObjectVMConstructorTracer");
+
+ newVMMethod->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectVMMethodTracer,
+ "nativeJavaObjectVMMethodTracer");
+
+ newVMField->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectVMFieldTracer,
+ "nativeJavaObjectVMFieldTracer");
+
//TODO: Fix native tracer for java.lang.Thread to not trace through
// the eetop field to our internal JavaThread.
//newVMThread->getVirtualVT()->setNativeTracer(
Modified: vmkit/trunk/tests/ThreadTest.java
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/tests/ThreadTest.java?rev=180294&r1=180293&r2=180294&view=diff
==============================================================================
--- vmkit/trunk/tests/ThreadTest.java (original)
+++ vmkit/trunk/tests/ThreadTest.java Thu Apr 25 11:49:46 2013
@@ -4,7 +4,13 @@ public class ThreadTest extends Thread {
}
public static void main(String[] args) throws InterruptedException {
- for(int i = 0; i < 10000; ++i) {
+ int count = 10000;
+ try {
+ count = Integer.parseInt(args[0]);
+ }
+ catch (Exception e) {
+ }
+ for(int i = 0; i < count ; ++i) {
Thread t1 = new ThreadTest();
Thread t2 = new ThreadTest();
t1.start();
More information about the vmkit-commits
mailing list