[vmkit-commits] [vmkit] r180305 - Implementing native methods of some important classes
Peter Senna Tschudin
peter.senna at gmail.com
Thu Apr 25 09:53:21 PDT 2013
Author: peter.senna
Date: Thu Apr 25 11:51:16 2013
New Revision: 180305
URL: http://llvm.org/viewvc/llvm-project?rev=180305&view=rev
Log:
Implementing native methods of some important classes
(cherry picked from commit 27080702e91589805249c5360982a457bdaebb47)
Added:
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMConstructor.inc
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc
vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc
Added: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMConstructor.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMConstructor.inc?rev=180305&view=auto
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMConstructor.inc (added)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMConstructor.inc Thu Apr 25 11:51:16 2013
@@ -0,0 +1,225 @@
+//===- ClasspathConstructor.cpp -------------------------------------------===//
+//===----------- GNU classpath java/lang/reflect/Constructor --------------===//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "types.h"
+
+#include "Classpath.h"
+#include "ClasspathReflect.h"
+#include "JavaArray.h"
+#include "JavaClass.h"
+#include "JavaObject.h"
+#include "JavaThread.h"
+#include "JavaTypes.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
+
+using namespace j3;
+
+extern "C" {
+
+
+
+JNIEXPORT jobject JNICALL Java_java_lang_reflect_VMConstructor_getParameterTypes(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMConstructor* cons) {
+
+ JavaObject* res = 0;
+ UserCommonClass* cls = 0;
+ JavaMethod* method = 0;
+ // Local object references
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
+ verifyNull(cons);
+ cls = (UserCommonClass*)JavaObjectVMConstructor::getClass(cons);
+ method = JavaObjectVMConstructor::getInternalMethod(cons);
+ res = method->getParameterTypes(cls->classLoader);
+
+ END_NATIVE_EXCEPTION
+
+ return (jobject)res;
+}
+
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMConstructor_getModifiersInternal(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMConstructor* cons) {
+
+ jint res = 0;
+
+ JavaMethod* method = 0;
+ // Local object references
+ llvm_gcroot(cons, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ // Store local reference
+ verifyNull(cons);
+ method = JavaObjectVMConstructor::getInternalMethod(cons);
+ res = method->access;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JavaObject* proceedRealConstructor(ArrayObject* args,
+ UserCommonClass* clazz, JavaMethod* method)
+ __attribute__ ((noinline));
+
+JavaObject* proceedRealConstructor(ArrayObject* args,
+ UserCommonClass* clazz, JavaMethod* method) {
+ JavaObject* res = 0;
+ JavaObject* excp = 0;
+
+ llvm_gcroot(args, 0);
+ llvm_gcroot(res, 0);
+ llvm_gcroot(excp, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
+ Signdef* sign = method->getSignature();
+ sint32 size = sign->nbArguments;
+
+ if (isAbstract(clazz->access)) vm->instantiationException(clazz);
+
+ vmkit::ThreadAllocator allocator;
+ // Allocate a buffer to store the arguments.
+ jvalue* buf = size ?
+ (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
+
+ if (nbArgs == size) {
+ UserClass* cl = clazz->asClass();
+ if (cl) {
+ cl->initialiseClass(vm);
+ res = cl->doNew(vm);
+ JavaObject** ptr = (JavaObject**)ArrayObject::getElements(args);
+
+ Typedef* const* arguments = sign->getArgumentsType();
+ // Store the arguments, unboxing primitives if necessary.
+ for (sint32 i = 0; i < size; ++i) {
+ JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);
+ if (!arguments[i]->isPrimitive()) {
+ buf[i].l = reinterpret_cast<jobject>(&ptr[i]);
+ }
+ }
+
+ JavaThread* th = JavaThread::get();
+ TRY {
+ method->invokeIntSpecialBuf(vm, cl, res, buf);
+ } CATCH {
+ excp = th->getJavaException();
+ } END_CATCH;
+ if (excp) {
+ if (JavaObject::getClass(excp)->isSubclassOf(vm->upcalls->newException)) {
+ th->clearException();
+ // If it's an exception, we encapsule it in an
+ // invocationTargetException
+ vm->invocationTargetException(excp);
+ } else {
+ // If it's an error, throw it again.
+ th->throwPendingException();
+ }
+ return NULL;
+ }
+ } else {
+ vm->illegalArgumentException("class is not a regular class");
+ return NULL;
+ }
+ } else {
+ vm->illegalArgumentException("wrong number of arguments");
+ return NULL;
+ }
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMConstructor_construct(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMConstructor* cons, ArrayObject* args) {
+
+ JavaObject* res = 0;
+ JavaMethod* m = 0;
+ UserCommonClass* cls = 0;
+
+ llvm_gcroot(res, 0);
+ llvm_gcroot(cons, 0);
+ llvm_gcroot(args, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(cons);
+
+ cls = (UserCommonClass*)JavaObjectVMConstructor::getClass(cons);
+ m = JavaObjectVMConstructor::getInternalMethod(cons);
+ res = proceedRealConstructor(args, cls, m);
+
+ END_NATIVE_EXCEPTION
+ return res;
+}
+
+JNIEXPORT
+ArrayObject* JNICALL Java_java_lang_reflect_VMConstructor_getExceptionTypes(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMConstructor* cons) {
+
+ ArrayObject* res = 0;
+ JavaMethod* m = 0;
+ UserCommonClass* cls = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(cons, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ verifyNull(cons);
+ cls = (UserCommonClass*)JavaObjectVMConstructor::getClass(cons);
+ m = JavaObjectVMConstructor::getInternalMethod(cons);
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = (ArrayObject*)m->getExceptionTypes(loader);
+
+ END_NATIVE_EXCEPTION
+
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMConstructor_getSignature(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMConstructor* cons) {
+
+ JavaObject* result = 0;
+ JavaMethod* m = 0;
+ llvm_gcroot(result, 0);
+ llvm_gcroot(cons, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ verifyNull(cons);
+ m = JavaObjectVMConstructor::getInternalMethod(cons);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ result = vm->internalUTF8ToStr(m->type);
+
+ END_NATIVE_EXCEPTION
+
+ return result;
+}
+
+
+}
Added: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc?rev=180305&view=auto
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc (added)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMField.inc Thu Apr 25 11:51:16 2013
@@ -0,0 +1,1190 @@
+//===- ClasspathReflect.cpp - Internal representation of core system classes -//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+//===- ClasspathVMField.cpp - GNU classpath java/lang/reflect/Field -------===//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Classpath.h"
+#include "ClasspathReflect.h"
+#include "JavaClass.h"
+#include "JavaThread.h"
+#include "JavaTypes.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+
+
+#include "Reader.h"
+
+#if 0
+using namespace vmkit;
+#define dprintf(...) do { printf("ClasspathVMField: "); printf(__VA_ARGS__); } while(0)
+#else
+#define dprintf(...)
+#endif
+
+using namespace j3;
+
+extern "C" {
+
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getModifiersInternal(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field) {
+ jint res = 0;
+
+ llvm_gcroot(Field, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+
+ res = field->access;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_getType(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field) {
+
+ JavaObject* res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+
+ UserCommonClass* cls = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+
+ JnjvmClassLoader* loader = cls->classLoader;
+ UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);
+ res = fieldCl->getClassDelegatee(vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMField_getInt(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jint res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ const Typedef* type = field->getSignature();
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+
+ if (prim->isInt()) {
+ if (stat) {
+ res = (sint32)field->getStaticInt32Field();
+ } else {
+ res = (sint32)field->getInstanceInt32Field(obj);
+ }
+ } else if (prim->isChar()) {
+ if (stat) {
+ res = (uint32)field->getStaticInt16Field();
+ } else {
+ res = (uint32)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isByte()) {
+ if (stat) {
+ res = (sint32)field->getStaticInt8Field();
+ } else {
+ res = (sint32)field->getInstanceInt8Field(obj);
+ }
+ } else if (prim->isShort()) {
+ if (stat) {
+ res = (sint32)field->getStaticInt16Field();
+ } else {
+ res = (sint32)field->getInstanceInt16Field(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+
+}
+
+JNIEXPORT jlong JNICALL Java_java_lang_reflect_VMField_getLong(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jlong res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+
+ if (prim->isInt()) {
+ if (stat) {
+ res = (sint64)field->getStaticInt32Field();
+ } else {
+ res = (sint64)field->getInstanceInt32Field(obj);
+ }
+ } else if (prim->isChar()) {
+ if (stat) {
+ res = (uint64)field->getStaticInt16Field();
+ } else {
+ res = (uint64)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isByte()) {
+ if (stat) {
+ res = (sint64)field->getStaticInt8Field();
+ } else {
+ res = (sint64)field->getInstanceInt8Field(obj);
+ }
+ } else if (prim->isShort()) {
+ if (stat) {
+ res = (sint64)field->getStaticInt16Field();
+ } else {
+ res = (sint64)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ res = (sint64)field->getStaticLongField();
+ } else {
+ res = (sint64)field->getInstanceLongField(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT jboolean JNICALL Java_java_lang_reflect_VMField_getBoolean(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jboolean res = 0;
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isBool()) {
+ if (stat) {
+ res = (uint8)field->getStaticInt8Field();
+ } else {
+ res = (uint8)field->getInstanceInt8Field(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+
+}
+
+JNIEXPORT jfloat JNICALL Java_java_lang_reflect_VMField_getFloat(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jfloat res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isByte()) {
+ if (stat) {
+ res = (jfloat)field->getStaticInt8Field();
+ } else {
+ res = (jfloat)field->getInstanceInt8Field(obj);
+ }
+ } else if (prim->isInt()) {
+ if (stat) {
+ res = (jfloat)field->getStaticInt32Field();
+ } else {
+ res = (jfloat)field->getInstanceInt32Field(obj);
+ }
+ } else if (prim->isShort()) {
+ if (stat) {
+ res = (jfloat)field->getStaticInt16Field();
+ } else {
+ res = (jfloat)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ res = (jfloat)field->getStaticLongField();
+ } else {
+ res = (jfloat)field->getInstanceLongField(obj);
+ }
+ } else if (prim->isChar()) {
+ // Cast to uint32 because char is unsigned.
+ if (stat) {
+ res = (jfloat)(uint32)field->getStaticInt16Field();
+ } else {
+ res = (jfloat)(uint32)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ res = (jfloat)field->getStaticFloatField();
+ } else {
+ res = (jfloat)field->getInstanceFloatField(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT jbyte JNICALL Java_java_lang_reflect_VMField_getByte(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jbyte res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isByte()) {
+ if (stat) {
+ res = (sint8)field->getStaticInt8Field();
+ } else {
+ res = (sint8)field->getInstanceInt8Field(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT jchar JNICALL Java_java_lang_reflect_VMField_getChar(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jchar res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isChar()) {
+ if (stat) {
+ res = (uint16)field->getStaticInt16Field();
+ } else {
+ res = (uint16)field->getInstanceInt16Field(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+
+}
+
+JNIEXPORT jshort JNICALL Java_java_lang_reflect_VMField_getShort(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+
+ jshort res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isShort()) {
+ if (stat) {
+ res = (sint16)field->getStaticInt16Field();
+ } else {
+ res = (sint16)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isByte()) {
+ if (stat) {
+ res = (sint16)field->getStaticInt8Field();
+ } else {
+ res = (sint16)field->getInstanceInt8Field(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT jdouble JNICALL Java_java_lang_reflect_VMField_getDouble(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+ jdouble res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isByte()) {
+ if (stat) {
+ res = (jdouble)(sint64)field->getStaticInt8Field();
+ } else {
+ res = (jdouble)(sint64)field->getInstanceInt8Field(obj);
+ }
+ } else if (prim->isInt()) {
+ if (stat) {
+ res = (jdouble)(sint64)field->getStaticInt32Field();
+ } else {
+ res = (jdouble)(sint64)field->getInstanceInt32Field(obj);
+ }
+ } else if (prim->isShort()) {
+ if (stat) {
+ res = (jdouble)(sint64)field->getStaticInt16Field();
+ } else {
+ res = (jdouble)(sint64)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ res = (jdouble)(sint64)field->getStaticLongField();
+ } else {
+ res = (jdouble)(sint64)field->getInstanceLongField(obj);
+ }
+ } else if (prim->isChar()) {
+ if (stat) {
+ res = (jdouble)(uint64)field->getStaticInt16Field();
+ } else {
+ res = (jdouble)(uint64)field->getInstanceInt16Field(obj);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ res = (jdouble)field->getStaticFloatField();
+ } else {
+ res = (jdouble)field->getInstanceFloatField(obj);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ res = (jdouble)field->getStaticDoubleField();
+ } else {
+ res = (jdouble)field->getInstanceDoubleField(obj);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMField_get(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj) {
+
+
+ JavaObject* res = 0;
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isBool()) {
+ uint8 val = stat ? field->getStaticInt8Field() :
+ field->getInstanceInt8Field(obj);
+ res = vm->upcalls->boolClass->doNew(vm);
+ vm->upcalls->boolValue->setInstanceInt8Field(res, val);
+ } else if (prim->isByte()) {
+ sint8 val = stat ? field->getStaticInt8Field() :
+ field->getInstanceInt8Field(obj);
+ res = vm->upcalls->byteClass->doNew(vm);
+ vm->upcalls->byteValue->setInstanceInt8Field(res, val);
+ } else if (prim->isChar()) {
+ uint16 val = stat ? field->getStaticInt16Field() :
+ field->getInstanceInt16Field(obj);
+ res = vm->upcalls->charClass->doNew(vm);
+ vm->upcalls->charValue->setInstanceInt16Field(res, val);
+ } else if (prim->isShort()) {
+ sint16 val = stat ? field->getStaticInt16Field() :
+ field->getInstanceInt16Field(obj);
+ res = vm->upcalls->shortClass->doNew(vm);
+ vm->upcalls->shortValue->setInstanceInt16Field(res, val);
+ } else if (prim->isInt()) {
+ sint64 val = stat ? field->getStaticInt32Field() :
+ field->getInstanceInt32Field(obj);
+ res = vm->upcalls->intClass->doNew(vm);
+ vm->upcalls->intValue->setInstanceInt32Field(res, val);
+ } else if (prim->isLong()) {
+ sint64 val = stat ? field->getStaticLongField() :
+ field->getInstanceLongField(obj);
+ res = vm->upcalls->longClass->doNew(vm);
+ vm->upcalls->longValue->setInstanceLongField(res, val);
+ } else if (prim->isFloat()) {
+ float val = stat ? field->getStaticFloatField() :
+ field->getInstanceFloatField(obj);
+ res = vm->upcalls->floatClass->doNew(vm);
+ vm->upcalls->floatValue->setInstanceFloatField(res, val);
+ } else if (prim->isDouble()) {
+ double val = stat ? field->getStaticDoubleField() :
+ field->getInstanceDoubleField(obj);
+ res = vm->upcalls->doubleClass->doNew(vm);
+ vm->upcalls->doubleValue->setInstanceDoubleField(res, val);
+ }
+ } else {
+ if (stat) {
+ res = field->getStaticObjectField();
+ } else {
+ res = field->getInstanceObjectField(obj);
+ }
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_set(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, JavaObject* val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(val, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ verifyNull(Field);
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ jvalue buf;
+ bool stat = isStatic(field->access);
+
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ JavaObject::decapsulePrimitive(val, vm, &buf, type);
+
+
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isBool()) {
+ if (stat) {
+ field->setStaticInt8Field(buf.z);
+ } else {
+ field->setInstanceInt8Field(obj, buf.z);
+ }
+ } else if (prim->isByte()) {
+ if (stat) {
+ field->setStaticInt8Field(buf.b);
+ } else {
+ field->setInstanceInt8Field(obj, buf.b);
+ }
+ } else if (prim->isChar()) {
+ if (stat) {
+ field->setStaticInt16Field(buf.c);
+ } else {
+ field->setInstanceInt16Field(obj, buf.c);
+ }
+ } else if (prim->isShort()) {
+ if (stat) {
+ field->setStaticInt16Field(buf.s);
+ } else {
+ field->setInstanceInt16Field(obj, buf.s);
+ }
+ } else if (prim->isInt()) {
+ if (stat) {
+ field->setStaticInt32Field(buf.i);
+ } else {
+ field->setInstanceInt32Field(obj, buf.i);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ field->setStaticLongField(buf.j);
+ } else {
+ field->setInstanceLongField(obj, buf.j);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField(buf.f);
+ } else {
+ field->setInstanceFloatField(obj, buf.f);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField(buf.d);
+ } else {
+ field->setInstanceDoubleField(obj, buf.d);
+ }
+ }
+ } else {
+ if (stat) {
+ field->setStaticObjectField(val);
+ } else {
+ field->setInstanceObjectField(obj, val);
+ }
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setBoolean(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jboolean val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isBool()) {
+ if (stat) {
+ field->setStaticInt8Field((uint8)val);
+ } else {
+ field->setInstanceInt8Field(obj, (uint8)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setByte(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jbyte val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isByte()) {
+ if (stat) {
+ field->setStaticInt8Field((sint8)val);
+ } else {
+ field->setInstanceInt8Field(obj, (sint8)val);
+ }
+ } else if (prim->isShort()) {
+ if (stat) {
+ field->setStaticInt16Field((sint16)val);
+ } else {
+ field->setInstanceInt16Field(obj, (sint16)val);
+ }
+ } else if (prim->isInt()) {
+ if (stat) {
+ field->setStaticInt32Field((sint32)val);
+ } else {
+ field->setInstanceInt32Field(obj, (sint32)val);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ field->setStaticLongField((sint64)val);
+ } else {
+ field->setInstanceLongField(obj, (sint64)val);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField((float)val);
+ } else {
+ field->setInstanceFloatField(obj, (float)val);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setChar(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jchar val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isChar()) {
+ if (stat) {
+ field->setStaticInt16Field((uint16)val);
+ } else {
+ field->setInstanceInt16Field(obj, (uint16)val);
+ }
+ } else if (prim->isInt()) {
+ if (stat) {
+ field->setStaticInt32Field((uint32)val);
+ } else {
+ field->setInstanceInt32Field(obj, (uint32)val);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ field->setStaticLongField((uint64)val);
+ } else {
+ field->setInstanceLongField(obj, (uint64)val);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField((float)(uint32)val);
+ } else {
+ field->setInstanceFloatField(obj, (float)(uint32)val);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)(uint64)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)(uint64)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setShort(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jshort val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isShort()) {
+ if (stat) {
+ field->setStaticInt16Field((sint16)val);
+ } else {
+ field->setInstanceInt16Field(obj, (sint16)val);
+ }
+ } else if (prim->isInt()) {
+ if (stat) {
+ field->setStaticInt32Field((sint32)val);
+ } else {
+ field->setInstanceInt32Field(obj, (sint32)val);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ field->setStaticLongField((sint64)val);
+ } else {
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField((float)val);
+ } else {
+ field->setInstanceFloatField(obj, (float)val);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setInt(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jint val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isInt()) {
+ if (stat) {
+ field->setStaticInt32Field((sint32)val);
+ } else {
+ field->setInstanceInt32Field(obj, (sint32)val);
+ }
+ } else if (prim->isLong()) {
+ if (stat) {
+ field->setStaticLongField((sint64)val);
+ } else {
+ field->setInstanceLongField(obj, (sint64)val);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField((float)val);
+ } else {
+ field->setInstanceFloatField(obj, (float)val);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setLong(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jlong val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isLong()) {
+ if (stat) {
+ field->setStaticLongField((sint64)val);
+ } else {
+ field->setInstanceLongField(obj, (sint64)val);
+ }
+ } else if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField((float)val);
+ } else {
+ field->setInstanceFloatField(obj, (float)val);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setFloat(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jfloat val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isFloat()) {
+ if (stat) {
+ field->setStaticFloatField((float)val);
+ } else {
+ field->setInstanceFloatField(obj, (float)val);
+ }
+ } else if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+JNIEXPORT void JNICALL Java_java_lang_reflect_VMField_setDouble(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMField* Field, JavaObject* obj, jdouble val) {
+
+ llvm_gcroot(Field, 0);
+ llvm_gcroot(obj, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Field);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserCommonClass* cl = (UserCommonClass*)JavaObjectVMField::getClass(Field);
+ JavaField* field = JavaObjectVMField::getInternalField(Field);
+ bool stat = isStatic(field->access);
+
+ if (stat) {
+ cl->asClass()->initialiseClass(vm);
+ } else {
+ verifyNull(obj);
+ }
+
+ const Typedef* type = field->getSignature();
+ if (type->isPrimitive()) {
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;
+ if (prim->isDouble()) {
+ if (stat) {
+ field->setStaticDoubleField((double)val);
+ } else {
+ field->setInstanceDoubleField(obj, (double)val);
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+ } else {
+ vm->illegalArgumentException("wrong type");
+ }
+
+ END_NATIVE_EXCEPTION
+}
+
+}
Added: vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc?rev=180305&view=auto
==============================================================================
--- vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc (added)
+++ vmkit/trunk/lib/j3/ClassLib/GNUClasspath/ClasspathVMMethod.inc Thu Apr 25 11:51:16 2013
@@ -0,0 +1,305 @@
+//===- ClasspathReflect.cpp - Internal representation of core system classes -//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+#include "types.h"
+
+#include "Classpath.h"
+#include "ClasspathReflect.h"
+#include "JavaArray.h"
+#include "JavaClass.h"
+#include "JavaObject.h"
+#include "JavaTypes.h"
+#include "JavaThread.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "JnjvmClassLoader.h"
+
+using namespace j3;
+
+extern "C" {
+
+JNIEXPORT jint JNICALL Java_java_lang_reflect_VMMethod_getModifiersInternal(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* Meth) {
+
+ jint res = 0;
+ llvm_gcroot(Meth, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaMethod* meth = JavaObjectVMMethod::getInternalMethod(Meth);
+ res = meth->access;
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getReturnType(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* Meth) {
+
+ JavaObject* res = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Meth);
+
+ JavaMethod* meth = JavaObjectVMMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = (UserCommonClass*)JavaObjectVMMethod::getClass(Meth);
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = meth->getReturnType(loader);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getParameterTypes(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* Meth) {
+
+ JavaObject* res = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Meth);
+
+ JavaMethod* meth = JavaObjectVMMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = (UserCommonClass*)JavaObjectVMMethod::getClass(Meth);
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = meth->getParameterTypes(loader);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+
+JavaObject* proceedVMMethod(JavaObjectVMMethod* Meth, JavaObject* obj,
+ ArrayObject* args)
+ __attribute__((noinline));
+
+JavaObject* proceedVMMethod(JavaObjectVMMethod* Meth, JavaObject* obj,
+ ArrayObject* args) {
+
+ JavaObject* res = 0;
+ JavaObject* exc = 0;
+
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(args, 0);
+ llvm_gcroot(exc, 0);
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ JavaMethod* meth = JavaObjectVMMethod::getInternalMethod(Meth);
+ UserCommonClass* _cl = (UserCommonClass*)JavaObjectVMMethod::getClass(Meth);
+
+ sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
+ Signdef* sign = meth->getSignature();
+ sint32 size = sign->nbArguments;
+
+ vmkit::ThreadAllocator allocator;
+ jvalue* buf = size ?
+ (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
+
+ if (nbArgs == size) {
+ //UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
+ UserClass* cl = (UserClass*)_cl;
+
+ if (isVirtual(meth->access)) {
+ verifyNull(obj);
+ UserCommonClass* objCl = JavaObject::getClass(obj);
+ if (!(objCl->isSubclassOf(cl))) {
+ vm->illegalArgumentException("<this> is not a valid type");
+ }
+
+ if (isInterface(cl->access)) {
+ cl->initialiseClass(vm);
+ UserClass* methodCl = 0;
+ UserClass* lookup = objCl->isArray() ? objCl->super : objCl->asClass();
+ meth = lookup->lookupMethod(meth->name, meth->type, false, true,
+ &methodCl);
+ }
+ } else {
+ cl->initialiseClass(vm);
+ }
+
+ JavaObject** ptr = ArrayObject::getElements(args);
+ Typedef* const* arguments = sign->getArgumentsType();
+ for (sint32 i = 0; i < size; ++i) {
+ JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);
+ if (!arguments[i]->isPrimitive()) {
+ buf[i].l = reinterpret_cast<jobject>(&ptr[i]);
+ }
+ }
+
+ JavaThread* th = JavaThread::get();
+
+#define RUN_METH(TYPE, VAR) \
+ TRY { \
+ if (isVirtual(meth->access)) { \
+ if (isPublic(meth->access) && !isFinal(meth->access) && \
+ !isFinal(meth->classDef->access)) { \
+ VAR = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, buf); \
+ } else { \
+ VAR = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, buf); \
+ } \
+ } else { \
+ VAR = meth->invoke##TYPE##StaticBuf(vm, cl, buf); \
+ } \
+ } CATCH { \
+ exc = th->getJavaException(); \
+ } END_CATCH; \
+ if (exc) { \
+ th->clearException(); \
+ th->getJVM()->invocationTargetException(exc); \
+ return NULL; \
+ }
+
+ Typedef* retType = sign->getReturnType();
+ if (retType->isPrimitive()) {
+ PrimitiveTypedef* prim = (PrimitiveTypedef*)retType;
+ if (prim->isVoid()) {
+ res = 0;
+ uint32 val = 0;
+ RUN_METH(Int, val);
+ } else if (prim->isBool()) {
+ uint32 val = 0;
+ RUN_METH(Int, val);
+ res = vm->upcalls->boolClass->doNew(vm);
+ vm->upcalls->boolValue->setInstanceInt8Field(res, val);
+ } else if (prim->isByte()) {
+ uint32 val = 0;
+ RUN_METH(Int, val);
+ res = vm->upcalls->byteClass->doNew(vm);
+ vm->upcalls->byteValue->setInstanceInt8Field(res, val);
+ } else if (prim->isChar()) {
+ uint32 val = 0;
+ RUN_METH(Int, val);
+ res = vm->upcalls->charClass->doNew(vm);
+ vm->upcalls->charValue->setInstanceInt16Field(res, val);
+ } else if (prim->isShort()) {
+ uint32 val = 0;
+ RUN_METH(Int, val);
+ res = vm->upcalls->shortClass->doNew(vm);
+ vm->upcalls->shortValue->setInstanceInt16Field(res, val);
+ } else if (prim->isInt()) {
+ uint32 val = 0;
+ RUN_METH(Int, val);
+ res = vm->upcalls->intClass->doNew(vm);
+ vm->upcalls->intValue->setInstanceInt32Field(res, val);
+ } else if (prim->isLong()) {
+ sint64 val = 0;
+ RUN_METH(Long, val);
+ res = vm->upcalls->longClass->doNew(vm);
+ vm->upcalls->longValue->setInstanceLongField(res, val);
+ } else if (prim->isFloat()) {
+ float val = 0;
+ RUN_METH(Float, val);
+ res = vm->upcalls->floatClass->doNew(vm);
+ vm->upcalls->floatValue->setInstanceFloatField(res, val);
+ } else if (prim->isDouble()) {
+ double val = 0;
+ RUN_METH(Double, val);
+ res = vm->upcalls->doubleClass->doNew(vm);
+ vm->upcalls->doubleValue->setInstanceDoubleField(res, val);
+ }
+ } else {
+ RUN_METH(JavaObject, res);
+ }
+ } else {
+ vm->illegalArgumentException("wrong number of arguments");
+ return NULL;
+ }
+
+ return res;
+}
+
+#undef RUN_METH
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_invoke(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* Meth, JavaObject* obj, ArrayObject* args) {
+
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(args, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+ verifyNull(Meth);
+ res = proceedVMMethod(Meth, obj, args);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT ArrayObject* JNICALL Java_java_lang_reflect_VMMethod_getExceptionTypes(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* Meth) {
+
+ ArrayObject* res = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ verifyNull(Meth);
+
+ JavaMethod* meth = JavaObjectVMMethod::getInternalMethod(Meth);
+ UserCommonClass* cls = (UserCommonClass*)JavaObjectVMMethod::getClass(Meth);
+ JnjvmClassLoader* loader = cls->classLoader;
+ res = meth->getExceptionTypes(loader);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMMethod_getSignature(
+#ifdef NATIVE_JNI
+JNIEnv *env,
+#endif
+JavaObjectVMMethod* Meth) {
+
+ JavaObject* result = 0;
+ llvm_gcroot(Meth, 0);
+ llvm_gcroot(result, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ verifyNull(Meth);
+ JavaMethod* meth = JavaObjectVMMethod::getInternalMethod(Meth);
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ result = vm->internalUTF8ToStr(meth->type);
+
+ END_NATIVE_EXCEPTION
+
+ return result;
+}
+
+}
More information about the vmkit-commits
mailing list