[vmkit-commits] [PATCH] Refactor Class-related code into new Class.inc.
Will Dietz
wdietz2 at illinois.edu
Wed Nov 16 16:05:58 PST 2011
On Wed, Nov 9, 2011 at 3:44 PM, Nicolas Geoffray
<nicolas.geoffray at gmail.com> wrote:
> Actually, I'm just trying to be the less annoying as possible for
> refactoring, as I guess there are much more we can do to get a nicer code
> base while still supporting two class libraries. But that would be in your
> way of getting openjdk support, and I surely prefer having openjdk support
> than a nice class library layer that supports classpath and openjdk, for now
> :)
> Nicolas
Okay, understood.
And thank you very much for being understanding about deferring a
better organization until later, and working with me to get all this
committed and cleaned up :)
Very much appreciated! :)
Anyway, here's an updated version of the patch that I think should
address the previously mentioned concerns. Of course, if not let me
know :).
Inlined below.
~Will
>From 64a5a3448785ea04d24540b020c1cd8b5bc04c96 Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Sat, 5 Nov 2011 23:53:56 -0500
Subject: [PATCH] Refactor reflection code into new Reflect.inc (shared) and
ClasspathReflect
Also use this refactored layout to add implementations for the OpenJDK port
---
lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp | 49 ++++
lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h | 12 +
lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc | 191 +--------------
lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp | 119 +++++++++-
lib/J3/ClassLib/OpenJDK/ClasspathReflect.h | 12 +
lib/J3/ClassLib/OpenJDK/OpenJDK.inc | 262 +++++----------------
lib/J3/ClassLib/Reflect.inc | 255 ++++++++++++++++++++
7 files changed, 510 insertions(+), 390 deletions(-)
create mode 100644 lib/J3/ClassLib/Reflect.inc
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
index 90bd617..20fa7b1 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
@@ -12,6 +12,8 @@
#include "JavaObject.h"
#include "JavaThread.h"
+#include "Reflect.inc"
+
namespace j3 {
JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*
self) {
@@ -27,4 +29,51 @@ JavaMethod*
JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
return &(cls->asClass()->virtualMethods[self->slot]);
}
+JavaObjectConstructor*
JavaObjectConstructor::createFromInternalConstructor(JavaMethod *
cons, int i) {
+ JavaObjectConstructor* ret = 0;
+ llvm_gcroot(ret, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClass* Cons = vm->upcalls->newConstructor;
+ ret = (JavaObjectConstructor*)Cons->doNew(vm);
+ JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+ vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+ Cl, i);
+
+ return ret;
+}
+
+JavaObjectMethod*
JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
+ JavaObjectMethod* ret = 0;
+ JavaString* str = 0;
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(str, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClass* Meth = vm->upcalls->newMethod;
+ ret = (JavaObjectMethod*)Meth->doNew(vm);
+ str = vm->internalUTF8ToStr(meth->name);
+ JavaObject* const* Cl = meth->classDef->getDelegateePtr();
+ vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+ Cl, &str, i);
+
+ return ret;
+}
+
+JavaObjectField* JavaObjectField::createFromInternalField(JavaField*
field, int i) {
+ JavaObjectField* ret = 0;
+ JavaString* name = 0;
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(name, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClass* Field = vm->upcalls->newField;
+ ret = (JavaObjectField*)Field->doNew(vm);
+ name = vm->internalUTF8ToStr(field->name);
+ JavaObject* const* Cl = field->classDef->getDelegateePtr();
+ vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+ Cl, &name, i);
+
+ return ret;
+}
}
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
index d847b98..23c79c5 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
@@ -60,6 +60,15 @@ public:
if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
}
}
+
+ static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
+ static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly);
+ static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl,
bool publicOnly);
+ static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool publicOnly);
+ static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly);
+ static ArrayObject* getInterfaces(JavaObjectClass* Cl);
+ static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
+ static int getModifiers(JavaObjectClass* Cl);
};
class JavaObjectField : public JavaObject {
@@ -88,6 +97,7 @@ public:
return cls->asClass();
}
+ static JavaObjectField* createFromInternalField(JavaField* field, int i);
};
class JavaObjectMethod : public JavaObject {
@@ -112,6 +122,7 @@ public:
return cls->asClass();
}
+ static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
};
class JavaObjectConstructor : public JavaObject {
@@ -133,6 +144,7 @@ public:
return cls->asClass();
}
+ static JavaObjectConstructor*
createFromInternalConstructor(JavaMethod* cons, int i);
};
class JavaObjectVMThread : public JavaObject {
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
index 0c4d21c..0c8eb4f 100644
--- a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
@@ -86,48 +86,12 @@ JavaObject* Cl,
jboolean publicOnly) {
ArrayObject* ret = 0;
- JavaObject* tmp = 0;
llvm_gcroot(Cl, 0);
llvm_gcroot(ret, 0);
- llvm_gcroot(tmp, 0);
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
- if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
- ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
- } else {
- UserClass* realCl = cl->asClass();;
- JnjvmClassLoader* classLoader = cl->classLoader;
- uint32 size = 0;
-
- for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
- (!publicOnly || pub)) {
- ++size;
- }
- }
-
- ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
- sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
- (!publicOnly || pub)) {
- UserClass* Cons = vm->upcalls->newConstructor;
- tmp = Cons->doNew(vm);
- vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);
- ArrayObject::setElement(ret, tmp, index);
- index++;
- }
- }
- }
+ ret = JavaObjectClass::getDeclaredConstructors((JavaObjectClass*)Cl,
publicOnly);
END_NATIVE_EXCEPTION
@@ -143,58 +107,12 @@ JavaObject* Cl,
jboolean publicOnly) {
ArrayObject* ret = 0;
- JavaObject* tmp = 0;
- JavaString* str = 0;
llvm_gcroot(Cl, 0);
llvm_gcroot(ret, 0);
- llvm_gcroot(tmp, 0);
- llvm_gcroot(str, 0);
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
- Classpath* upcalls = vm->upcalls;
-
- if (cl->isArray() || cl->isPrimitive()) {
- ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
- } else {
- UserClass* realCl = cl->asClass();
- JnjvmClassLoader* classLoader = cl->classLoader;
- uint32 size = 0;
-
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
- ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
- !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
- (!publicOnly || pub)) {
- ++size;
- }
- }
-
-
- ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
- sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
- ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
- !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
- (!publicOnly || pub)) {
- // TODO: check parameter types
- UserClass* Meth = vm->upcalls->newMethod;
- tmp = Meth->doNew(vm);
- str = vm->internalUTF8ToStr(meth->name);
- upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);
- ArrayObject::setElement(ret, tmp, index);
- index++;
- }
- }
- }
+ ret = JavaObjectClass::getDeclaredMethods((JavaObjectClass*)Cl, publicOnly);
END_NATIVE_EXCEPTION
@@ -214,14 +132,7 @@ jboolean ignore) {
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
- res = cl->getAccess();
-
- if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
- // javac may put that flag to inner classes of enum classes.
- res &= ~ACC_ENUM;
- }
+ res = JavaObjectClass::getModifiers((JavaObjectClass*)Cl);
END_NATIVE_EXCEPTION
return res;
@@ -428,49 +339,12 @@ jclass clazz,
JavaObject* Cl, jboolean publicOnly) {
ArrayObject* ret = 0;
- JavaObject* tmp = 0;
- JavaString* name = 0;
llvm_gcroot(Cl, 0);
llvm_gcroot(ret, 0);
- llvm_gcroot(tmp, 0);
- llvm_gcroot(name, 0);
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
- if (!cl->isClass()) {
- ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
- } else {
- UserClass* realCl = cl->asClass();
- uint32 size = 0;
- for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
- ++i) {
- JavaField* field = &realCl->virtualFields[i];
- if (!publicOnly || isPublic(field->access)) {
- ++size;
- }
- }
-
-
- ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
- sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
- ++i) {
- JavaField* field = &realCl->virtualFields[i];
- if (!publicOnly || isPublic(field->access)) {
- // TODO: check parameter types
- UserClass* Field = vm->upcalls->newField;
- tmp = Field->doNew(vm);
- name = vm->internalUTF8ToStr(field->name);
- vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,
&name, i);
- ArrayObject::setElement(ret, tmp, index);
- index++;
- }
- }
- }
+ ret = JavaObjectClass::getDeclaredFields((JavaObjectClass*)Cl, publicOnly);
END_NATIVE_EXCEPTION
@@ -490,14 +364,7 @@ JavaObject* Cl) {
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
- res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
vm);
-
- for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
- UserClass* klass = cl->interfaces[i];
- ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
- }
+ res = JavaObjectClass::getInterfaces((JavaObjectClass*)Cl);
END_NATIVE_EXCEPTION
@@ -518,16 +385,7 @@ JavaObject* Cl) {
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
-
- if (cl) {
- cl->resolveInnerOuterClasses();
- UserClass* outer = cl->getOuterClass();
- if (outer) {
- res = outer->getClassDelegatee(vm);
- }
- }
+ res = JavaObjectClass::getDeclaringClass((JavaObjectClass*)Cl);
END_NATIVE_EXCEPTION
@@ -548,33 +406,7 @@ JavaObject* Cl, bool publicOnly) {
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
- if (cl) {
- cl->resolveInnerOuterClasses();
- UserClassArray* array = vm->upcalls->constructorArrayClass;
-
- uint16 sizeArray = 0;
-
- if (publicOnly) {
- for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
- UserClass* klass = cl->innerClasses[i];
- if (isPublic(klass->innerAccess)) ++sizeArray;
- }
- } else {
- sizeArray = cl->nbInnerClasses;
- }
-
- result = (ArrayObject*)array->doNew(sizeArray, vm);
- int index = 0;
- for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
- UserClass* klass = cl->innerClasses[i];
- if (!publicOnly || isPublic(klass->innerAccess))
- ArrayObject::setElement(result, klass->getClassDelegatee(vm),
index++);
- }
- assert(index == sizeArray);
- }
-
+ result = JavaObjectClass::getDeclaredClasses((JavaObjectClass*)Cl,
publicOnly);
END_NATIVE_EXCEPTION
@@ -603,16 +435,14 @@ jclass clazz,
#endif
JavaObject* Cl) {
// TODO implement me
-
+
ArrayObject* res = 0;
llvm_gcroot(res, 0);
llvm_gcroot(Cl, 0);
-
+
BEGIN_NATIVE_EXCEPTION(0)
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
- res = (ArrayObject*)array->doNew(0, vm);
+ res = JavaObjectClass::getDeclaredAnnotations((JavaObjectClass*)Cl);
END_NATIVE_EXCEPTION
@@ -641,5 +471,4 @@ JavaObject* Cl) {
return res;
}
-
}
diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
index 4842bb9..f5be3c2 100644
--- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
+++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
@@ -8,12 +8,14 @@
//===----------------------------------------------------------------------===//
#include "ClasspathReflect.h"
+#include "JavaArray.h"
#include "JavaClass.h"
#include "JavaObject.h"
#include "JavaThread.h"
-#include "Jnjvm.h"
+#include "JavaTypes.h"
#include "JavaUpcalls.h"
-#include "JavaArray.h"
+#include "Jnjvm.h"
+#include "Reflect.inc"
namespace j3 {
@@ -80,4 +82,117 @@ int
JavaObjectThrowable::getStackTraceDepth(JavaObjectThrowable * self) {
return size;
}
+JavaObjectConstructor*
JavaObjectConstructor::createFromInternalConstructor(JavaMethod *
cons, int i) {
+ JavaObjectConstructor* ret = 0;
+ JavaObject* pArr = 0;
+ JavaObject* eArr = 0;
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(pArr, 0);
+ llvm_gcroot(eArr, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ JnjvmClassLoader * classLoader = cons->classDef->classLoader;
+
+ UserClass* Cons = vm->upcalls->newConstructor;
+ pArr = cons->getParameterTypes(classLoader);
+ eArr = cons->getExceptionTypes(classLoader);
+ ret = (JavaObjectConstructor*)Cons->doNew(vm);
+ JavaObject* const* Cl = cons->classDef->getDelegateePtr();
+ vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, ret,
+ Cl, /* declaringClass */
+ &pArr, /* parameterTypes */
+ &eArr, /* checkedExceptions */
+ cons->access, /* modifiers */
+ i, /* slot */
+ NULL, /* String signature */
+ NULL, /* annotations */
+ NULL /* parameterAnnotations */
+ );
+
+ return ret;
+}
+
+JavaObjectMethod*
JavaObjectMethod::createFromInternalMethod(JavaMethod* meth, int i) {
+ JavaObjectMethod* ret = 0;
+ JavaString* str = 0;
+ JavaObject* pArr = 0;
+ JavaObject* eArr = 0;
+ JavaObject* retTy = 0;
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(str, 0);
+ llvm_gcroot(pArr, 0);
+ llvm_gcroot(eArr, 0);
+ llvm_gcroot(retTy, 0);
+
+ // TODO: check parameter types
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ JnjvmClassLoader * classLoader = meth->classDef->classLoader;
+
+ UserClass* Meth = vm->upcalls->newMethod;
+ ret = (JavaObjectMethod*)Meth->doNew(vm);
+ str = vm->internalUTF8ToStr(meth->name);
+ pArr = meth->getParameterTypes(classLoader);
+ eArr = meth->getExceptionTypes(classLoader);
+ retTy = meth->getReturnType(classLoader);
+ JavaObject* const* Cl = meth->classDef->getClassDelegateePtr(vm);
+ vm->upcalls->initMethod->invokeIntSpecial(vm, Meth, ret,
+ Cl, /* declaring class */
+ &str, /* name */
+ &pArr, /* parameter types */
+ &retTy, /* return type */
+ &eArr, /* exceptions */
+ meth->access, /* modifiers */
+ i, /* slot */
+ NULL, /* signature */
+ NULL, /* annotations */
+ NULL, /* parameter annotations */
+ NULL); /* default annotations */
+
+ return ret;
}
+
+JavaObjectField* JavaObjectField::createFromInternalField(JavaField*
field, int i) {
+ JavaObjectField* ret = 0;
+ JavaString* name = 0;
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(name, 0);
+
+ // TODO: check parameter types
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClass* Field = vm->upcalls->newField;
+ ret = (JavaObjectField*)Field->doNew(vm);
+ name = vm->internalUTF8ToStr(field->name);
+
+ //type->Class
+ JnjvmClassLoader* loader = field->classDef->classLoader;
+ UserCommonClass * fieldCl = field->getSignature()->assocClass(loader);
+ assert(fieldCl);
+ JavaObject* const* type = fieldCl->getClassDelegateePtr(vm);
+ JavaObject* const* Cl = field->classDef->getClassDelegateePtr(vm);
+
+ // TODO:Implement these!
+ JavaObject** sign = NULL;
+ JavaObject** annArray = NULL;
+
+ /* java.reflect.Field(
+ * Class declaringClass,
+ * String name,
+ * Class type,
+ * int modifiers,
+ * int slot,
+ * String signature,
+ * byte[] annotations)
+ */
+ vm->upcalls->initField->invokeIntSpecial(vm, Field, ret,
+ Cl,
+ &name,
+ type,
+ field->access,
+ i,
+ sign,
+ annArray);
+
+ return ret;
+}
+
+} // end namespace j3
diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
index 0055a73..15e9574 100644
--- a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
+++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
@@ -92,6 +92,15 @@ public:
if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
}
}
+
+ static ArrayObject* getDeclaredAnnotations(JavaObjectClass* Cl);
+ static ArrayObject* getDeclaredClasses(JavaObjectClass* Cl, bool publicOnly);
+ static ArrayObject* getDeclaredConstructors(JavaObjectClass* Cl,
bool publicOnly);
+ static ArrayObject* getDeclaredFields(JavaObjectClass* Cl, bool publicOnly);
+ static ArrayObject* getDeclaredMethods(JavaObjectClass* Cl, bool publicOnly);
+ static ArrayObject* getInterfaces(JavaObjectClass* Cl);
+ static JavaObject* getDeclaringClass(JavaObjectClass* Cl);
+ static int getModifiers(JavaObjectClass* Cl);
};
class JavaObjectField : public JavaObject {
@@ -143,6 +152,7 @@ public:
return cls->asClass();
}
+ static JavaObjectField* createFromInternalField(JavaField* field, int i);
};
class JavaObjectMethod : public JavaObject {
@@ -196,6 +206,7 @@ public:
return cls->asClass();
}
+ static JavaObjectMethod* createFromInternalMethod(JavaMethod* meth, int i);
};
class JavaObjectConstructor : public JavaObject {
@@ -240,6 +251,7 @@ public:
return cls->asClass();
}
+ static JavaObjectConstructor*
createFromInternalConstructor(JavaMethod* cons, int i);
};
class JavaObjectThrowable : public JavaObject {
diff --git a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
index 016c067..ed84bf1 100644
--- a/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
+++ b/lib/J3/ClassLib/OpenJDK/OpenJDK.inc
@@ -1186,7 +1186,18 @@ JVM_GetClassName(JNIEnv *env, jclass cls) {
JNIEXPORT jobjectArray JNICALL
JVM_GetClassInterfaces(JNIEnv *env, jclass cls) {
- NYI();
+ ArrayObject* ret = 0;
+ llvm_gcroot(ret, 0);
+
+ BEGIN_JNI_EXCEPTION
+
+ ret = JavaObjectClass::getInterfaces(*(JavaObjectClass**)cls);
+
+ RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+ END_JNI_EXCEPTION
+
+ return 0;
}
JNIEXPORT jobject JNICALL
@@ -1328,23 +1339,13 @@ JVM_GetComponentType(JNIEnv *env, jclass cls) {
JNIEXPORT jint JNICALL
JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
- JavaObject * Cl = 0;
+ JavaObjectClass * Cl = 0;
llvm_gcroot(Cl, 0);
BEGIN_JNI_EXCEPTION
- Cl = *(JavaObject**)cls;
-
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
false)->asClass();;
-
- jint res = cl->getAccess();
+ Cl = *(JavaObjectClass**)cls;
- if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
- // javac may put that flag to inner classes of enum classes.
- res &= ~ACC_ENUM;
- }
-
- RETURN_FROM_JNI(res);
+ RETURN_FROM_JNI(JavaObjectClass::getModifiers(Cl));
END_JNI_EXCEPTION
@@ -1353,12 +1354,35 @@ JVM_GetClassModifiers(JNIEnv *env, jclass cls) {
JNIEXPORT jobjectArray JNICALL
JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass) {
- NYI();
+ ArrayObject* ret = 0;
+ llvm_gcroot(ret, 0);
+
+ BEGIN_JNI_EXCEPTION
+
+ // TODO: Verify boolean parameter here, assuming should default to true.
+ ret = JavaObjectClass::getDeclaredClasses(*(JavaObjectClass**)ofClass,
false);
+
+ RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
+
+ END_JNI_EXCEPTION
+
+ return 0;
}
JNIEXPORT jclass JNICALL
JVM_GetDeclaringClass(JNIEnv *env, jclass ofClass) {
- NYI();
+ JavaObject* ret = 0;
+ llvm_gcroot(ret, 0);
+
+ BEGIN_JNI_EXCEPTION
+
+ ret = JavaObjectClass::getDeclaringClass(*(JavaObjectClass**)ofClass);
+
+ RETURN_FROM_JNI((jclass)th->pushJNIRef(ret));
+
+ END_JNI_EXCEPTION
+
+ return 0;
}
/* Generics support (JDK 1.5) */
@@ -1370,7 +1394,18 @@ JVM_GetClassSignature(JNIEnv *env, jclass cls) {
/* Annotations support (JDK 1.5) */
JNIEXPORT jbyteArray JNICALL
JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
- NYI();
+ ArrayObject* ret = 0;
+ llvm_gcroot(ret, 0);
+
+ BEGIN_JNI_EXCEPTION
+
+ ret = JavaObjectClass::getDeclaredAnnotations(*(JavaObjectClass**)cls);
+
+ RETURN_FROM_JNI((jbyteArray)th->pushJNIRef(ret));
+
+ END_JNI_EXCEPTION
+
+ return 0;
}
/*
@@ -1380,74 +1415,11 @@ JVM_GetClassAnnotations(JNIEnv *env, jclass cls) {
JNIEXPORT jobjectArray JNICALL
JVM_GetClassDeclaredMethods(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
ArrayObject* ret = 0;
- JavaObject* tmp = 0;
- JavaString* str = 0;
- JavaObject * Cl = 0;
- llvm_gcroot(Cl, 0);
llvm_gcroot(ret, 0);
- llvm_gcroot(tmp, 0);
- llvm_gcroot(str, 0);
BEGIN_JNI_EXCEPTION
- Cl = *(JavaObject**)ofClass;
-
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
- Classpath* upcalls = vm->upcalls;
-
- if (cl->isArray() || cl->isPrimitive()) {
- ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
- } else {
- UserClass* realCl = cl->asClass();
- JnjvmClassLoader* classLoader = cl->classLoader;
- uint32 size = 0;
-
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
- ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
- (!publicOnly || pub)) {
- ++size;
- }
- }
-
-
- ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
-
- sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
- ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
- (!publicOnly || pub)) {
- // TODO: check parameter types
- UserClass* Meth = vm->upcalls->newMethod;
- tmp = Meth->doNew(vm);
- str = vm->internalUTF8ToStr(meth->name);
- JavaObject * pArr = meth->getParameterTypes(classLoader);
- JavaObject * eArr = meth->getExceptionTypes(classLoader);
- JavaObject * retTy = meth->getReturnType(classLoader);
- upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp,
- &Cl, /* declaring class */
- &str, /* name */
- &pArr, /* parameter types */
- &retTy, /* return type */
- &eArr, /* exceptions */
- meth->access, /* modifiers */
- i, /* slot */
- NULL, /* signature */
- NULL, /* annotations */
- NULL, /* parameter annotations */
- NULL, /* default annotations */
- i);
- ArrayObject::setElement(ret, tmp, index);
- index++;
- }
- }
- }
+ ret = JavaObjectClass::getDeclaredMethods(*(JavaObjectClass**)ofClass,
publicOnly);
RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
@@ -1459,85 +1431,12 @@ JVM_GetClassDeclaredMethods(JNIEnv *env,
jclass ofClass, jboolean publicOnly) {
JNIEXPORT jobjectArray JNICALL
JVM_GetClassDeclaredFields(JNIEnv *env, jclass ofClass, jboolean publicOnly) {
ArrayObject* ret = 0;
- JavaObject* tmp = 0;
- JavaString* name = 0;
- JavaObject*const* type = 0;
- JavaString* sign = 0;
- JavaObject* annArray = 0;
llvm_gcroot(ret, 0);
- llvm_gcroot(tmp, 0);
- llvm_gcroot(name, 0);
- llvm_gcroot(type, 0);
- llvm_gcroot(sign, 0);
- llvm_gcroot(annArray, 0);
BEGIN_JNI_EXCEPTION
- JavaObject * Cl = *(JavaObject**)ofClass;
- llvm_gcroot(Cl, 0);
-
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
- if (!cl->isClass()) {
- ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
- } else {
- UserClass* realCl = cl->asClass();
- uint32 size = 0;
- for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
- ++i) {
- JavaField* field = &realCl->virtualFields[i];
- if (!publicOnly || isPublic(field->access)) {
- ++size;
- }
- }
-
+ ret = JavaObjectClass::getDeclaredFields(*(JavaObjectClass**)ofClass,
publicOnly);
- ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
-
- sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
- ++i) {
- JavaField* field = &realCl->virtualFields[i];
- if (!publicOnly || isPublic(field->access)) {
- // TODO: check parameter types
- UserClass* Field = vm->upcalls->newField;
- tmp = Field->doNew(vm);
- name = vm->internalUTF8ToStr(field->name);
-
- //type->Class
- UserCommonClass * fieldCl =
field->getSignature()->assocClass(cl->classLoader);
- assert(fieldCl);
- type = fieldCl->getClassDelegateePtr(vm);
-
- // TODO:Implement these!
- sign = NULL;
- annArray = NULL;
-
- //Convert to string
-
- /* java.reflect.Field(
- * Class declaringClass,
- * String name,
- * Class type,
- * int modifiers,
- * int slot,
- * String signature,
- * byte[] annotations)
- */
- vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp,
- &Cl,
- &name,
- type,
- field->access,
- i,
- sign,
- annArray);
- ArrayObject::setElement(ret, tmp, index);
- index++;
- }
- }
- }
RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
END_JNI_EXCEPTION
@@ -1548,62 +1447,11 @@ JVM_GetClassDeclaredFields(JNIEnv *env, jclass
ofClass, jboolean publicOnly) {
JNIEXPORT jobjectArray JNICALL
JVM_GetClassDeclaredConstructors(JNIEnv *env, jclass ofClass,
jboolean publicOnly) {
ArrayObject* ret = 0;
- JavaObject* tmp = 0;
- JavaObject* Cl = 0;
- llvm_gcroot(Cl, 0);
llvm_gcroot(ret, 0);
- llvm_gcroot(tmp, 0);
BEGIN_JNI_EXCEPTION
- Cl = *(JavaObject**)ofClass;
-
- Jnjvm* vm = JavaThread::get()->getJVM();
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
-
- if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
- ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
- } else {
- UserClass* realCl = cl->asClass();;
- JnjvmClassLoader* classLoader = cl->classLoader;
- uint32 size = 0;
-
- for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
- (!publicOnly || pub)) {
- ++size;
- }
- }
-
- ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
-
- sint32 index = 0;
- for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
- JavaMethod* meth = &realCl->virtualMethods[i];
- bool pub = isPublic(meth->access);
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
- (!publicOnly || pub)) {
- UserClass* Cons = vm->upcalls->newConstructor;
- JavaObject * pArr = meth->getParameterTypes(classLoader);
- JavaObject * eArr = meth->getExceptionTypes(classLoader);
- tmp = Cons->doNew(vm);
- vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp,
- &Cl, /* declaringClass */
- &pArr, /* parameterTypes */
- &eArr, /* checkedExceptions */
- meth->access, /* modifiers */
- i, /* slot */
- NULL, /* String signature */
- NULL, /* annotations */
- NULL /* parameterAnnotations */
- );
- ArrayObject::setElement(ret, tmp, index);
- index++;
- }
- }
- }
+ ret = JavaObjectClass::getDeclaredConstructors(*(JavaObjectClass**)ofClass,
publicOnly);
RETURN_FROM_JNI((jobjectArray)th->pushJNIRef(ret));
diff --git a/lib/J3/ClassLib/Reflect.inc b/lib/J3/ClassLib/Reflect.inc
new file mode 100644
index 0000000..1d6effd
--- /dev/null
+++ b/lib/J3/ClassLib/Reflect.inc
@@ -0,0 +1,255 @@
+//===---- Reflect.inc - Shared reflecation code
---------------------------===//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClasspathReflect.h"
+#include "JavaArray.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+
+namespace j3 {
+
+ArrayObject* JavaObjectClass::getDeclaredConstructors(JavaObjectClass*
Cl, bool publicOnly) {
+ ArrayObject* ret = 0;
+ JavaObject* tmp = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(tmp, 0);
+
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+ if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {
+ ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);
+ } else {
+ UserClass* realCl = cl->asClass();;
+ JnjvmClassLoader* classLoader = cl->classLoader;
+ uint32 size = 0;
+
+ for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+ JavaMethod* meth = &realCl->virtualMethods[i];
+ bool pub = isPublic(meth->access);
+ if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+ (!publicOnly || pub)) {
+ ++size;
+ }
+ }
+
+ ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);
+
+ sint32 index = 0;
+ for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {
+ JavaMethod* meth = &realCl->virtualMethods[i];
+ bool pub = isPublic(meth->access);
+ if (meth->name->equals(classLoader->bootstrapLoader->initName) &&
+ (!publicOnly || pub)) {
+ tmp = JavaObjectConstructor::createFromInternalConstructor(meth, i);
+ ArrayObject::setElement(ret, tmp, index);
+ index++;
+ }
+ }
+ }
+
+ return ret;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredMethods(JavaObjectClass* Cl,
bool publicOnly) {
+ ArrayObject* ret = 0;
+ JavaObject* tmp = 0;
+ JavaString* str = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(tmp, 0);
+ llvm_gcroot(str, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ Classpath* upcalls = vm->upcalls;
+
+ if (cl->isArray() || cl->isPrimitive()) {
+ ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);
+ } else {
+ UserClass* realCl = cl->asClass();
+ JnjvmClassLoader* classLoader = cl->classLoader;
+ uint32 size = 0;
+
+ for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+ ++i) {
+ JavaMethod* meth = &realCl->virtualMethods[i];
+ bool pub = isPublic(meth->access);
+ if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+ !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+ (!publicOnly || pub)) {
+ ++size;
+ }
+ }
+
+
+ ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);
+
+ sint32 index = 0;
+ for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;
+ ++i) {
+ JavaMethod* meth = &realCl->virtualMethods[i];
+ bool pub = isPublic(meth->access);
+ if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&
+ !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&
+ (!publicOnly || pub)) {
+ tmp = JavaObjectMethod::createFromInternalMethod(meth, i);
+ ArrayObject::setElement(ret, tmp, index);
+ index++;
+ }
+ }
+ }
+
+ return ret;
+}
+
+JavaObject* JavaObjectClass::getDeclaringClass(JavaObjectClass* Cl) {
+ JavaObject* res = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(res, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+
+ if (cl) {
+ cl->resolveInnerOuterClasses();
+ UserClass* outer = cl->getOuterClass();
+ if (outer) {
+ res = outer->getClassDelegatee(vm);
+ }
+ }
+
+ return res;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredClasses(JavaObjectClass* Cl,
bool publicOnly) {
+ ArrayObject* result = 0;
+ llvm_gcroot(result, 0);
+ llvm_gcroot(Cl, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();
+ if (cl) {
+ cl->resolveInnerOuterClasses();
+ UserClassArray* array = vm->upcalls->constructorArrayClass;
+
+ uint16 sizeArray = 0;
+
+ if (publicOnly) {
+ for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+ UserClass* klass = cl->innerClasses[i];
+ if (isPublic(klass->innerAccess)) ++sizeArray;
+ }
+ } else {
+ sizeArray = cl->nbInnerClasses;
+ }
+
+ result = (ArrayObject*)array->doNew(sizeArray, vm);
+ int index = 0;
+ for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {
+ UserClass* klass = cl->innerClasses[i];
+ if (!publicOnly || isPublic(klass->innerAccess))
+ ArrayObject::setElement(result, klass->getClassDelegatee(vm), index++);
+ }
+ assert(index == sizeArray);
+ }
+
+ return result;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredFields(JavaObjectClass* Cl,
bool publicOnly) {
+ ArrayObject* ret = 0;
+ JavaObject* tmp = 0;
+ JavaString* name = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(ret, 0);
+ llvm_gcroot(tmp, 0);
+ llvm_gcroot(name, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+
+ if (!cl->isClass()) {
+ ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);
+ } else {
+ UserClass* realCl = cl->asClass();
+ uint32 size = 0;
+ for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+ ++i) {
+ JavaField* field = &realCl->virtualFields[i];
+ if (!publicOnly || isPublic(field->access)) {
+ ++size;
+ }
+ }
+
+ ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);
+
+ sint32 index = 0;
+ for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;
+ ++i) {
+ JavaField* field = &realCl->virtualFields[i];
+ if (!publicOnly || isPublic(field->access)) {
+ tmp = JavaObjectField::createFromInternalField(field, i);
+ ArrayObject::setElement(ret, tmp, index);
+ index++;
+ }
+ }
+ }
+
+ return ret;
+}
+
+ArrayObject* JavaObjectClass::getInterfaces(JavaObjectClass* Cl) {
+ ArrayObject* res = 0;
+ llvm_gcroot(Cl, 0);
+ llvm_gcroot(res, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,
vm);
+
+ for (uint16 i = 0; i < cl->nbInterfaces; ++i) {
+ UserClass* klass = cl->interfaces[i];
+ ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);
+ }
+
+ return res;
+}
+
+ArrayObject* JavaObjectClass::getDeclaredAnnotations(JavaObjectClass* Cl) {
+ // TODO: Implement me (for now just returning empty array)
+ ArrayObject* res = 0;
+ llvm_gcroot(res, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
+ res = (ArrayObject*)array->doNew(0, vm);
+
+ return res;
+}
+
+int32_t JavaObjectClass::getModifiers(JavaObjectClass* Cl) {
+ llvm_gcroot(Cl, 0);
+ int32_t res;
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ res = cl->getAccess();
+
+ if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {
+ // javac may put that flag to inner classes of enum classes.
+ res &= ~ACC_ENUM;
+ }
+
+ return res;
+}
+
+} // end namespace j3
--
1.7.5.1
More information about the vmkit-commits
mailing list