[vmkit-commits] [PATCH] Refactor Class-related code into new Class.inc.
Nicolas Geoffray
nicolas.geoffray at gmail.com
Thu Nov 17 11:07:50 PST 2011
Looks good, please apply :)
On Thu, Nov 17, 2011 at 1:05 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
> 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
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111117/c8b41405/attachment.html>
More information about the vmkit-commits
mailing list