[vmkit-commits] [PATCH] Move classpath to subdirectory, infrastructure for both runtimes
Nicolas Geoffray
nicolas.geoffray at gmail.com
Tue Oct 25 06:35:30 PDT 2011
Patch looks good! Hopefully you've just made svn move? (or the git
equivalent)
On Tue, Oct 25, 2011 at 12:32 AM, Will Dietz <wdietz2 at illinois.edu> wrote:
> File-level refactoring, sorry for noisy diff.
>
> Essentially move lib/J3/Classpath/* to lib/J3/ClasLib/GNUClasspath/*,
> and update Makefiles.
>
> Classpath.h.in is only exception--it goes in lib/J3/ClassLib/
> Classpath.h.in.
>
> No intended functionality changes.
>
> ~Will
>
> >From accdc80f91a029abc79f16fd867b8b45ec964ccf Mon Sep 17 00:00:00 2001
> From: Will Dietz <w at wdtz.org>
> Date: Fri, 14 Oct 2011 02:54:01 -0500
> Subject: [PATCH 01/29] Move Classpath to subdirectory, infrastructure for
> both runtimes.
>
> ---
> lib/J3/ClassLib/Classpath.h.in | 22 +
> lib/J3/ClassLib/GNUClasspath/Classpath.inc | 392 +++++++
> .../ClassLib/GNUClasspath/ClasspathConstructor.inc | 222 ++++
> lib/J3/ClassLib/GNUClasspath/ClasspathField.inc | 1171
> ++++++++++++++++++++
> lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc | 304 +++++
> lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp | 30 +
> lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h | 222 ++++
> lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc | 645 +++++++++++
> .../GNUClasspath/ClasspathVMClassLoader.inc | 380 +++++++
> lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc | 170 +++
> .../ClassLib/GNUClasspath/ClasspathVMRuntime.inc | 228 ++++
> .../GNUClasspath/ClasspathVMStackWalker.inc | 86 ++
> lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc | 119 ++
> .../GNUClasspath/ClasspathVMSystemProperties.inc | 154 +++
> lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc | 217 ++++
> .../ClassLib/GNUClasspath/ClasspathVMThrowable.inc | 183 +++
> lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp | 1076
> ++++++++++++++++++
> lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h | 283 +++++
> lib/J3/ClassLib/GNUClasspath/Makefile | 23 +
> lib/J3/ClassLib/Makefile | 15 +
> lib/J3/ClassLib/OpenJDK/Makefile | 19 +
> lib/J3/Classpath/Classpath.h.in | 19 -
> lib/J3/Classpath/Classpath.inc | 392 -------
> lib/J3/Classpath/ClasspathConstructor.inc | 222 ----
> lib/J3/Classpath/ClasspathField.inc | 1171
> --------------------
> lib/J3/Classpath/ClasspathMethod.inc | 304 -----
> lib/J3/Classpath/ClasspathReflect.cpp | 30 -
> lib/J3/Classpath/ClasspathReflect.h | 222 ----
> lib/J3/Classpath/ClasspathVMClass.inc | 645 -----------
> lib/J3/Classpath/ClasspathVMClassLoader.inc | 380 -------
> lib/J3/Classpath/ClasspathVMObject.inc | 170 ---
> lib/J3/Classpath/ClasspathVMRuntime.inc | 229 ----
> lib/J3/Classpath/ClasspathVMStackWalker.inc | 86 --
> lib/J3/Classpath/ClasspathVMSystem.inc | 119 --
> lib/J3/Classpath/ClasspathVMSystemProperties.inc | 154 ---
> lib/J3/Classpath/ClasspathVMThread.inc | 217 ----
> lib/J3/Classpath/ClasspathVMThrowable.inc | 183 ---
> lib/J3/Classpath/JavaUpcalls.cpp | 1076
> ------------------
> lib/J3/Classpath/JavaUpcalls.h | 283 -----
> lib/J3/Classpath/Makefile | 23 -
> lib/J3/Compiler/Makefile | 2 +-
> lib/J3/Makefile | 2 +-
> lib/J3/VMCore/Makefile | 2 +-
> 43 files changed, 5964 insertions(+), 5928 deletions(-)
> create mode 100644 lib/J3/ClassLib/Classpath.h.in
> create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathField.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> create mode 100644
> lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
> create mode 100644 lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> create mode 100644 lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
> create mode 100644 lib/J3/ClassLib/GNUClasspath/Makefile
> create mode 100644 lib/J3/ClassLib/Makefile
> create mode 100644 lib/J3/ClassLib/OpenJDK/Makefile
> delete mode 100644 lib/J3/Classpath/Classpath.h.in
> delete mode 100644 lib/J3/Classpath/Classpath.inc
> delete mode 100644 lib/J3/Classpath/ClasspathConstructor.inc
> delete mode 100644 lib/J3/Classpath/ClasspathField.inc
> delete mode 100644 lib/J3/Classpath/ClasspathMethod.inc
> delete mode 100644 lib/J3/Classpath/ClasspathReflect.cpp
> delete mode 100644 lib/J3/Classpath/ClasspathReflect.h
> delete mode 100644 lib/J3/Classpath/ClasspathVMClass.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMClassLoader.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMObject.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMRuntime.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMStackWalker.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMSystem.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMSystemProperties.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMThread.inc
> delete mode 100644 lib/J3/Classpath/ClasspathVMThrowable.inc
> delete mode 100644 lib/J3/Classpath/JavaUpcalls.cpp
> delete mode 100644 lib/J3/Classpath/JavaUpcalls.h
> delete mode 100644 lib/J3/Classpath/Makefile
>
> diff --git a/lib/J3/ClassLib/Classpath.h.in b/lib/J3/ClassLib/
> Classpath.h.in
> new file mode 100644
> index 0000000..a409582
> --- /dev/null
> +++ b/lib/J3/ClassLib/Classpath.h.in
> @@ -0,0 +1,22 @@
> +//===-------- Classpath.h - Configuration for classpath
> -------------------===//
> +//
> +// The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#ifdef NATIVE_JNI
> +#define JNIEXPORT
> +#else
> +#include <jni.h>
> +#endif
> +
> +// GNU Classpath values
> +#define GNUClasspathLibs "@classpathlibs@";
> +#define GNUClasspathGlibj "@classpathglibj@";
> +#define GNUClasspathVersion "@classpathversion@";
> +
> +// OpenJDK values
> +// TODO: Add me!
> diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> new file mode 100644
> index 0000000..b33a5f6
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc
> @@ -0,0 +1,392 @@
> +//===-------- Classpath.cpp - Configuration for classpath
> -------------------===//
> +//
> +// 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 "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +// Define hasClassInitializer because of a buggy implementation in
> Classpath.
> +JNIEXPORT bool JNICALL
> Java_java_io_VMObjectStreamClass_hasClassInitializer(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + llvm_gcroot(Cl, 0);
> + bool res = false;
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(Cl);
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
> +
> + if (cl->isClass() &&
> +
> cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
> +
> vm->bootstrapLoader->clinitType,
> + true, false, 0))
> + res = true;
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +
> +// Redefine some VMObjectStreamClass functions because of a slow
> implementation
> +// in Classpath.
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jboolean val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceInt8Field(obj, (uint8)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jbyte val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceInt8Field(obj, (uint8)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jchar val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jshort val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceInt16Field(obj, (sint16)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jint val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceInt32Field(obj, (sint32)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jlong val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceLongField(obj, (sint64)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jfloat val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceFloatField(obj, (float)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jdouble val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceDoubleField(obj, (double)val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(val, 0);
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(obj);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + field->setInstanceObjectField(obj, val);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_io_VMObjectInputStream_allocateObject(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(target, 0);
> + llvm_gcroot(constr, 0);
> + llvm_gcroot(cons, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl =
> + (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
> + res = cl->doNew(vm);
> + JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> + meth->invokeIntSpecial(vm, cl, res);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_VMArray_createObjectArray(
> +#ifdef NATIVE_JNI
> +JNIEnv * env,
> +jclass thisClass,
> +#endif
> +JavaObject* arrayType, jint arrayLength) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(arrayType, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* base =
> + UserCommonClass::resolvedImplClass(vm, arrayType, true);
> + JnjvmClassLoader* loader = base->classLoader;
> + const UTF8* name = base->getName();
> + // -1 because we're adding a new dimension in this method.
> + const int kLimit = 255 - 1;
> + const uint16* elements = name->elements;
> + if (name->size > kLimit && elements[kLimit] == '[') {
> + vm->illegalArgumentException("Too many dimensions for array");
> + }
> + const UTF8* arrayName = loader->constructArrayName(1, name);
> + UserClassArray* array = loader->constructArray(arrayName, base);
> + res = array->doNew(arrayLength, vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +
> +// Never throws.
> +JNIEXPORT
> +bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + return false;
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> +
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(obj, 0);
> + jlong *ptr;
> + jlong value;
> +
> + ptr = (jlong *) (((uint8 *) obj) + offset);
> +
> + value = *ptr;
> +
> + if (value == expect) {
> + *ptr = update;
> + return true;
> + } else {
> + return false;
> + }
> +
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> +
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(obj, 0);
> + jint *ptr;
> +
> + ptr = (jint *) (((uint8 *) obj) + offset);
> +
> + return __sync_bool_compare_and_swap(ptr, expect, update);
> +}
> +
> +// Never throws.
> +JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> +JavaObject* update) {
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(expect, 0);
> + llvm_gcroot(update, 0);
> +
> + JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> +
> + return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> +}
> +
> +// Never throws.
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
> + llvm_gcroot(unsafe, 0);
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(value, 0);
> +
> + JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> + mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr,
> (gc*)value);
> +}
> +
> +// TODO: Add the Volatile variants
> +#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> +JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> +JavaObject* unsafe, JavaObject* base, jlong offset) { \
> + jtype res = 0; \
> + BEGIN_NATIVE_EXCEPTION(0) \
> + jtype* ptr = (jtype*) (((uint8 *) base) + offset); \
> + res = *ptr; \
> + END_NATIVE_EXCEPTION \
> + \
> + return res; \
> +} \
> + \
> +JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> __Ljava_lang_Object_2J ## shorttype( \
> +JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> + BEGIN_NATIVE_EXCEPTION(0) \
> + jtype* ptr = (jtype*) (((uint8 *) base) + offset); \
> + *ptr = val; \
> + END_NATIVE_EXCEPTION \
> +}
> +
> +GET_PUT_OFFSET(Boolean,jboolean,Z)
> +GET_PUT_OFFSET(Byte,jbyte,B)
> +GET_PUT_OFFSET(Char,jchar,C)
> +GET_PUT_OFFSET(Short,jshort,S)
> +GET_PUT_OFFSET(Int,jint,I)
> +GET_PUT_OFFSET(Long,jlong,J)
> +GET_PUT_OFFSET(Float,jfloat,F)
> +GET_PUT_OFFSET(Double,jdouble,D)
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc
> new file mode 100644
> index 0000000..8c506f4
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc
> @@ -0,0 +1,222 @@
> +//===- 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_Constructor_getParameterTypes(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectConstructor* cons) {
> +
> + JavaObject* res = 0;
> +
> + llvm_gcroot(cons, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(cons);
> + UserClass* cl = JavaObjectConstructor::getClass(cons);
> + JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> + JnjvmClassLoader* loader = cl->classLoader;
> +
> + res = meth->getParameterTypes(loader);
> + END_NATIVE_EXCEPTION
> +
> + return (jobject)res;
> +}
> +
> +JNIEXPORT jint JNICALL
> Java_java_lang_reflect_Constructor_getModifiersInternal(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectConstructor* cons) {
> +
> + llvm_gcroot(cons, 0);
> + jint res = 0;
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(cons);
> + JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> + res = meth->access;
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JavaObject* proceedConstructor(JavaObjectConstructor* cons,
> + ArrayObject* args,
> + JavaObject* Clazz, jint index)
> + __attribute__ ((noinline));
> +
> +JavaObject* proceedConstructor(JavaObjectConstructor* cons,
> + ArrayObject* args,
> + JavaObject* Clazz, jint index) {
> + JavaObject* res = 0;
> + JavaObject* excp = 0;
> +
> + llvm_gcroot(cons, 0);
> + llvm_gcroot(args, 0);
> + llvm_gcroot(Clazz, 0);
> + llvm_gcroot(res, 0);
> + llvm_gcroot(excp, 0);
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> + UserClass* cl = JavaObjectConstructor::getClass(cons);
> + sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
> + Signdef* sign = meth->getSignature();
> + sint32 size = sign->nbArguments;
> +
> + if (isAbstract(cl->access)) vm->instantiationException(cl);
> +
> + mvm::ThreadAllocator allocator;
> + // Allocate a buffer to store the arguments.
> + jvalue* buf = size ?
> + (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
> +
> + if (nbArgs == size) {
> + UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm,
> Clazz, false);
> + UserClass* cl = _cl->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 {
> + meth->invokeIntSpecialBuf(vm, cl, res, buf);
> + } CATCH {
> + excp = th->getJavaException();
> + } END_CATCH;
> + if (excp) {
> + if
> (JavaObject::getClass(excp)->isAssignableFrom(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_Constructor_constructNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectConstructor* cons, ArrayObject* args, JavaObject* Clazz,
> jint index) {
> +
> + JavaObject* res = 0;
> +
> + llvm_gcroot(res, 0);
> + llvm_gcroot(cons, 0);
> + llvm_gcroot(args, 0);
> + llvm_gcroot(Clazz, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + res = proceedConstructor(cons, args, Clazz, index);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT
> +ArrayObject* JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectConstructor* cons) {
> +
> + ArrayObject* res = 0;
> +
> + llvm_gcroot(res, 0);
> + llvm_gcroot(cons, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(cons);
> + UserClass* cl = JavaObjectConstructor::getClass(cons);
> + JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> + JnjvmClassLoader* loader = cl->classLoader;
> +
> + res = (ArrayObject*)meth->getExceptionTypes(loader);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_Constructor_getSignature(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectConstructor* Meth) {
> +
> + JavaObject* result = 0;
> +
> + llvm_gcroot(result, 0);
> + llvm_gcroot(Meth, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(Meth);
> + JavaMethod* meth = JavaObjectConstructor::getInternalMethod(Meth);
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + result = vm->internalUTF8ToStr(meth->type);
> +
> + END_NATIVE_EXCEPTION
> +
> + return result;
> +}
> +
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc
> new file mode 100644
> index 0000000..e56c82f
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc
> @@ -0,0 +1,1171 @@
> +//===- 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"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +
> +JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field) {
> + jint res = 0;
> +
> + llvm_gcroot(Field, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + res = field->access;
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_getType(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field) {
> +
> + JavaObject* res = 0;
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + JnjvmClassLoader* loader = cl->classLoader;
> + UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);
> + res = fieldCl->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jint res = 0;
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + const Typedef* type = field->getSignature();
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getLong(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jlong res = 0;
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getBoolean(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jboolean res = 0;
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getFloat(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jfloat res = 0;
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getByte(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jbyte res = 0;
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getChar(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jchar res = 0;
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getShort(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> +
> + jshort res = 0;
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_getDouble(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> + jdouble res = 0;
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_get(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj) {
> +
> +
> + JavaObject* res = 0;
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_set(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* 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();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + jvalue buf;
> + bool stat = isStatic(field->access);
> +
> +
> + if (stat) {
> + cl->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_Field_setBoolean(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jboolean val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setByte(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jbyte val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setChar(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jchar val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setShort(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jshort val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setInt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jint val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setLong(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jlong val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setFloat(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jfloat val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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_Field_setDouble(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectField* Field, JavaObject* obj, jdouble val) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = JavaObjectField::getClass(Field);
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + bool stat = isStatic(field->access);
> +
> + if (stat) {
> + cl->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
> +}
> +
> +// Never throws.
> +JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* Unsafe, JavaObjectField* Field) {
> +
> + llvm_gcroot(Field, 0);
> + llvm_gcroot(Unsafe, 0);
> +
> + JavaField* field = JavaObjectField::getInternalField(Field);
> + return (jlong)field->ptrOffset;
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc
> new file mode 100644
> index 0000000..fcfea1c
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc
> @@ -0,0 +1,304 @@
> +//===- ClasspathMethod.cpp
> ------------------------------------------------===//
> +//===------------- GNU classpath java/lang/reflect/Method
> -----------------===//
> +//
> +// 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_Method_getModifiersInternal(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectMethod* Meth) {
> +
> + jint res = 0;
> + llvm_gcroot(Meth, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> + res = meth->access;
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getReturnType(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectMethod* Meth) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(Meth, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + UserClass* cl = JavaObjectMethod::getClass(Meth);
> + JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> + JnjvmClassLoader* loader = cl->classLoader;
> + res = meth->getReturnType(loader);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_Method_getParameterTypes(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectMethod* Meth) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(Meth, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + UserClass* cl = JavaObjectMethod::getClass(Meth);
> + JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> + JnjvmClassLoader* loader = cl->classLoader;
> +
> + res = meth->getParameterTypes(loader);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
> + ArrayObject* args, JavaObject* Cl, jint index)
> + __attribute__((noinline));
> +
> +JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
> + ArrayObject* args, JavaObject* Cl, jint index) {
> +
> + JavaObject* res = 0;
> + JavaObject* exc = 0;
> +
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Meth, 0);
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(args, 0);
> + llvm_gcroot(Cl, 0);
> + llvm_gcroot(exc, 0);
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> +
> + JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> +
> + sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
> + Signdef* sign = meth->getSignature();
> + sint32 size = sign->nbArguments;
> +
> + mvm::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->isAssignableFrom(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_Method_invokeNative(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectMethod* Meth, JavaObject* obj, ArrayObject* args,
> JavaObject* Cl, jint index) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Meth, 0);
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(args, 0);
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + res = proceedMethod(Meth, obj, args, Cl, index);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT ArrayObject* JNICALL
> Java_java_lang_reflect_Method_getExceptionTypes(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectMethod* Meth) {
> +
> + ArrayObject* res = 0;
> + llvm_gcroot(Meth, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(Meth);
> + UserClass* cl = JavaObjectMethod::getClass(Meth);
> + JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> + JnjvmClassLoader* loader = cl->classLoader;
> + res = meth->getExceptionTypes(loader);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getSignature(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObjectMethod* Meth) {
> +
> + JavaObject* result = 0;
> + llvm_gcroot(Meth, 0);
> + llvm_gcroot(result, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(Meth);
> + JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + result = vm->internalUTF8ToStr(meth->type);
> +
> + END_NATIVE_EXCEPTION
> +
> + return result;
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> new file mode 100644
> index 0000000..3d69fa4
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp
> @@ -0,0 +1,30 @@
> +//===- 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 "ClasspathReflect.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaThread.h"
> +
> +namespace j3 {
> +
> +JavaMethod*
> JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*
> self) {
> + llvm_gcroot(self, 0);
> + UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
> + return &(cls->asClass()->virtualMethods[self->slot]);
> +}
> +
> +
> +JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
> + llvm_gcroot(self, 0);
> + UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
> + return &(cls->asClass()->virtualMethods[self->slot]);
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> new file mode 100644
> index 0000000..494e444
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h
> @@ -0,0 +1,222 @@
> +//===-- ClasspathReflect.h - 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.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef JNJVM_CLASSPATH_REFLECT_H
> +#define JNJVM_CLASSPATH_REFLECT_H
> +
> +#include "MvmGC.h"
> +
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaThread.h"
> +
> +extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);
> +
> +namespace j3 {
> +
> +class JavaObjectClass : public JavaObject {
> +private:
> + JavaObject* signers;
> + JavaObject* pd;
> + UserCommonClass* vmdata;
> + JavaObject* constructor;
> +
> +public:
> +
> + static UserCommonClass* getClass(JavaObjectClass* cl) {
> + llvm_gcroot(cl, 0);
> + return cl->vmdata;
> + }
> +
> + static void setClass(JavaObjectClass* cl, UserCommonClass* vmdata) {
> + llvm_gcroot(cl, 0);
> + cl->vmdata = vmdata;
> + }
> +
> + static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
> + llvm_gcroot(cl, 0);
> + llvm_gcroot(pd, 0);
> + mvm::Collector::objectReferenceWriteBarrier(
> + (gc*)cl, (gc**)&(cl->pd), (gc*)pd);
> + }
> +
> + static JavaObject* getProtectionDomain(JavaObjectClass* cl) {
> + llvm_gcroot(cl, 0);
> + return cl->pd;
> + }
> +
> + static void staticTracer(JavaObjectClass* obj, word_t closure) {
> + mvm::Collector::markAndTrace(obj, &obj->pd, closure);
> + mvm::Collector::markAndTrace(obj, &obj->signers, closure);
> + mvm::Collector::markAndTrace(obj, &obj->constructor, closure);
> + if (obj->vmdata) {
> + JavaObject** Obj =
> obj->vmdata->classLoader->getJavaClassLoaderPtr();
> + if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
> + }
> + }
> +};
> +
> +class JavaObjectField : public JavaObject {
> +private:
> + uint8 flag;
> + JavaObjectClass* declaringClass;
> + JavaObject* name;
> + uint32 slot;
> +
> +public:
> +
> + static void staticTracer(JavaObjectField* obj, word_t closure) {
> + mvm::Collector::markAndTrace(obj, &obj->name, closure);
> + mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
> + }
> +
> + static JavaField* getInternalField(JavaObjectField* self) {
> + llvm_gcroot(self, 0);
> + UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> + return &(cls->asClass()->virtualFields[self->slot]);
> + }
> +
> + static UserClass* getClass(JavaObjectField* self) {
> + llvm_gcroot(self, 0);
> + UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> + return cls->asClass();
> + }
> +
> +};
> +
> +class JavaObjectMethod : public JavaObject {
> +private:
> + uint8 flag;
> + JavaObjectClass* declaringClass;
> + JavaObject* name;
> + uint32 slot;
> +
> +public:
> +
> + static void staticTracer(JavaObjectMethod* obj, word_t closure) {
> + mvm::Collector::markAndTrace(obj, &obj->name, closure);
> + mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
> + }
> +
> + static JavaMethod* getInternalMethod(JavaObjectMethod* self);
> +
> + static UserClass* getClass(JavaObjectMethod* self) {
> + llvm_gcroot(self, 0);
> + UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> + return cls->asClass();
> + }
> +
> +};
> +
> +class JavaObjectConstructor : public JavaObject {
> +private:
> + uint8 flag;
> + JavaObjectClass* declaringClass;
> + uint32 slot;
> +
> +public:
> + static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
> + mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
> + }
> +
> + static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
> +
> + static UserClass* getClass(JavaObjectConstructor* self) {
> + llvm_gcroot(self, 0);
> + UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> + return cls->asClass();
> + }
> +
> +};
> +
> +class JavaObjectVMThread : public JavaObject {
> +private:
> + JavaObject* thread;
> + bool running;
> + JavaThread* vmdata;
> +
> +public:
> + static void staticTracer(JavaObjectVMThread* obj, word_t closure) {
> + mvm::Collector::markAndTrace(obj, &obj->thread, closure);
> + }
> +
> + static void setVmdata(JavaObjectVMThread* vmthread,
> + JavaThread* internal_thread) {
> + llvm_gcroot(vmthread, 0);
> + vmthread->vmdata = internal_thread;
> + }
> +
> +};
> +
> +
> +class JavaObjectThrowable : public JavaObject {
> +private:
> + JavaObject* detailedMessage;
> + JavaObject* cause;
> + JavaObject* stackTrace;
> + JavaObject* vmState;
> +
> +public:
> +
> + static void setDetailedMessage(JavaObjectThrowable* self, JavaObject*
> obj) {
> + llvm_gcroot(self, 0);
> + llvm_gcroot(obj, 0);
> + mvm::Collector::objectReferenceWriteBarrier(
> + (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
> + }
> +
> + static void fillInStackTrace(JavaObjectThrowable* self) {
> + JavaObject* stackTrace = NULL;
> + llvm_gcroot(self, 0);
> + llvm_gcroot(stackTrace, 0);
> +
> + stackTrace = internalFillInStackTrace(self);
> + mvm::Collector::objectReferenceWriteBarrier(
> + (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
> +
> + mvm::Collector::objectReferenceWriteBarrier(
> + (gc*)self, (gc**)&(self->cause), (gc*)self);
> +
> + self->stackTrace = NULL;
> + }
> +};
> +
> +class JavaObjectReference : public JavaObject {
> +private:
> + JavaObject* referent;
> + JavaObject* queue;
> + JavaObject* nextOnQueue;
> +
> +public:
> + static void init(JavaObjectReference* self, JavaObject* r, JavaObject*
> q) {
> + llvm_gcroot(self, 0);
> + llvm_gcroot(r, 0);
> + llvm_gcroot(q, 0);
> + mvm::Collector::objectReferenceWriteBarrier(
> + (gc*)self, (gc**)&(self->referent), (gc*)r);
> + mvm::Collector::objectReferenceWriteBarrier(
> + (gc*)self, (gc**)&(self->queue), (gc*)q);
> + }
> +
> + static JavaObject** getReferentPtr(JavaObjectReference* self) {
> + llvm_gcroot(self, 0);
> + return &(self->referent);
> + }
> +
> + static void setReferent(JavaObjectReference* self, JavaObject* r) {
> + llvm_gcroot(self, 0);
> + llvm_gcroot(r, 0);
> + // No write barrier: this is only called by the GC.
> + self->referent = r;
> + }
> +};
> +
> +}
> +
> +#endif
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> new file mode 100644
> index 0000000..26fa36a
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc
> @@ -0,0 +1,645 @@
> +//===---- ClasspathVMClass.cpp - GNU classpath java/lang/VMClass
> ----------===//
> +//
> +// 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 "JavaAccess.h"
> +#include "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaString.h"
> +#include "JavaTypes.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +// Never throws
> +JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObjectClass* klass) {
> +
> + llvm_gcroot(klass, 0);
> +
> + UserCommonClass* cl = JavaObjectClass::getClass(klass);
> +
> + return cl->isArray();
> +
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_forName(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaString* str,
> +jboolean clinit,
> +JavaObject* loader) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(loader, 0);
> + llvm_gcroot(str, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(str);
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JnjvmClassLoader* JCL =
> + JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> + UserCommonClass* cl = JCL->loadClassFromJavaString(str, true, false);
> +
> + if (cl != NULL && !cl->isPrimitive()) {
> + if (clinit && cl->asClass()) {
> + cl->asClass()->initialiseClass(vm);
> + }
> + res = cl->getClassDelegatee(vm);
> + } else {
> + vm->classNotFoundException(str);
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_VMClass_getDeclaredConstructors(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +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++;
> + }
> + }
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return ret;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredMethods(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +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++;
> + }
> + }
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return ret;
> +}
> +
> +JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl,
> +jboolean ignore) {
> +
> + jint res = 0;
> + llvm_gcroot(Cl, 0);
> +
> + 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;
> + }
> +
> + END_NATIVE_EXCEPTION
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getName(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + JavaObject* result = 0;
> + llvm_gcroot(Cl, 0);
> + llvm_gcroot(result, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> + const UTF8* iname = cl->getName();
> + result = JavaString::internalToJava(iname, vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return result;
> +}
> +
> +JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + jboolean res = 0;
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> + res = cl->isPrimitive();
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + jboolean res = 0;
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> + res = cl->isInterface();
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getComponentType(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Cl, 0);
> +
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> + if (cl->isArray()) {
> + UserCommonClass* bc = cl->asArrayClass()->baseClass();
> + res = bc->getClassDelegatee(vm);
> + } else {
> + res = 0;
> + }
> +
> + END_NATIVE_EXCEPTION
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getClassLoader(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> + res = cl->classLoader->getJavaClassLoader();
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl1, JavaObject* Cl2) {
> +
> + jboolean res = 0;
> + llvm_gcroot(Cl1, 0);
> + llvm_gcroot(Cl2, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + if (!Cl2) vm->nullPointerException();
> +
> + UserCommonClass* cl1 = UserCommonClass::resolvedImplClass(vm, Cl1,
> false);
> + UserCommonClass* cl2 = UserCommonClass::resolvedImplClass(vm, Cl2,
> false);
> +
> + res = cl2->isAssignableFrom(cl1);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getSuperclass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(Cl, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> + if (cl->isInterface()) res = 0;
> + else {
> + if (cl->getSuper()) res = cl->getSuper()->getClassDelegatee(vm);
> + else res = 0;
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl, JavaObject* obj) {
> +
> + bool res = false;
> + llvm_gcroot(Cl, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> + res = JavaObject::instanceOf(obj, cl);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredFields(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +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++;
> + }
> + }
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return ret;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getInterfaces(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + ArrayObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Cl, 0);
> +
> + 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);
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaringClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> + JavaObject* res = 0;
> +
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Cl, 0);
> +
> + 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);
> + }
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredClasses(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl, bool publicOnly) {
> +
> + ArrayObject* result = 0;
> + llvm_gcroot(result, 0);
> + llvm_gcroot(Cl, 0);
> +
> + 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);
> + }
> +
> +
> + END_NATIVE_EXCEPTION
> +
> + return result;
> +
> +}
> +
> +// Only throws.
> +JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* throwable) {
> +
> + llvm_gcroot(throwable, 0);
> +
> + assert(throwable && "Using internal VM throw exception without
> exception");
> + JavaThread::get()->pendingException = (JavaObject*)throwable;
> +}
> +
> +JNIEXPORT ArrayObject* Java_java_lang_VMClass_getDeclaredAnnotations(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +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);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT jboolean Java_java_lang_VMClass_isAnonymousClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + jboolean res = false;
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> +
> + if (cl) res = cl->isAnonymous;
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc
> new file mode 100644
> index 0000000..8a57db4
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc
> @@ -0,0 +1,380 @@
> +//===- ClasspathVMClassLoader.cpp - GNU classpath
> java/lang/VMClassLoader -===//
> +//
> +// 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 "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaString.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +#include "Reader.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_VMClassLoader_getPrimitiveClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +jchar byteId) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClassPrimitive* prim =
> + UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls);
> +
> + if (!prim) {
> + fprintf(stderr, "unknown byte primitive %c", byteId);
> + abort();
> + }
> +
> + res = prim->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_java_lang_VMClassLoader_findLoadedClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* loader,
> +JavaString* name) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(loader, 0);
> + llvm_gcroot(name, 0);
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JnjvmClassLoader* JCL =
> + JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> + UserCommonClass* cl = JCL->lookupClassFromJavaString(name);
> +
> + if (cl) res = cl->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +
> + return 0;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_loadClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaString* str,
> +jboolean doResolve) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(str, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> +
> + JnjvmClassLoader* JCL = vm->bootstrapLoader;
> + UserCommonClass* cl = JCL->loadClassFromJavaString(str, doResolve,
> false);
> +
> + if (cl != 0) res = cl->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_defineClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* loader,
> +JavaString* str,
> +ArrayUInt8* bytes,
> +jint off,
> +jint len,
> +JavaObject* pd) {
> +
> + JavaObject* res = 0;
> + JavaObject* excp = 0;
> + llvm_gcroot(loader, 0);
> + llvm_gcroot(str, 0);
> + llvm_gcroot(bytes, 0);
> + llvm_gcroot(pd, 0);
> + llvm_gcroot(res, 0);
> + llvm_gcroot(excp, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + // We need a name, which is unfortunately not required by the spec.
> + verifyNull(str);
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> +
> + JnjvmClassLoader* JCL =
> + JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> +
> + int32_t size = JavaArray::getSize(bytes);
> + ClassBytes* classBytes = new (JCL->allocator, size) ClassBytes(size);
> + memcpy(classBytes->elements, JavaArray::getElements(bytes), size);
> +
> + // Before creating a class, do a check on the bytes.
> + Reader reader(classBytes);
> + uint32 magic = reader.readU4();
> + if (magic != Jnjvm::Magic) {
> + JavaThread::get()->getJVM()->classFormatError("bad magic number");
> + }
> +
> +
> + const UTF8* name = JavaString::javaToInternal(str, JCL->hashUTF8);
> + UserCommonClass* cl = JCL->lookupClass(name);
> +
> + if (!cl) {
> + UserClass* cl = JCL->constructClass(name, classBytes);
> + cl->resolveClass();
> +
> + res = cl->getClassDelegatee(vm, pd);
> + } else {
> + excp = vm->CreateLinkageError("duplicate class definition");
> + JavaThread::get()->throwException(excp);
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + verifyNull(Cl);
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass::resolvedImplClass(vm, Cl, false);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +#define NUM_BOOT_PACKAGES 168
> +
> +static const char* bootPackages[NUM_BOOT_PACKAGES] = {
> + "java.applet",
> + "java.awt",
> + "java.awt.color",
> + "java.awt.datatransfer",
> + "java.awt.dnd",
> + "java.awt.dnd.peer",
> + "java.awt.event",
> + "java.awt.font",
> + "java.awt.geom",
> + "java.awt.im",
> + "java.awt.im.spi",
> + "java.awt.image",
> + "java.awt.image.renderable",
> + "java.awt.peer",
> + "java.awt.print",
> + "java.beans",
> + "java.beans.beancontext",
> + "java.io",
> + "java.lang",
> + "java.lang.annotation",
> + "java.lang.instrument",
> + "java.lang.management",
> + "java.lang.ref",
> + "java.lang.reflect",
> + "java.math",
> + "java.net",
> + "java.nio",
> + "java.nio.channels",
> + "java.nio.channels.spi",
> + "java.nio.charset",
> + "java.nio.charset.spi",
> + "java.rmi",
> + "java.rmi.activation",
> + "java.rmi.dgc",
> + "java.rmi.registry",
> + "java.rmi.server",
> + "java.security",
> + "java.security.acl",
> + "java.security.cert",
> + "java.security.interfaces",
> + "java.security.spec",
> + "java.sql",
> + "java.text",
> + "java.util",
> + "java.util.concurrent",
> + "java.util.concurrent.atomic",
> + "java.util.concurrent.locks",
> + "java.util.jar",
> + "java.util.logging",
> + "java.util.prefs",
> + "java.util.regex",
> + "java.util.zip",
> + "javax.accessibility",
> + "javax.activity",
> + "javax.crypto",
> + "javax.crypto.interfaces",
> + "javax.crypto.spec",
> + "javax.imageio",
> + "javax.imageio.event",
> + "javax.imageio.metadata",
> + "javax.imageio.plugins.bmp",
> + "javax.imageio.plugins.jpeg",
> + "javax.imageio.spi",
> + "javax.imageio.stream",
> + "javax.management",
> + "javax.management.loading",
> + "javax.management.modelmbean",
> + "javax.management.monitor",
> + "javax.management.openmbean",
> + "javax.management.relation",
> + "javax.management.remote",
> + "javax.management.remote.rmi",
> + "javax.management.timer",
> + "javax.naming",
> + "javax.naming.directory",
> + "javax.naming.event",
> + "javax.naming.ldap",
> + "javax.naming.spi",
> + "javax.net",
> + "javax.net.ssl",
> + "javax.print",
> + "javax.print.attribute",
> + "javax.print.attribute.standard",
> + "javax.print.event",
> + "javax.rmi",
> + "javax.rmi.CORBA",
> + "javax.rmi.ssl",
> + "javax.security.auth",
> + "javax.security.auth.callback",
> + "javax.security.auth.kerberos",
> + "javax.security.auth.login",
> + "javax.security.auth.spi",
> + "javax.security.auth.x500",
> + "javax.security.cert",
> + "javax.security.sasl",
> + "javax.sound.midi",
> + "javax.sound.midi.spi",
> + "javax.sound.sampled",
> + "javax.sound.sampled.spi",
> + "javax.sql",
> + "javax.sql.rowset",
> + "javax.sql.rowset.serial",
> + "javax.sql.rowset.spi",
> + "javax.swing",
> + "javax.swing.border",
> + "javax.swing.colorchooser",
> + "javax.swing.event",
> + "javax.swing.filechooser",
> + "javax.swing.plaf",
> + "javax.swing.plaf.basic",
> + "javax.swing.plaf.metal",
> + "javax.swing.plaf.multi",
> + "javax.swing.plaf.synth",
> + "javax.swing.table",
> + "javax.swing.text",
> + "javax.swing.text.html",
> + "javax.swing.text.html.parser",
> + "javax.swing.text.rtf",
> + "javax.swing.tree",
> + "javax.swing.undo",
> + "javax.transaction",
> + "javax.transaction.xa",
> + "javax.xml",
> + "javax.xml.datatype",
> + "javax.xml.namespace",
> + "javax.xml.parsers",
> + "javax.xml.transform",
> + "javax.xml.transform.dom",
> + "javax.xml.transform.sax",
> + "javax.xml.transform.stream",
> + "javax.xml.validation",
> + "javax.xml.xpath",
> + "org.ietf.jgss",
> + "org.omg.CORBA",
> + "org.omg.CORBA_2_3",
> + "org.omg.CORBA_2_3.portable",
> + "org.omg.CORBA.DynAnyPackage",
> + "org.omg.CORBA.ORBPackage",
> + "org.omg.CORBA.portable",
> + "org.omg.CORBA.TypeCodePackage",
> + "org.omg.CosNaming",
> +
> "org.omg.CosNaming.NamingContextExtPackage",
> + "org.omg.CosNaming.NamingContextPackage",
> + "org.omg.Dynamic",
> + "org.omg.DynamicAny",
> + "org.omg.DynamicAny.DynAnyFactoryPackage",
> + "org.omg.DynamicAny.DynAnyPackage",
> + "org.omg.IOP",
> + "org.omg.IOP.CodecFactoryPackage",
> + "org.omg.IOP.CodecPackage",
> + "org.omg.Messaging",
> + "org.omg.PortableInterceptor",
> +
> "org.omg.PortableInterceptor.ORBInitInfoPackage",
> + "org.omg.PortableServer",
> + "org.omg.PortableServer.CurrentPackage",
> + "org.omg.PortableServer.POAManagerPackage",
> + "org.omg.PortableServer.POAPackage",
> + "org.omg.PortableServer.portable",
> +
> "org.omg.PortableServer.ServantLocatorPackage",
> + "org.omg.SendingContext",
> + "org.omg.stub.java.rmi",
> + "org.w3c.dom",
> + "org.w3c.dom.bootstrap",
> + "org.w3c.dom.events",
> + "org.w3c.dom.ls",
> + "org.xml.sax",
> + "org.xml.sax.ext",
> + "org.xml.sax.helpers"
> +};
> +
> +extern "C" ArrayObject* Java_java_lang_VMClassLoader_getBootPackages__() {
> + ArrayObject* obj = 0;
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + obj = (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES,
> vm);
> + for (uint32 i = 0; i < NUM_BOOT_PACKAGES; ++i) {
> + ArrayObject::setElement(obj, vm->asciizToStr(bootPackages[i]), i);
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return obj;
> +}
> +
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> new file mode 100644
> index 0000000..c71fb5b
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc
> @@ -0,0 +1,170 @@
> +//===------ ClasspathVMObject.cpp - GNU classpath java/lang/VMObject
> ------===//
> +//
> +// 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 "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaThread.h"
> +#include "Jnjvm.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_clone(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* src) {
> +
> + JavaObject* res = NULL;
> + JavaObject* tmp = NULL;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(src, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + UserCommonClass* cl = JavaObject::getClass(src);
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + if (cl->isArray()) {
> + UserClassArray* array = cl->asArrayClass();
> + int length = JavaArray::getSize(src);
> + res = array->doNew(length, vm);
> + UserCommonClass* base = array->baseClass();
> + if (base->isPrimitive()) {
> + int size = length << base->asPrimitiveClass()->logSize;
> + memcpy((void*)((uintptr_t)res + sizeof(JavaObject) +
> sizeof(size_t)),
> + (void*)((uintptr_t)src + sizeof(JavaObject) +
> sizeof(size_t)),
> + size);
> + } else {
> + for (int i = 0; i < length; i++) {
> + tmp = ArrayObject::getElement((ArrayObject*)src, i);
> + ArrayObject::setElement((ArrayObject*)res, tmp, i);
> + }
> + }
> + } else {
> + assert(cl->isClass() && "Not a class!");
> + res = cl->asClass()->doNew(vm);
> + while (cl != NULL) {
> + for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
> + JavaField& field = cl->asClass()->virtualFields[i];
> + if (field.isReference()) {
> + tmp = field.getInstanceObjectField(src);
> + JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
> + mvm::Collector::objectReferenceWriteBarrier((gc*)res,
> (gc**)ptr, (gc*)tmp);
> + } else if (field.isLong()) {
> + field.setInstanceLongField(res,
> field.getInstanceLongField(src));
> + } else if (field.isDouble()) {
> + field.setInstanceDoubleField(res,
> field.getInstanceDoubleField(src));
> + } else if (field.isInt()) {
> + field.setInstanceInt32Field(res,
> field.getInstanceInt32Field(src));
> + } else if (field.isFloat()) {
> + field.setInstanceFloatField(res,
> field.getInstanceFloatField(src));
> + } else if (field.isShort() || field.isChar()) {
> + field.setInstanceInt16Field(res,
> field.getInstanceInt16Field(src));
> + } else if (field.isByte() || field.isBoolean()) {
> + field.setInstanceInt8Field(res,
> field.getInstanceInt8Field(src));
> + } else {
> + UNREACHABLE();
> + }
> + }
> + cl = cl->super;
> + }
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_getClass(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* obj) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + res = JavaObject::getClass(obj)->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* obj) {
> +
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObject::notifyAll(obj);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMObject_wait(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* obj, jlong ms, jint ns) {
> +
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + uint32 sec = (uint32) (ms / 1000);
> + uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
> + if (ns && !usec) usec = 1;
> + if (sec || usec) {
> + struct timeval t;
> + t.tv_sec = sec;
> + t.tv_usec = usec;
> + JavaObject::timedWait(obj, t);
> + } else {
> + JavaObject::wait(obj);
> + }
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMObject_notify(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* obj) {
> +
> + llvm_gcroot(obj, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObject::notify(obj);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
> new file mode 100644
> index 0000000..3a39c4f
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc
> @@ -0,0 +1,228 @@
> +//===------ ClasspathVMRuntime.cpp - GNU classpath
> java/lang/VMRuntime ----===//
> +//
> +// The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +
> +#include "MvmGC.h"
> +
> +#include "types.h"
> +
> +#include "Classpath.h"
> +#include "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaString.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +#include <cstring>
> +#include <unistd.h>
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMRuntime_mapLibraryName(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaString* strLib) {
> +
> + JavaObject* res = 0;
> + ArrayUInt16* array = 0;
> + const ArrayUInt16* utf8Lib = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(array, 0);
> + llvm_gcroot(utf8Lib, 0);
> + llvm_gcroot(strLib, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> +
> + utf8Lib = JavaString::getValue(strLib);
> + uint32 stLib = strLib->offset;
> + sint32 lgLib = strLib->count;
> + sint32 lgPre = vm->bootstrapLoader->prelib->size;
> + sint32 lgPost = vm->bootstrapLoader->postlib->size;
> +
> + uint32 size = (uint32)(lgPre + lgLib + lgPost);
> + array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
> + uint16* elements = ArrayUInt16::getElements(array);
> +
> + memmove(elements, vm->bootstrapLoader->prelib->elements,
> + lgPre * sizeof(uint16));
> + memmove(&(elements[lgPre]), ArrayUInt16::getElements(utf8Lib) + stLib,
> + lgLib * sizeof(uint16));
> + memmove(&(elements[lgPre + lgLib]),
> vm->bootstrapLoader->postlib->elements,
> + lgPost * sizeof(uint16));
> +
> + res = vm->constructString(array);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +
> +}
> +
> +typedef int (*onLoad_t)(const void**, void*);
> +extern "C" void j3EndJNI(uint32** old);
> +extern "C" void j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame*
> Frame);
> +
> +extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)
> + __attribute__ ((noinline));
> +
> +extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm)
> + __attribute__ ((noinline));
> +
> +extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm) {
> + func(&vm->javavmEnv, res);
> + return 1;
> +}
> +
> +// Calls the JNI_OnLoad function of a dynamic library.
> +extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)
> {
> +
> + onLoad_t onLoad = (onLoad_t)loader->loadInLib("JNI_OnLoad", res);
> +
> + if (onLoad) {
> + uint32 num = 0;
> + uint32* old = 0;
> + mvm::KnownFrame Frame;
> +
> + j3StartJNI(&num, &old, &Frame);
> + doCall(onLoad, res, vm);
> + j3EndJNI(&old);
> + }
> +}
> +
> +// Never throws.
> +JNIEXPORT jint JNICALL Java_java_lang_VMRuntime_nativeLoad(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaString* str,
> +JavaObject* javaLoader) {
> +
> +
> + llvm_gcroot(str, 0);
> + llvm_gcroot(javaLoader, 0);
> +
> + void* res = 0;
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JnjvmClassLoader* loader =
> + JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);
> +
> + mvm::ThreadAllocator allocator;
> + char* buf = JavaString::strToAsciiz(str, &allocator);
> +
> + res = loader->loadLib(buf);
> +
> + if (res) callOnLoad(res, loader, vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res != 0;
> +}
> +
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMRuntime_gc(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + mvm::Collector::collect();
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + mvm::Collector::collect();
> + // Sleep a bit.
> + sleep(1);
> + return;
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizationForExit(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + return;
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizersOnExit(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +uint8 value
> +) {
> + return;
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMRuntime_exit(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +jint par1) {
> + mvm::System::Exit(par1);
> +}
> +
> +JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + return (jlong)mvm::Collector::getFreeMemory();
> +}
> +
> +JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + return (jlong)mvm::Collector::getTotalMemory();
> +}
> +
> +JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + return (jlong)mvm::Collector::getMaxMemory();
> +}
> +
> +JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> + return mvm::System::GetNumberOfProcessors();
> +}
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> new file mode 100644
> index 0000000..361ec45
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc
> @@ -0,0 +1,86 @@
> +//===- ClasspathVMStackWalker.cpp
> -----------------------------------------===//
> +//===------------ GNU classpath gnu/classpath/VMStackWalker
> ---------------===//
> +//
> +// 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 "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_gnu_classpath_VMStackWalker_getClassContext(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> +
> + ArrayObject* result = NULL;
> + JavaObject* delegatee = NULL;
> + llvm_gcroot(result, 0);
> + llvm_gcroot(delegatee, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaThread* th = JavaThread::get();
> + Jnjvm* vm = th->getJVM();
> + uint32 length = th->getFrameContextLength();
> +
> + mvm::ThreadAllocator allocator;
> + uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> +
> + uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> +
> + result = (ArrayObject*)
> + vm->upcalls->stackTraceArray->doNew(finalSize, vm);
> +
> + for (uint32 i = 0; i != finalSize; ++i) {
> + JavaMethod* meth = ((JavaMethod**)buffer)[i];
> + assert(meth && "Wrong stack trace");
> + delegatee = meth->classDef->getClassDelegatee(vm);;
> + ArrayObject::setElement(result, delegatee, i);
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return result;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL
> Java_gnu_classpath_VMStackWalker_getClassLoader(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* Cl) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(Cl, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> + res = cl->classLoader->getJavaClassLoader();
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> new file mode 100644
> index 0000000..38bc9ec
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc
> @@ -0,0 +1,119 @@
> +//===-- ClasspathVMSystem.cpp - GNU classpath java/lang/VMSystem
> ----------===//
> +//
> +// 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 "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaThread.h"
> +#include "Jnjvm.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass _cl,
> +#endif
> +JavaObject* src,
> +jint sstart,
> +JavaObject* dst,
> +jint dstart,
> +jint len) {
> +
> + JavaObject* cur = 0;
> + llvm_gcroot(src, 0);
> + llvm_gcroot(dst, 0);
> + llvm_gcroot(cur, 0);
> + assert(src->getVirtualTable());
> + assert(dst->getVirtualTable());
> +
> + JavaThread* th = JavaThread::get();
> + Jnjvm *vm = th->getJVM();
> +
> + if (src == NULL || dst == NULL) {
> + th->pendingException = vm->CreateNullPointerException();
> + return;
> + }
> +
> + if (!(JavaObject::getClass(src)->isArray() &&
> + JavaObject::getClass(dst)->isArray())) {
> + th->pendingException = vm->CreateArrayStoreException(
> + (JavaVirtualTable*)dst->getVirtualTable());
> + return;
> + }
> +
> + UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
> + UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
> + UserCommonClass* dstType = td->baseClass();
> + UserCommonClass* srcType = ts->baseClass();
> +
> + sint32 srcSize = JavaArray::getSize(src);
> + sint32 dstSize = JavaArray::getSize(dst);
> +
> + if (len > srcSize) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(len);
> + } else if (len > dstSize) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(len);
> + } else if (len + sstart > srcSize) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(len +
> sstart);
> + } else if (len + dstart > dstSize) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(len +
> dstart);
> + } else if (dstart < 0) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(dstart);
> + } else if (sstart < 0) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(sstart);
> + } else if (len < 0) {
> + th->pendingException = vm->CreateIndexOutOfBoundsException(len);
> + } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&
> + srcType != dstType) {
> + th->pendingException = vm->CreateArrayStoreException(
> + (JavaVirtualTable*)dst->getVirtualTable());
> + }
> + if (th->pendingException != NULL) return;
> +
> + if (!(dstType->isPrimitive())) {
> + for (int i = 0; i < len; i++) {
> + cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
> + if (cur) {
> + if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
> + th->pendingException = vm->CreateArrayStoreException(
> + (JavaVirtualTable*)dst->getVirtualTable());
> + break;
> + } else {
> + ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
> + }
> + }
> + }
> + } else {
> + uint32 logSize = dstType->asPrimitiveClass()->logSize;
> + void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) +
> (dstart << logSize));
> + void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) +
> (sstart << logSize));
> + memmove(ptrDst, ptrSrc, len << logSize);
> + }
> +
> +}
> +
> +JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* obj) {
> +
> + llvm_gcroot(obj, 0);
> + if (obj == NULL) return 0;
> + return JavaObject::hashCode(obj);
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc
> new file mode 100644
> index 0000000..7e9e5c1
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc
> @@ -0,0 +1,154 @@
> +//===- ClasspathVMSystem/Properties.cpp
> -----------------------------------===//
> +//===--------------------- GNU classpath
> gnu/classpath/VMSystemProperties -===//
> +//
> +// The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#include <sys/utsname.h>
> +
> +#include "types.h"
> +
> +#include "Classpath.h"
> +#include "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +void setProperty(Jnjvm* vm, JavaObject* prop, const char* key,
> + const char* val) {
> +
> + JavaString* Val = 0;
> + JavaString* Key = 0;
> + llvm_gcroot(prop, 0);
> + llvm_gcroot(Val, 0);
> + llvm_gcroot(Key, 0);
> +
> + Val = vm->asciizToStr(val);
> + Key = vm->asciizToStr(key);
> +
> + vm->upcalls->setProperty->invokeIntSpecial(
> + vm, (UserClass*)JavaObject::getClass(prop), prop, &Key, &Val);
> +}
> +
> +void setUnameProp(Jnjvm* vm, JavaObject* prop) {
> +
> + llvm_gcroot(prop, 0);
> +
> + struct utsname infos;
> + uname(&infos);
> + setProperty(vm, prop, "os.name", infos.sysname);
> + setProperty(vm, prop, "os.arch", infos.machine);
> + setProperty(vm, prop, "os.version", infos.release);
> + if (!strcmp(infos.machine, "ppc")) {
> + setProperty(vm, prop, "gnu.cpu.endian","big");
> + } else {
> + setProperty(vm, prop, "gnu.cpu.endian","little");
> + }
> +}
> +
> +JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* prop) {
> +
> + llvm_gcroot(prop, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + const char* tmp;
> + setProperty(vm, prop, "java.vm.specification.version", "1.0");
> + setProperty(vm, prop, "java.vm.specification.vendor",
> + "Sun Microsystems, Inc");
> + setProperty(vm, prop, "java.vm.specification.name",
> + "Java Virtual Machine Specification");
> + setProperty(vm, prop, "java.specification.version", "1.5");
> + setProperty(vm, prop, "java.specification.vendor", "Sun Microsystems,
> Inc");
> + setProperty(vm, prop, "java.specification.name",
> + "Java Platform API Specification");
> + setProperty(vm, prop, "java.version", "1.5");
> + setProperty(vm, prop, "java.runtime.version", "1.5");
> + setProperty(vm, prop, "java.vendor", "The VMKit Project");
> + setProperty(vm, prop, "java.vendor.url", "http://vmkit.llvm.org");
> +
> + tmp = getenv("JAVA_HOME");
> + if (!tmp) tmp = "";
> + setProperty(vm, prop, "java.home", tmp);
> +
> + JnjvmBootstrapLoader* JCL = vm->bootstrapLoader;
> + setProperty(vm, prop, "java.class.version", "49.0");
> + setProperty(vm, prop, "java.class.path", vm->classpath);
> + setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv);
> + setProperty(vm, prop, "sun.boot.class.path", JCL->bootClasspathEnv);
> + setProperty(vm, prop, "java.vm.version", "0.28");
> + setProperty(vm, prop, "java.vm.vendor", "The VMKit Project");
> + setProperty(vm, prop, "java.vm.name", "J3");
> + setProperty(vm, prop, "java.specification.version", "1.5");
> + setProperty(vm, prop, "java.io.tmpdir", "/tmp");
> +
> + tmp = getenv("JAVA_COMPILER");
> + if (!tmp) tmp = "gcj";
> + setProperty(vm, prop, "java.compiler", tmp);
> +
> + setProperty(vm, prop, "build.compiler", "gcj");
> + setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv);
> + setProperty(vm, prop, "gnu.classpath.boot.library.path",
> + JCL->libClasspathEnv);
> +
> + setUnameProp(vm, prop);
> +
> + setProperty(vm, prop, "file.separator", vm->dirSeparator);
> + setProperty(vm, prop, "path.separator", vm->envSeparator);
> + setProperty(vm, prop, "line.separator", "\n");
> +
> + tmp = getenv("USERNAME");
> + if (!tmp) tmp = getenv("LOGNAME");
> + if (!tmp) tmp = getenv("NAME");
> + if (!tmp) tmp = "";
> + setProperty(vm, prop, "user.name", tmp);
> +
> + tmp = getenv("HOME");
> + if (!tmp) tmp = "";
> + setProperty(vm, prop, "user.home", tmp);
> +
> + tmp = getenv("PWD");
> + if (!tmp) tmp = "";
> + setProperty(vm, prop, "user.dir", tmp);
> +
> + // Disable this property. The Classpath iconv implementation is really
> + // not optimized (it over-abuses JNI calls).
> + //setProperty(vm, prop, "gnu.classpath.nio.charset.provider.iconv",
> "true");
> + setProperty(vm, prop, "file.encoding", "ISO8859_1");
> + setProperty(vm, prop, "gnu.java.util.zoneinfo.dir",
> "/usr/share/zoneinfo");
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +extern "C" void
>
> Java_gnu_classpath_VMSystemProperties_postInit__Ljava_util_Properties_2(JavaObject*
> prop) {
> +
> + llvm_gcroot(prop, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + for (std::vector<std::pair<char*, char*> >::iterator i =
> + vm->postProperties.begin(), e = vm->postProperties.end(); i!= e;
> i++) {
> + setProperty(vm, prop, i->first, i->second);
> + }
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
> new file mode 100644
> index 0000000..da283d0
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc
> @@ -0,0 +1,217 @@
> +//===- ClasspathVMThread.cpp - GNU classpath java/lang/VMThread
> -----------===//
> +//
> +// 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 "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +// Never throws.
> +// Never calls Java code.
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThread_currentThread(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz
> +#endif
> +) {
> + return JavaThread::get()->currentThread();
> +}
> +
> +void start(JavaThread* thread) {
> +
> + JavaObjectVMThread* vmThread = NULL;
> + JavaObject* javaThread = NULL;
> + llvm_gcroot(vmThread, 0);
> + llvm_gcroot(javaThread, 0);
> +
> + Jnjvm* vm = thread->getJVM();
> + // Wait some time to let the creator initialise these fields.
> + while ((thread->javaThread == NULL) || (thread->vmThread == NULL)) {
> + mvm::Thread::yield();
> + }
> +
> + // Ok, now that the thread is created we can set the the value of
> vmdata,
> + // which is the JavaThread object.
> + vmThread = (JavaObjectVMThread*)thread->vmThread;
> + assert(vmThread && "Didn't fix the vmThread of a j3 thread");
> + assert(vmThread->getVirtualTable());
> + JavaObjectVMThread::setVmdata(vmThread, thread);
> +
> + UserClass* vmthClass = (UserClass*)JavaObject::getClass(vmThread);
> +
> + javaThread = thread->javaThread;
> + assert(javaThread && "Didn't fix the javaThread of a j3 thread");
> + // If the thread is not a daemon, it is added to the list of threads to
> + // wait until exit.
> + bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);
> +
> + if (!isDaemon) {
> + vm->threadSystem.enter();
> + }
> +
> + assert(vmThread->getVirtualTable());
> + assert(javaThread->getVirtualTable());
> + // Run the VMThread::run function
> + vm->upcalls->runVMThread->invokeIntSpecial(vm, vmthClass, vmThread);
> +
> + // Remove the thread from the list.
> + if (!isDaemon) {
> + vm->threadSystem.leave();
> + }
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMThread_start(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* vmThread, sint64 stackSize) {
> +
> + JavaObject* javaThread = 0;
> + llvm_gcroot(vmThread, 0);
> + llvm_gcroot(javaThread, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> +
> + // Classpath has set this field.
> + javaThread = vm->upcalls->assocThread->getInstanceObjectField(vmThread);
> + assert(javaThread && "VMThread with no Java equivalent");
> +
> + JavaThread* th = new JavaThread(vm);
> + if (!th) vm->outOfMemoryError();
> + th->start((void (*)(mvm::Thread*))start);
> + // Now that the thread has been created, initialise its object fields.
> + th->initialise(javaThread, vmThread);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* vmthread) {
> +
> + llvm_gcroot(vmthread, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JavaField* field = vm->upcalls->vmdataVMThread;
> +
> + // It's possible that the thread to be interrupted has not finished
> + // its initialization. Wait until the initialization is done.
> + while (field->getInstanceObjectField(vmthread) == 0)
> + mvm::Thread::yield();
> +
> + JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);
> + th->lockingThread.interruptFlag = 1;
> + mvm::FatLock* lock = th->lockingThread.waitsOn;
> +
> + // If the thread is blocked on a wait. We also verify nextWaiting in
> case
> + // the thread has been notified.
> + if (lock && th->lockingThread.nextWaiting) {
> + th->lockingThread.state = mvm::LockingThread::StateInterrupted;
> +
> + // Make sure the thread is waiting.
> + uint32 locked = 0;
> + while (true) {
> + locked = (lock->tryAcquire() == 0);
> + if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
> + break;
> + else mvm::Thread::yield();
> + }
> +
> + // Interrupt the thread.
> + th->lockingThread.varcond.signal();
> +
> + // Release the lock if we acquired it.
> + if (locked) lock->release(lock->getAssociatedObject(),
> vm->lockSystem);
> + }
> +
> + // Here we could also raise a signal for interrupting I/O
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +// Never throws.
> +// Never calls Java code.
> +JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + JavaThread* th = JavaThread::get();
> + uint32 interrupt = th->lockingThread.interruptFlag;
> + th->lockingThread.interruptFlag = 0;
> + return (jboolean)interrupt;
> +}
> +
> +// Never throws.
> +// Never calls Java code.
> +JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* vmthread) {
> +
> + llvm_gcroot(vmthread, 0);
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JavaField* field = vm->upcalls->vmdataVMThread;
> + JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);
> + return (jboolean)th->lockingThread.interruptFlag;
> +}
> +
> +// Never throws.
> +// Never calls Java code.
> +JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* vmthread, jint prio) {
> + // Currently not implemented
> + llvm_gcroot(vmthread, 0);
> +}
> +
> +// Never throws.
> +// Never calls Java code.
> +JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* vmthread, JavaObject* exc) {
> + // Currently not implemented
> + llvm_gcroot(vmthread, 0);
> + llvm_gcroot(exc, 0);
> +}
> +
> +// Never throws.
> +// Never calls Java code.
> +JNIEXPORT void JNICALL Java_java_lang_VMThread_yield(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +) {
> + mvm::Thread::yield();
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
> b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
> new file mode 100644
> index 0000000..ee5c1ca
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc
> @@ -0,0 +1,183 @@
> +//===- ClasspathVMClassLoader.cpp - GNU classpath
> java/lang/VMClassLoader -===//
> +//
> +// 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 "JavaAccess.h"
> +#include "JavaArray.h"
> +#include "JavaClass.h"
> +#include "JavaConstantPool.h"
> +#include "JavaObject.h"
> +#include "JavaString.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +#include "Reader.h"
> +
> +using namespace j3;
> +
> +extern "C" {
> +
> +JavaObject* internalFillInStackTrace(JavaObject* throwable) {
> +
> + JavaObject* vmThrowable = 0;
> + ArrayPtr* result = 0;
> + llvm_gcroot(throwable, 0);
> + llvm_gcroot(vmThrowable, 0);
> + llvm_gcroot(result, 0);
> +
> + JavaThread* th = JavaThread::get();
> + Jnjvm* vm = th->getJVM();
> +
> + uint32 length = th->getFrameContextLength();
> +
> + if (sizeof(void*) == 4) {
> + ClassArray* cl = vm->upcalls->ArrayOfInt;
> + result = (ArrayPtr*) cl->doNew(length, vm);
> + } else {
> + ClassArray* cl = vm->upcalls->ArrayOfLong;
> + result = (ArrayPtr*) cl->doNew(length, vm);
> + }
> +
> + // Don't call th->getFrameContext because it is not GC-safe.
> + mvm::StackWalker Walker(th);
> + uint32_t i = 0;
> +
> + while (intptr_t ip = *Walker) {
> + ArrayPtr::setElement(result, ip, i);
> + ++i;
> + ++Walker;
> + }
> +
> + // Set the tempory data in the new VMThrowable object.
> + vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
> + vm->upcalls->vmDataVMThrowable->setInstanceObjectField(vmThrowable,
> result);
> + return vmThrowable;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_fillInStackTrace(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +jclass clazz,
> +#endif
> +JavaObject* throwable) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> + llvm_gcroot(throwable, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + res = internalFillInStackTrace(throwable);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +
> +JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
> +
> + JavaString* methodName = 0;
> + JavaString* className = 0;
> + JavaString* sourceName = 0;
> + JavaObject* res = 0;
> + llvm_gcroot(methodName, 0);
> + llvm_gcroot(className, 0);
> + llvm_gcroot(sourceName, 0);
> + llvm_gcroot(res, 0);
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JavaMethod* meth = (JavaMethod*)FI->Metadata;
> + methodName = vm->internalUTF8ToStr(meth->name);
> + Class* cl = meth->classDef;
> + className = JavaString::internalToJava(cl->name, vm);
> +
> + Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);
> +
> + // We don't have the bytes if the class was vmjc'ed.
> + if (sourceAtt && cl->getBytes()) {
> + Reader reader(sourceAtt, cl->bytes);
> + uint16 index = reader.readU2();
> + sourceName =
> vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));
> + }
> +
> + bool native = isNative(meth->access);
> + uint16 lineNumber = meth->lookupLineNumber(FI);
> +
> + UserClass* newS = vm->upcalls->newStackTraceElement;
> + res = newS->doNew(vm);
> + vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,
> + &sourceName,
> + lineNumber,
> + &className,
> + &methodName,
> native);
> + return res;
> +}
> +
> +JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_getStackTrace(
> +#ifdef NATIVE_JNI
> +JNIEnv *env,
> +#endif
> +JavaObject* vmthrow, JavaObject* throwable) {
> +
> + ArrayObject* result = NULL;
> + JavaObject* stack = NULL;
> + llvm_gcroot(vmthrow, 0);
> + llvm_gcroot(throwable, 0);
> + llvm_gcroot(result, 0);
> + llvm_gcroot(stack, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + JavaField* field = vm->upcalls->vmDataVMThrowable;
> + stack = field->getInstanceObjectField(vmthrow);
> +
> + // remove the VMThrowable.fillInStackTrace method and the last method
> + // on the stack.
> + sint32 index = 2;;
> + while (index != JavaArray::getSize(stack)) {
> + mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
> + if (FI->Metadata == NULL) ++index;
> + else {
> + JavaMethod* meth = (JavaMethod*)FI->Metadata;
> + assert(meth && "Wrong stack trace");
> + if (meth->classDef->isAssignableFrom(vm->upcalls->newThrowable)) {
> + ++index;
> + } else break;
> + }
> + }
> +
> + sint32 size = 0;
> + sint32 cur = index;
> + while (cur < JavaArray::getSize(stack)) {
> + mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
> + ++cur;
> + if (FI->Metadata != NULL) ++size;
> + }
> +
> + result = (ArrayObject*)
> + vm->upcalls->stackTraceArray->doNew(size, vm);
> +
> + cur = 0;
> + for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {
> + mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
> + if (FI->Metadata != NULL) {
> + ArrayObject::setElement(result, consStackElement(FI,
> ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);
> + cur++;
> + }
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return result;
> +}
> +
> +}
> diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> new file mode 100644
> index 0000000..986664c
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp
> @@ -0,0 +1,1076 @@
> +//===-------- JavaUpcalls.cpp - Upcalls to Java entities
> ------------------===//
> +//
> +// The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#include "ClasspathReflect.h"
> +#include "JavaAccess.h"
> +#include "JavaClass.h"
> +#include "JavaObject.h"
> +#include "JavaString.h"
> +#include "JavaThread.h"
> +#include "JavaUpcalls.h"
> +#include "Jnjvm.h"
> +#include "ReferenceQueue.h"
> +
> +#define COMPILE_METHODS(cl) \
> + for (CommonClass::method_iterator i = cl->virtualMethods.begin(), \
> + e = cl->virtualMethods.end(); i!= e; ++i) { \
> + i->second->compiledPtr(); \
> + } \
> + \
> + for (CommonClass::method_iterator i = cl->staticMethods.begin(), \
> + e = cl->staticMethods.end(); i!= e; ++i) { \
> + i->second->compiledPtr(); \
> + }
> +
> +
> +using namespace j3;
> +
> +Class* Classpath::newThread;
> +Class* Classpath::newVMThread;
> +JavaField* Classpath::assocThread;
> +JavaField* Classpath::vmdataVMThread;
> +JavaMethod* Classpath::finaliseCreateInitialThread;
> +JavaMethod* Classpath::initVMThread;
> +JavaMethod* Classpath::initThread;
> +JavaMethod* Classpath::groupAddThread;
> +JavaField* Classpath::threadName;
> +JavaField* Classpath::groupName;
> +JavaMethod* Classpath::initGroup;
> +JavaField* Classpath::priority;
> +JavaField* Classpath::daemon;
> +JavaField* Classpath::group;
> +JavaField* Classpath::running;
> +Class* Classpath::threadGroup;
> +JavaField* Classpath::rootGroup;
> +JavaField* Classpath::vmThread;
> +JavaMethod* Classpath::getUncaughtExceptionHandler;
> +JavaMethod* Classpath::uncaughtException;
> +Class* Classpath::inheritableThreadLocal;
> +
> +JavaMethod* Classpath::runVMThread;
> +JavaMethod* Classpath::setContextClassLoader;
> +JavaMethod* Classpath::getSystemClassLoader;
> +Class* Classpath::newString;
> +Class* Classpath::newClass;
> +Class* Classpath::newThrowable;
> +Class* Classpath::newException;
> +JavaMethod* Classpath::initClass;
> +JavaMethod* Classpath::initClassWithProtectionDomain;
> +JavaField* Classpath::vmdataClass;
> +JavaMethod* Classpath::setProperty;
> +JavaMethod* Classpath::initString;
> +JavaMethod* Classpath::getCallingClassLoader;
> +JavaMethod* Classpath::initConstructor;
> +Class* Classpath::newConstructor;
> +ClassArray* Classpath::constructorArrayClass;
> +ClassArray* Classpath::constructorArrayAnnotation;
> +JavaField* Classpath::constructorSlot;
> +JavaMethod* Classpath::initMethod;
> +JavaMethod* Classpath::initField;
> +Class* Classpath::newField;
> +Class* Classpath::newMethod;
> +ClassArray* Classpath::methodArrayClass;
> +ClassArray* Classpath::fieldArrayClass;
> +JavaField* Classpath::methodSlot;
> +JavaField* Classpath::fieldSlot;
> +ClassArray* Classpath::classArrayClass;
> +JavaMethod* Classpath::loadInClassLoader;
> +JavaMethod* Classpath::initVMThrowable;
> +JavaField* Classpath::vmDataVMThrowable;
> +Class* Classpath::newVMThrowable;
> +JavaField* Classpath::bufferAddress;
> +JavaField* Classpath::dataPointer32;
> +JavaField* Classpath::dataPointer64;
> +Class* Classpath::newPointer32;
> +Class* Classpath::newPointer64;
> +Class* Classpath::newDirectByteBuffer;
> +JavaField* Classpath::vmdataClassLoader;
> +JavaMethod* Classpath::InitDirectByteBuffer;
> +Class* Classpath::newClassLoader;
> +
> +
> +JavaField* Classpath::boolValue;
> +JavaField* Classpath::byteValue;
> +JavaField* Classpath::shortValue;
> +JavaField* Classpath::charValue;
> +JavaField* Classpath::intValue;
> +JavaField* Classpath::longValue;
> +JavaField* Classpath::floatValue;
> +JavaField* Classpath::doubleValue;
> +
> +Class* Classpath::newStackTraceElement;
> +ClassArray* Classpath::stackTraceArray;
> +JavaMethod* Classpath::initStackTraceElement;
> +
> +Class* Classpath::voidClass;
> +Class* Classpath::boolClass;
> +Class* Classpath::byteClass;
> +Class* Classpath::shortClass;
> +Class* Classpath::charClass;
> +Class* Classpath::intClass;
> +Class* Classpath::floatClass;
> +Class* Classpath::doubleClass;
> +Class* Classpath::longClass;
> +
> +Class* Classpath::vmStackWalker;
> +
> +Class* Classpath::InvocationTargetException;
> +Class* Classpath::ArrayStoreException;
> +Class* Classpath::ClassCastException;
> +Class* Classpath::IllegalMonitorStateException;
> +Class* Classpath::IllegalArgumentException;
> +Class* Classpath::InterruptedException;
> +Class* Classpath::IndexOutOfBoundsException;
> +Class* Classpath::ArrayIndexOutOfBoundsException;
> +Class* Classpath::NegativeArraySizeException;
> +Class* Classpath::NullPointerException;
> +Class* Classpath::SecurityException;
> +Class* Classpath::ClassFormatError;
> +Class* Classpath::ClassCircularityError;
> +Class* Classpath::NoClassDefFoundError;
> +Class* Classpath::UnsupportedClassVersionError;
> +Class* Classpath::NoSuchFieldError;
> +Class* Classpath::NoSuchMethodError;
> +Class* Classpath::InstantiationError;
> +Class* Classpath::InstantiationException;
> +Class* Classpath::IllegalAccessError;
> +Class* Classpath::IllegalAccessException;
> +Class* Classpath::VerifyError;
> +Class* Classpath::ExceptionInInitializerError;
> +Class* Classpath::LinkageError;
> +Class* Classpath::AbstractMethodError;
> +Class* Classpath::UnsatisfiedLinkError;
> +Class* Classpath::InternalError;
> +Class* Classpath::OutOfMemoryError;
> +Class* Classpath::StackOverflowError;
> +Class* Classpath::UnknownError;
> +Class* Classpath::ClassNotFoundException;
> +Class* Classpath::ArithmeticException;
> +
> +JavaMethod* Classpath::InitInvocationTargetException;
> +JavaMethod* Classpath::InitArrayStoreException;
> +JavaMethod* Classpath::InitClassCastException;
> +JavaMethod* Classpath::InitIllegalMonitorStateException;
> +JavaMethod* Classpath::InitIllegalArgumentException;
> +JavaMethod* Classpath::InitInterruptedException;
> +JavaMethod* Classpath::InitIndexOutOfBoundsException;
> +JavaMethod* Classpath::InitArrayIndexOutOfBoundsException;
> +JavaMethod* Classpath::InitNegativeArraySizeException;
> +JavaMethod* Classpath::InitNullPointerException;
> +JavaMethod* Classpath::InitSecurityException;
> +JavaMethod* Classpath::InitClassFormatError;
> +JavaMethod* Classpath::InitClassCircularityError;
> +JavaMethod* Classpath::InitNoClassDefFoundError;
> +JavaMethod* Classpath::InitUnsupportedClassVersionError;
> +JavaMethod* Classpath::InitNoSuchFieldError;
> +JavaMethod* Classpath::InitNoSuchMethodError;
> +JavaMethod* Classpath::InitInstantiationError;
> +JavaMethod* Classpath::InitInstantiationException;
> +JavaMethod* Classpath::InitIllegalAccessError;
> +JavaMethod* Classpath::InitIllegalAccessException;
> +JavaMethod* Classpath::InitVerifyError;
> +JavaMethod* Classpath::InitExceptionInInitializerError;
> +JavaMethod* Classpath::InitLinkageError;
> +JavaMethod* Classpath::InitAbstractMethodError;
> +JavaMethod* Classpath::InitUnsatisfiedLinkError;
> +JavaMethod* Classpath::InitInternalError;
> +JavaMethod* Classpath::InitOutOfMemoryError;
> +JavaMethod* Classpath::InitStackOverflowError;
> +JavaMethod* Classpath::InitUnknownError;
> +JavaMethod* Classpath::InitClassNotFoundException;
> +JavaMethod* Classpath::InitArithmeticException;
> +JavaMethod* Classpath::InitObject;
> +JavaMethod* Classpath::FinalizeObject;
> +JavaMethod* Classpath::IntToString;
> +
> +JavaMethod* Classpath::SystemArraycopy;
> +JavaMethod* Classpath::VMSystemArraycopy;
> +Class* Classpath::SystemClass;
> +Class* Classpath::EnumClass;
> +
> +JavaMethod* Classpath::ErrorWithExcpNoClassDefFoundError;
> +JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;
> +JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;
> +
> +ClassArray* Classpath::ArrayOfByte;
> +ClassArray* Classpath::ArrayOfChar;
> +ClassArray* Classpath::ArrayOfString;
> +ClassArray* Classpath::ArrayOfInt;
> +ClassArray* Classpath::ArrayOfShort;
> +ClassArray* Classpath::ArrayOfBool;
> +ClassArray* Classpath::ArrayOfLong;
> +ClassArray* Classpath::ArrayOfFloat;
> +ClassArray* Classpath::ArrayOfDouble;
> +ClassArray* Classpath::ArrayOfObject;
> +
> +ClassPrimitive* Classpath::OfByte;
> +ClassPrimitive* Classpath::OfChar;
> +ClassPrimitive* Classpath::OfInt;
> +ClassPrimitive* Classpath::OfShort;
> +ClassPrimitive* Classpath::OfBool;
> +ClassPrimitive* Classpath::OfLong;
> +ClassPrimitive* Classpath::OfFloat;
> +ClassPrimitive* Classpath::OfDouble;
> +ClassPrimitive* Classpath::OfVoid;
> +
> +Class* Classpath::OfObject;
> +
> +JavaField* Classpath::methodClass;
> +JavaField* Classpath::fieldClass;
> +JavaField* Classpath::constructorClass;
> +
> +JavaMethod* Classpath::EnqueueReference;
> +Class* Classpath::newReference;
> +
> +void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,
> + const char* thName, JavaObject* Group) {
> + JavaObjectVMThread* vmth = NULL;
> + JavaObject* th = NULL;
> + JavaObject* name = NULL;
> + llvm_gcroot(Group, 0);
> + llvm_gcroot(vmth, 0);
> + llvm_gcroot(th, 0);
> + llvm_gcroot(name, 0);
> +
> + th = newThread->doNew(vm);
> + myth->javaThread = th;
> + vmth = (JavaObjectVMThread*)newVMThread->doNew(vm);
> + name = vm->asciizToStr(thName);
> +
> + initThread->invokeIntSpecial(vm, newThread, th, &vmth, &name, 1, 0);
> + vmThread->setInstanceObjectField(th, vmth);
> + assocThread->setInstanceObjectField(vmth, th);
> + running->setInstanceInt8Field(vmth, (uint32)1);
> + JavaObjectVMThread::setVmdata(vmth, myth);
> +
> + group->setInstanceObjectField(th, Group);
> + groupAddThread->invokeIntSpecial(vm, threadGroup, Group, &th);
> +
> + finaliseCreateInitialThread->invokeIntStatic(vm,
> inheritableThreadLocal, &th);
> +}
> +
> +void Classpath::InitializeThreading(Jnjvm* vm) {
> +
> + JavaObject* RG = 0;
> + JavaObject* SystemGroup = 0;
> + JavaObject* systemName = 0;
> + llvm_gcroot(RG, 0);
> + llvm_gcroot(SystemGroup, 0);
> + llvm_gcroot(systemName, 0);
> +
> + // Resolve and initialize classes first.
> + newThread->resolveClass();
> + newThread->initialiseClass(vm);
> +
> + newVMThread->resolveClass();
> + newVMThread->initialiseClass(vm);
> +
> + threadGroup->resolveClass();
> + threadGroup->initialiseClass(vm);
> +
> + // Create the main thread
> + RG = rootGroup->getStaticObjectField();
> + assert(RG && "No root group");
> + assert(vm->getMainThread() && "VM did not set its main thread");
> + CreateJavaThread(vm, (JavaThread*)vm->getMainThread(), "main", RG);
> +
> + // Create the "system" group.
> + SystemGroup = threadGroup->doNew(vm);
> + initGroup->invokeIntSpecial(vm, threadGroup, SystemGroup);
> + systemName = vm->asciizToStr("system");
> + groupName->setInstanceObjectField(SystemGroup, systemName);
> +
> + // Create the finalizer thread.
> + assert(vm->getFinalizerThread() && "VM did not set its finalizer
> thread");
> + CreateJavaThread(vm, vm->getFinalizerThread(), "Finalizer",
> SystemGroup);
> +
> + // Create the enqueue thread.
> + assert(vm->getReferenceThread() && "VM did not set its enqueue thread");
> + CreateJavaThread(vm, vm->getReferenceThread(), "Reference",
> SystemGroup);
> +}
> +
> +extern "C" void
> Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2(
> + JavaObjectReference* reference, JavaObject* referent) {
> + llvm_gcroot(reference, 0);
> + llvm_gcroot(referent, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObjectReference::init(reference, referent, 0);
> +
> JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);
> +
> + END_NATIVE_EXCEPTION
> +
> +}
> +
> +extern "C" void
>
> Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
> + JavaObjectReference* reference,
> + JavaObject* referent,
> + JavaObject* queue) {
> + llvm_gcroot(reference, 0);
> + llvm_gcroot(referent, 0);
> + llvm_gcroot(queue, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObjectReference::init(reference, referent, queue);
> +
> JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);
> +
> + END_NATIVE_EXCEPTION
> +
> +}
> +
> +extern "C" void
> Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2(
> + JavaObjectReference* reference, JavaObject* referent) {
> + llvm_gcroot(reference, 0);
> + llvm_gcroot(referent, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObjectReference::init(reference, referent, 0);
> +
> JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);
> +
> + END_NATIVE_EXCEPTION
> +
> +}
> +
> +extern "C" void
>
> Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
> + JavaObjectReference* reference,
> + JavaObject* referent,
> + JavaObject* queue) {
> + llvm_gcroot(reference, 0);
> + llvm_gcroot(referent, 0);
> + llvm_gcroot(queue, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObjectReference::init(reference, referent, queue);
> +
> JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);
> +
> + END_NATIVE_EXCEPTION
> +
> +}
> +
> +extern "C" void
>
> Java_java_lang_ref_PhantomReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
> + JavaObjectReference* reference,
> + JavaObject* referent,
> + JavaObject* queue) {
> + llvm_gcroot(reference, 0);
> + llvm_gcroot(referent, 0);
> + llvm_gcroot(queue, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaObjectReference::init(reference, referent, queue);
> +
> JavaThread::get()->getJVM()->getReferenceThread()->addPhantomReference(reference);
> +
> + END_NATIVE_EXCEPTION
> +}
> +
> +extern "C" JavaString*
> Java_java_lang_VMString_intern__Ljava_lang_String_2(
> + JavaString* obj) {
> + const ArrayUInt16* array = 0;
> + JavaString* res = 0;
> + llvm_gcroot(obj, 0);
> + llvm_gcroot(array, 0);
> + llvm_gcroot(res, 0);
> + // If the string is already interned, just return.
> + if (obj->getVirtualTable() == JavaString::internStringVT) return obj;
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + array = JavaString::strToArray(obj, vm);
> + res = vm->constructString(array);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +extern "C" uint8 Java_java_lang_Class_isArray__(JavaObjectClass* klass) {
> + llvm_gcroot(klass, 0);
> + UserCommonClass* cl = 0;
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + cl = JavaObjectClass::getClass(klass);
> +
> + END_NATIVE_EXCEPTION
> +
> + return (uint8)cl->isArray();
> +}
> +
> +extern "C" JavaObject*
> Java_gnu_classpath_VMStackWalker_getCallingClass__() {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaThread* th = JavaThread::get();
> + UserClass* cl = th->getCallingClassLevel(2);
> + if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +extern "C" JavaObject*
> Java_gnu_classpath_VMStackWalker_getCallingClassLoader__() {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaThread* th = JavaThread::get();
> + UserClass* cl = th->getCallingClassLevel(2);
> + res = cl->classLoader->getJavaClassLoader();
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +extern "C" JavaObject*
> Java_gnu_classpath_VMStackWalker_firstNonNullClassLoader__() {
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaThread* th = JavaThread::get();
> + res = th->getNonNullClassLoader();
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +extern "C" JavaObject*
> Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {
> +
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + JavaThread* th = JavaThread::get();
> + Jnjvm* vm = th->getJVM();
> + UserClass* cl = th->getCallingClassLevel(index);
> + if (cl) res = cl->getClassDelegatee(vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +extern "C" JavaObject*
> Java_java_lang_reflect_AccessibleObject_getAnnotation__Ljava_lang_Class_2(
> + JavaObject* obj) {
> + llvm_gcroot(obj, 0);
> + return 0;
> +}
> +
> +extern "C" JavaObject*
> Java_java_lang_reflect_AccessibleObject_getDeclaredAnnotations__() {
> + JavaObject* res = 0;
> + llvm_gcroot(res, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> + res = array->doNew(0, vm);
> +
> + END_NATIVE_EXCEPTION
> +
> + return res;
> +}
> +
> +extern "C" void nativeJavaObjectClassTracer(
> + JavaObjectClass* obj, word_t closure) {
> + JavaObjectClass::staticTracer(obj, closure);
> +}
> +
> +extern "C" void nativeJavaObjectFieldTracer(
> + JavaObjectField* obj, word_t closure) {
> + JavaObjectField::staticTracer(obj, closure);
> +}
> +
> +extern "C" void nativeJavaObjectMethodTracer(
> + JavaObjectMethod* obj, word_t closure) {
> + JavaObjectMethod::staticTracer(obj, closure);
> +}
> +
> +extern "C" void nativeJavaObjectConstructorTracer(
> + JavaObjectConstructor* obj, word_t closure) {
> + JavaObjectConstructor::staticTracer(obj, closure);
> +}
> +
> +extern "C" void nativeJavaObjectVMThreadTracer(
> + JavaObjectVMThread* obj, word_t closure) {
> + JavaObjectVMThread::staticTracer(obj, closure);
> +}
> +
> +extern "C" JavaString*
> Java_java_lang_VMSystem_getenv__Ljava_lang_String_2(JavaString* str) {
> + JavaString* ret = 0;
> + llvm_gcroot(str, 0);
> + llvm_gcroot(ret, 0);
> +
> + BEGIN_NATIVE_EXCEPTION(0)
> +
> + mvm::ThreadAllocator allocator;
> + char* buf = JavaString::strToAsciiz(str, &allocator);
> + char* res = getenv(buf);
> + if (res) {
> + Jnjvm* vm = JavaThread::get()->getJVM();
> + ret = vm->asciizToStr(res);
> + }
> +
> + END_NATIVE_EXCEPTION
> +
> + return ret;
> +}
> +
> +void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
> +
> + newClassLoader =
> + UPCALL_CLASS(loader, "java/lang/ClassLoader");
> +
> + getSystemClassLoader =
> + UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader",
> + "()Ljava/lang/ClassLoader;", ACC_STATIC);
> +
> + setContextClassLoader =
> + UPCALL_METHOD(loader, "java/lang/Thread", "setContextClassLoader",
> + "(Ljava/lang/ClassLoader;)V", ACC_VIRTUAL);
> +
> + newString =
> + UPCALL_CLASS(loader, "java/lang/String");
> +
> + newClass =
> + UPCALL_CLASS(loader, "java/lang/Class");
> +
> + newThrowable =
> + UPCALL_CLASS(loader, "java/lang/Throwable");
> +
> + newException =
> + UPCALL_CLASS(loader, "java/lang/Exception");
> +
> + newPointer32 =
> + UPCALL_CLASS(loader, "gnu/classpath/Pointer32");
> +
> + newPointer64 =
> + UPCALL_CLASS(loader, "gnu/classpath/Pointer64");
> +
> + newDirectByteBuffer =
> + UPCALL_CLASS(loader, "java/nio/DirectByteBufferImpl$ReadWrite");
> +
> + InitDirectByteBuffer =
> + UPCALL_METHOD(loader, "java/nio/DirectByteBufferImpl$ReadWrite",
> "<init>",
> + "(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V",
> + ACC_VIRTUAL);
> +
> + initClass =
> + UPCALL_METHOD(loader, "java/lang/Class", "<init>",
> "(Ljava/lang/Object;)V",
> + ACC_VIRTUAL);
> +
> + initClassWithProtectionDomain =
> + UPCALL_METHOD(loader, "java/lang/Class", "<init>",
> + "(Ljava/lang/Object;Ljava/security/ProtectionDomain;)V",
> + ACC_VIRTUAL);
> +
> + vmdataClass =
> + UPCALL_FIELD(loader, "java/lang/Class", "vmdata",
> "Ljava/lang/Object;",
> + ACC_VIRTUAL);
> +
> + setProperty =
> + UPCALL_METHOD(loader, "java/util/Properties", "setProperty",
> +
> "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
> + ACC_VIRTUAL);
> +
> + initString =
> + UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V",
> ACC_VIRTUAL);
> +
> + initConstructor =
> + UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",
> + "(Ljava/lang/Class;I)V", ACC_VIRTUAL);
> +
> + newConstructor =
> + UPCALL_CLASS(loader, "java/lang/reflect/Constructor");
> +
> + constructorArrayClass =
> + UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);
> +
> + constructorArrayAnnotation =
> + UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);
> +
> + constructorSlot =
> + UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot",
> "I", ACC_VIRTUAL);
> +
> + initMethod =
> + UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",
> + "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
> +
> + newMethod =
> + UPCALL_CLASS(loader, "java/lang/reflect/Method");
> +
> + methodArrayClass =
> + UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);
> +
> + methodSlot =
> + UPCALL_FIELD(loader, "java/lang/reflect/Method", "slot", "I",
> ACC_VIRTUAL);
> +
> + initField =
> + UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",
> + "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
> +
> + newField =
> + UPCALL_CLASS(loader, "java/lang/reflect/Field");
> +
> + fieldArrayClass =
> + UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);
> +
> + fieldSlot =
> + UPCALL_FIELD(loader, "java/lang/reflect/Field", "slot", "I",
> ACC_VIRTUAL);
> +
> +
> + classArrayClass =
> + UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);
> +
> + newVMThrowable =
> + UPCALL_CLASS(loader, "java/lang/VMThrowable");
> +
> + initVMThrowable =
> + UPCALL_METHOD(loader, "java/lang/VMThrowable", "<init>", "()V",
> ACC_VIRTUAL);
> +
> + vmDataVMThrowable =
> + UPCALL_FIELD(loader, "java/lang/VMThrowable", "vmdata",
> "Ljava/lang/Object;",
> + ACC_VIRTUAL);
> +
> + bufferAddress =
> + UPCALL_FIELD(loader, "java/nio/Buffer", "address",
> "Lgnu/classpath/Pointer;",
> + ACC_VIRTUAL);
> +
> + dataPointer32 =
> + UPCALL_FIELD(loader, "gnu/classpath/Pointer32", "data", "I",
> ACC_VIRTUAL);
> +
> + dataPointer64 =
> + UPCALL_FIELD(loader, "gnu/classpath/Pointer64", "data", "J",
> ACC_VIRTUAL);
> +
> + vmdataClassLoader =
> + UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",
> "Ljava/lang/Object;",
> + ACC_VIRTUAL);
> +
> + newStackTraceElement =
> + UPCALL_CLASS(loader, "java/lang/StackTraceElement");
> +
> + stackTraceArray =
> + UPCALL_ARRAY_CLASS(loader, "java/lang/StackTraceElement", 1);
> +
> + initStackTraceElement =
> + UPCALL_METHOD(loader, "java/lang/StackTraceElement", "<init>",
> +
> "(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Z)V",
> + ACC_VIRTUAL);
> +
> + boolValue =
> + UPCALL_FIELD(loader, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);
> +
> + byteValue =
> + UPCALL_FIELD(loader, "java/lang/Byte", "value", "B", ACC_VIRTUAL);
> +
> + shortValue =
> + UPCALL_FIELD(loader, "java/lang/Short", "value", "S", ACC_VIRTUAL);
> +
> + charValue =
> + UPCALL_FIELD(loader, "java/lang/Character", "value", "C",
> ACC_VIRTUAL);
> +
> + intValue =
> + UPCALL_FIELD(loader, "java/lang/Integer", "value", "I", ACC_VIRTUAL);
> +
> + longValue =
> + UPCALL_FIELD(loader, "java/lang/Long", "value", "J", ACC_VIRTUAL);
> +
> + floatValue =
> + UPCALL_FIELD(loader, "java/lang/Float", "value", "F", ACC_VIRTUAL);
> +
> + doubleValue =
> + UPCALL_FIELD(loader, "java/lang/Double", "value", "D", ACC_VIRTUAL);
> +
> + Classpath::voidClass =
> + UPCALL_CLASS(loader, "java/lang/Void");
> +
> + Classpath::boolClass =
> + UPCALL_CLASS(loader, "java/lang/Boolean");
> +
> + Classpath::byteClass =
> + UPCALL_CLASS(loader, "java/lang/Byte");
> +
> + Classpath::shortClass =
> + UPCALL_CLASS(loader, "java/lang/Short");
> +
> + Classpath::charClass =
> + UPCALL_CLASS(loader, "java/lang/Character");
> +
> + Classpath::intClass =
> + UPCALL_CLASS(loader, "java/lang/Integer");
> +
> + Classpath::floatClass =
> + UPCALL_CLASS(loader, "java/lang/Float");
> +
> + Classpath::doubleClass =
> + UPCALL_CLASS(loader, "java/lang/Double");
> +
> + Classpath::longClass =
> + UPCALL_CLASS(loader, "java/lang/Long");
> +
> + Classpath::OfObject =
> + UPCALL_CLASS(loader, "java/lang/Object");
> +
> + vmStackWalker =
> + UPCALL_CLASS(loader, "gnu/classpath/VMStackWalker");
> +
> + loadInClassLoader =
> + UPCALL_METHOD(loader, "java/lang/ClassLoader", "loadClass",
> + "(Ljava/lang/String;)Ljava/lang/Class;", ACC_VIRTUAL);
> +
> + JavaMethod* internString =
> + UPCALL_METHOD(loader, "java/lang/VMString", "intern",
> + "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
> + internString->setNative();
> +
> + JavaMethod* isArray =
> + UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z",
> ACC_VIRTUAL);
> + isArray->setNative();
> +
> + // Make sure classes the JIT optimizes on are loaded.
> + UPCALL_CLASS(loader, "java/lang/VMFloat");
> + UPCALL_CLASS(loader, "java/lang/VMDouble");
> +
> + UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException);
> + UPCALL_CLASS_EXCEPTION(loader, ArrayStoreException);
> + UPCALL_CLASS_EXCEPTION(loader, ClassCastException);
> + UPCALL_CLASS_EXCEPTION(loader, IllegalMonitorStateException);
> + UPCALL_CLASS_EXCEPTION(loader, IllegalArgumentException);
> + UPCALL_CLASS_EXCEPTION(loader, InterruptedException);
> + UPCALL_CLASS_EXCEPTION(loader, IndexOutOfBoundsException);
> + UPCALL_CLASS_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
> + UPCALL_CLASS_EXCEPTION(loader, NegativeArraySizeException);
> + UPCALL_CLASS_EXCEPTION(loader, NullPointerException);
> + UPCALL_CLASS_EXCEPTION(loader, SecurityException);
> + UPCALL_CLASS_EXCEPTION(loader, ClassFormatError);
> + UPCALL_CLASS_EXCEPTION(loader, ClassCircularityError);
> + UPCALL_CLASS_EXCEPTION(loader, NoClassDefFoundError);
> + UPCALL_CLASS_EXCEPTION(loader, UnsupportedClassVersionError);
> + UPCALL_CLASS_EXCEPTION(loader, NoSuchFieldError);
> + UPCALL_CLASS_EXCEPTION(loader, NoSuchMethodError);
> + UPCALL_CLASS_EXCEPTION(loader, InstantiationError);
> + UPCALL_CLASS_EXCEPTION(loader, InstantiationException);
> + UPCALL_CLASS_EXCEPTION(loader, IllegalAccessError);
> + UPCALL_CLASS_EXCEPTION(loader, IllegalAccessException);
> + UPCALL_CLASS_EXCEPTION(loader, VerifyError);
> + UPCALL_CLASS_EXCEPTION(loader, ExceptionInInitializerError);
> + UPCALL_CLASS_EXCEPTION(loader, LinkageError);
> + UPCALL_CLASS_EXCEPTION(loader, AbstractMethodError);
> + UPCALL_CLASS_EXCEPTION(loader, UnsatisfiedLinkError);
> + UPCALL_CLASS_EXCEPTION(loader, InternalError);
> + UPCALL_CLASS_EXCEPTION(loader, OutOfMemoryError);
> + UPCALL_CLASS_EXCEPTION(loader, StackOverflowError);
> + UPCALL_CLASS_EXCEPTION(loader, UnknownError);
> + UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);
> + UPCALL_CLASS_EXCEPTION(loader, ArithmeticException);
> +
> + UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);
> + UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);
> + UPCALL_METHOD_EXCEPTION(loader, ClassCastException);
> + UPCALL_METHOD_EXCEPTION(loader, IllegalMonitorStateException);
> + UPCALL_METHOD_EXCEPTION(loader, IllegalArgumentException);
> + UPCALL_METHOD_EXCEPTION(loader, InterruptedException);
> + UPCALL_METHOD_EXCEPTION(loader, IndexOutOfBoundsException);
> + UPCALL_METHOD_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
> + UPCALL_METHOD_EXCEPTION(loader, NegativeArraySizeException);
> + UPCALL_METHOD_EXCEPTION(loader, NullPointerException);
> + UPCALL_METHOD_EXCEPTION(loader, SecurityException);
> + UPCALL_METHOD_EXCEPTION(loader, ClassFormatError);
> + UPCALL_METHOD_EXCEPTION(loader, ClassCircularityError);
> + UPCALL_METHOD_EXCEPTION(loader, NoClassDefFoundError);
> + UPCALL_METHOD_EXCEPTION(loader, UnsupportedClassVersionError);
> + UPCALL_METHOD_EXCEPTION(loader, NoSuchFieldError);
> + UPCALL_METHOD_EXCEPTION(loader, NoSuchMethodError);
> + UPCALL_METHOD_EXCEPTION(loader, InstantiationError);
> + UPCALL_METHOD_EXCEPTION(loader, InstantiationException);
> + UPCALL_METHOD_EXCEPTION(loader, IllegalAccessError);
> + UPCALL_METHOD_EXCEPTION(loader, IllegalAccessException);
> + UPCALL_METHOD_EXCEPTION(loader, VerifyError);
> + UPCALL_METHOD_EXCEPTION(loader, ExceptionInInitializerError);
> + UPCALL_METHOD_EXCEPTION(loader, LinkageError);
> + UPCALL_METHOD_EXCEPTION(loader, AbstractMethodError);
> + UPCALL_METHOD_EXCEPTION(loader, UnsatisfiedLinkError);
> + UPCALL_METHOD_EXCEPTION(loader, InternalError);
> + UPCALL_METHOD_EXCEPTION(loader, OutOfMemoryError);
> + UPCALL_METHOD_EXCEPTION(loader, StackOverflowError);
> + UPCALL_METHOD_EXCEPTION(loader, UnknownError);
> + UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);
> + UPCALL_METHOD_EXCEPTION(loader, ArithmeticException);
> +
> + UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);
> + UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
> + UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);
> +
> + InitObject = UPCALL_METHOD(loader, "java/lang/Object", "<init>", "()V",
> + ACC_VIRTUAL);
> +
> + FinalizeObject = UPCALL_METHOD(loader, "java/lang/Object", "finalize",
> "()V",
> + ACC_VIRTUAL);
> +
> + IntToString = UPCALL_METHOD(loader, "java/lang/Integer", "toString",
> + "(II)Ljava/lang/String;", ACC_STATIC);
> +
> + SystemArraycopy = UPCALL_METHOD(loader, "java/lang/System", "arraycopy",
> +
> "(Ljava/lang/Object;ILjava/lang/Object;II)V",
> + ACC_STATIC);
> +
> + VMSystemArraycopy = UPCALL_METHOD(loader, "java/lang/VMSystem",
> "arraycopy",
> +
> "(Ljava/lang/Object;ILjava/lang/Object;II)V",
> + ACC_STATIC);
> +
> + SystemClass = UPCALL_CLASS(loader, "java/lang/System");
> + EnumClass = UPCALL_CLASS(loader, "java/lang/Enum");
> +
> + newThread =
> + UPCALL_CLASS(loader, "java/lang/Thread");
> +
> + newVMThread =
> + UPCALL_CLASS(loader, "java/lang/VMThread");
> +
> + assocThread =
> + UPCALL_FIELD(loader, "java/lang/VMThread", "thread",
> "Ljava/lang/Thread;",
> + ACC_VIRTUAL);
> +
> + vmdataVMThread =
> + UPCALL_FIELD(loader, "java/lang/VMThread", "vmdata",
> "Ljava/lang/Object;",
> + ACC_VIRTUAL);
> +
> + inheritableThreadLocal =
> + UPCALL_CLASS(loader, "java/lang/InheritableThreadLocal");
> +
> + finaliseCreateInitialThread =
> + UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal",
> "newChildThread",
> + "(Ljava/lang/Thread;)V", ACC_STATIC);
> +
> + initThread =
> + UPCALL_METHOD(loader, "java/lang/Thread", "<init>",
> + "(Ljava/lang/VMThread;Ljava/lang/String;IZ)V",
> ACC_VIRTUAL);
> +
> + initVMThread =
> + UPCALL_METHOD(loader, "java/lang/VMThread", "<init>",
> + "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
> +
> + runVMThread =
> + UPCALL_METHOD(loader, "java/lang/VMThread", "run", "()V",
> ACC_VIRTUAL);
> +
> +
> + groupAddThread =
> + UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread",
> + "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
> +
> + initGroup =
> + UPCALL_METHOD(loader, "java/lang/ThreadGroup", "<init>",
> + "()V", ACC_VIRTUAL);
> +
> + groupName =
> + UPCALL_FIELD(loader, "java/lang/ThreadGroup", "name",
> "Ljava/lang/String;",
> + ACC_VIRTUAL);
> +
> + threadName =
> + UPCALL_FIELD(loader, "java/lang/Thread", "name",
> "Ljava/lang/String;",
> + ACC_VIRTUAL);
> +
> +
> + priority =
> + UPCALL_FIELD(loader, "java/lang/Thread", "priority", "I",
> ACC_VIRTUAL);
> +
> + daemon =
> + UPCALL_FIELD(loader, "java/lang/Thread", "daemon", "Z", ACC_VIRTUAL);
> +
> + group =
> + UPCALL_FIELD(loader, "java/lang/Thread", "group",
> + "Ljava/lang/ThreadGroup;", ACC_VIRTUAL);
> +
> + running =
> + UPCALL_FIELD(loader, "java/lang/VMThread", "running", "Z",
> ACC_VIRTUAL);
> +
> + threadGroup =
> + UPCALL_CLASS(loader, "java/lang/ThreadGroup");
> +
> + rootGroup =
> + UPCALL_FIELD(loader, "java/lang/ThreadGroup", "root",
> + "Ljava/lang/ThreadGroup;", ACC_STATIC);
> +
> + vmThread =
> + UPCALL_FIELD(loader, "java/lang/Thread", "vmThread",
> + "Ljava/lang/VMThread;", ACC_VIRTUAL);
> +
> + getUncaughtExceptionHandler =
> + UPCALL_METHOD(loader, "java/lang/Thread",
> "getUncaughtExceptionHandler",
> + "()Ljava/lang/Thread$UncaughtExceptionHandler;",
> ACC_VIRTUAL);
> +
> + uncaughtException =
> + UPCALL_METHOD(loader, "java/lang/Thread$UncaughtExceptionHandler",
> + "uncaughtException",
> + "(Ljava/lang/Thread;Ljava/lang/Throwable;)V",
> ACC_VIRTUAL);
> +
> +
> + methodClass =
> + UPCALL_FIELD(loader, "java/lang/reflect/Method", "declaringClass",
> + "Ljava/lang/Class;", ACC_VIRTUAL);
> +
> + fieldClass =
> + UPCALL_FIELD(loader, "java/lang/reflect/Field", "declaringClass",
> + "Ljava/lang/Class;", ACC_VIRTUAL);
> +
> + constructorClass =
> + UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "clazz",
> + "Ljava/lang/Class;", ACC_VIRTUAL);
> +
> + loader->loadName(loader->asciizConstructUTF8("java/lang/String"),
> + true, false, NULL);
> +
> + loader->loadName(loader->asciizConstructUTF8("java/lang/Object"),
> + true, false, NULL);
> +
> + // Don't compile methods here, we still don't know where to allocate
> Java
> + // strings.
> +
> + JavaMethod* getEnv =
> + UPCALL_METHOD(loader, "java/lang/VMSystem", "getenv",
> + "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
> + getEnv->setNative();
> +
> + JavaMethod* getCallingClass =
> + UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
> "getCallingClass",
> + "()Ljava/lang/Class;", ACC_STATIC);
> + getCallingClass->setNative();
> +
> + JavaMethod* getCallingClassLoader =
> + UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
> "getCallingClassLoader",
> + "()Ljava/lang/ClassLoader;", ACC_STATIC);
> + getCallingClassLoader->setNative();
> +
> + JavaMethod* firstNonNullClassLoader =
> + UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
> "firstNonNullClassLoader",
> + "()Ljava/lang/ClassLoader;", ACC_STATIC);
> + firstNonNullClassLoader->setNative();
> +
> + JavaMethod* getCallerClass =
> + UPCALL_METHOD(loader, "sun/reflect/Reflection", "getCallerClass",
> + "(I)Ljava/lang/Class;", ACC_STATIC);
> + getCallerClass->setNative();
> +
> + JavaMethod* postProperties =
> + UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit",
> + "(Ljava/util/Properties;)V", ACC_STATIC);
> + postProperties->setNative();
> +
> + // Also implement these twos, implementation in GNU Classpath
> 0.97.2 is buggy.
> + JavaMethod* getAnnotation =
> + UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",
> "getAnnotation",
> + "(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;",
> + ACC_VIRTUAL);
> + getAnnotation->setNative();
> +
> + JavaMethod* getAnnotations =
> + UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",
> + "getDeclaredAnnotations",
> + "()[Ljava/lang/annotation/Annotation;",
> + ACC_VIRTUAL);
> + getAnnotations->setNative();
> +
> + JavaMethod* getBootPackages =
> + UPCALL_METHOD(loader, "java/lang/VMClassLoader", "getBootPackages",
> + "()[Ljava/lang/String;", ACC_STATIC);
> + getBootPackages->setNative();
> +
> +
> //===----------------------------------------------------------------------===//
> + //
> + // To make classes non GC-allocated, we have to bypass the tracer
> functions of
> + // java.lang.Class, java.lang.reflect.Field, java.lang.reflect.Method
> and
> + // java.lang.reflect.constructor. The new tracer functions trace
> the classloader
> + // instead of the class/field/method.
> + //
> +
> //===----------------------------------------------------------------------===//
> +
> + newClass->getVirtualVT()->setNativeTracer(
> + (word_t)nativeJavaObjectClassTracer,
> + "nativeJavaObjectClassTracer");
> +
> + newConstructor->getVirtualVT()->setNativeTracer(
> + (word_t)nativeJavaObjectConstructorTracer,
> + "nativeJavaObjectConstructorTracer");
> +
> + newMethod->getVirtualVT()->setNativeTracer(
> + (word_t)nativeJavaObjectMethodTracer,
> + "nativeJavaObjectMethodTracer");
> +
> + newField->getVirtualVT()->setNativeTracer(
> + (word_t)nativeJavaObjectFieldTracer,
> + "nativeJavaObjectFieldTracer");
> +
> + newVMThread->getVirtualVT()->setNativeTracer(
> + (word_t)nativeJavaObjectVMThreadTracer,
> + "nativeJavaObjectVMThreadTracer");
> +
> + newReference = UPCALL_CLASS(loader, "java/lang/ref/Reference");
> +
> + EnqueueReference =
> + UPCALL_METHOD(loader, "java/lang/ref/Reference", "enqueue", "()Z",
> + ACC_VIRTUAL);
> +
> + JavaMethod* initWeakReference =
> + UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
> + "(Ljava/lang/Object;)V",
> + ACC_VIRTUAL);
> + initWeakReference->setNative();
> +
> + initWeakReference =
> + UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
> + "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
> + ACC_VIRTUAL);
> + initWeakReference->setNative();
> +
> + JavaMethod* initSoftReference =
> + UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",
> + "(Ljava/lang/Object;)V",
> + ACC_VIRTUAL);
> + initSoftReference->setNative();
> +
> + initSoftReference =
> + UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",
> + "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
> + ACC_VIRTUAL);
> + initSoftReference->setNative();
> +
> + JavaMethod* initPhantomReference =
> + UPCALL_METHOD(loader, "java/lang/ref/PhantomReference", "<init>",
> + "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
> + ACC_VIRTUAL);
> + initPhantomReference->setNative();
> +}
> +
> +#include "ClasspathConstructor.inc"
> +#include "Classpath.inc"
> +#include "ClasspathField.inc"
> +#include "ClasspathMethod.inc"
> +#include "ClasspathVMClass.inc"
> +#include "ClasspathVMClassLoader.inc"
> +#include "ClasspathVMObject.inc"
> +#include "ClasspathVMRuntime.inc"
> +#include "ClasspathVMStackWalker.inc"
> +#include "ClasspathVMSystem.inc"
> +#include "ClasspathVMSystemProperties.inc"
> +#include "ClasspathVMThread.inc"
> +#include "ClasspathVMThrowable.inc"
> diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
> b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
> new file mode 100644
> index 0000000..ae5eb63
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h
> @@ -0,0 +1,283 @@
> +//===---------- JavaUpcalls.h - Upcalls to Java entities
> ------------------===//
> +//
> +// The VMKit project
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
>
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef JNJVM_JAVA_UPCALLS_H
> +#define JNJVM_JAVA_UPCALLS_H
> +
> +#include "mvm/Allocator.h"
> +
> +#include "JnjvmConfig.h"
> +
> +#define UPCALL_CLASS(vm, name)
> \
> + vm->loadName(vm->asciizConstructUTF8(name), true, false, NULL)
> +
> +#define UPCALL_PRIMITIVE_CLASS(loader, name, nb)
> \
> + new(loader->allocator, "Primitive class")
> \
> + UserClassPrimitive(loader,
> loader->asciizConstructUTF8(name), nb) \
> +
> +#define UPCALL_FIELD(vm, cl, name, type, acc)
> \
> + UPCALL_CLASS(vm,
> cl)->lookupFieldDontThrow(vm->asciizConstructUTF8(name), \
> +
> vm->asciizConstructUTF8(type), \
> + isStatic(acc), false, 0)
> +
> +#define UPCALL_METHOD(vm, cl, name, type, acc)
> \
> + UPCALL_CLASS(vm,
> cl)->lookupMethodDontThrow(vm->asciizConstructUTF8(name), \
> +
> vm->asciizConstructUTF8(type), \
> + isStatic(acc), false, 0)
> +
> +#define UPCALL_ARRAY_CLASS(loader, name, depth)
> \
> + loader->constructArray(
> \
> + loader->constructArrayName(depth, loader->asciizConstructUTF8(name)))
> +
> +#define UPCALL_CLASS_EXCEPTION(loader, name)
> \
> + name = UPCALL_CLASS(loader, "java/lang/"#name)
> +
> +#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name)
> \
> + name = UPCALL_CLASS(loader, "java/lang/reflect/"#name)
> +
> +#define UPCALL_METHOD_EXCEPTION(loader, name) \
> + Init##name =
> name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \
> +
> loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \
> + false, false, 0);
> +
> +#define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \
> + ErrorWithExcp##name =
> name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \
> +
> loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \
> + false, false, 0);
> +
> +namespace j3 {
> +
> +class Jnjvm;
> +class JavaField;
> +class JavaMethod;
> +class JavaObject;
> +class JavaThread;
> +class Class;
> +class ClassArray;
> +class JnjvmClassLoader;
> +
> +class Classpath : public mvm::PermanentObject {
> +public:
> + ISOLATE_STATIC UserClass* newClassLoader;
> + ISOLATE_STATIC JavaMethod* getSystemClassLoader;
> + ISOLATE_STATIC JavaMethod* setContextClassLoader;
> + ISOLATE_STATIC UserClass* newString;
> + ISOLATE_STATIC UserClass* newClass;
> + ISOLATE_STATIC UserClass* newThrowable;
> + ISOLATE_STATIC UserClass* newException;
> + ISOLATE_STATIC JavaMethod* initClass;
> + ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain;
> + ISOLATE_STATIC JavaField* vmdataClass;
> + ISOLATE_STATIC JavaMethod* setProperty;
> + ISOLATE_STATIC JavaMethod* initString;
> + ISOLATE_STATIC JavaMethod* getCallingClassLoader;
> + ISOLATE_STATIC JavaMethod* initConstructor;
> + ISOLATE_STATIC UserClassArray* constructorArrayClass;
> + ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;
> + ISOLATE_STATIC UserClass* newConstructor;
> + ISOLATE_STATIC JavaField* constructorSlot;
> + ISOLATE_STATIC JavaMethod* initMethod;
> + ISOLATE_STATIC JavaMethod* initField;
> + ISOLATE_STATIC UserClassArray* methodArrayClass;
> + ISOLATE_STATIC UserClassArray* fieldArrayClass;
> + ISOLATE_STATIC UserClass* newMethod;
> + ISOLATE_STATIC UserClass* newField;
> + ISOLATE_STATIC JavaField* methodSlot;
> + ISOLATE_STATIC JavaField* fieldSlot;
> + ISOLATE_STATIC UserClassArray* classArrayClass;
> + ISOLATE_STATIC JavaMethod* loadInClassLoader;
> + ISOLATE_STATIC JavaMethod* initVMThrowable;
> + ISOLATE_STATIC JavaField* vmDataVMThrowable;
> + ISOLATE_STATIC UserClass* newVMThrowable;
> + ISOLATE_STATIC JavaField* bufferAddress;
> + ISOLATE_STATIC JavaField* dataPointer32;
> + ISOLATE_STATIC JavaField* dataPointer64;
> + ISOLATE_STATIC UserClass* newPointer32;
> + ISOLATE_STATIC UserClass* newPointer64;
> + ISOLATE_STATIC UserClass* newDirectByteBuffer;
> + ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;
> + ISOLATE_STATIC JavaField* vmdataClassLoader;
> + ISOLATE_STATIC UserClass* enumClass;
> +
> + ISOLATE_STATIC JavaField* boolValue;
> + ISOLATE_STATIC JavaField* byteValue;
> + ISOLATE_STATIC JavaField* shortValue;
> + ISOLATE_STATIC JavaField* charValue;
> + ISOLATE_STATIC JavaField* intValue;
> + ISOLATE_STATIC JavaField* longValue;
> + ISOLATE_STATIC JavaField* floatValue;
> + ISOLATE_STATIC JavaField* doubleValue;
> +
> + ISOLATE_STATIC UserClass* newStackTraceElement;
> + ISOLATE_STATIC UserClassArray* stackTraceArray;
> + ISOLATE_STATIC JavaMethod* initStackTraceElement;
> +
> + ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader);
> +
> + ISOLATE_STATIC UserClass* voidClass;
> + ISOLATE_STATIC UserClass* boolClass;
> + ISOLATE_STATIC UserClass* byteClass;
> + ISOLATE_STATIC UserClass* shortClass;
> + ISOLATE_STATIC UserClass* charClass;
> + ISOLATE_STATIC UserClass* intClass;
> + ISOLATE_STATIC UserClass* floatClass;
> + ISOLATE_STATIC UserClass* doubleClass;
> + ISOLATE_STATIC UserClass* longClass;
> +
> + ISOLATE_STATIC UserClass* vmStackWalker;
> +
> + ISOLATE_STATIC UserClass* newThread;
> + ISOLATE_STATIC UserClass* newVMThread;
> + ISOLATE_STATIC JavaField* assocThread;
> + ISOLATE_STATIC JavaField* vmdataVMThread;
> + ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread;
> + ISOLATE_STATIC JavaMethod* initThread;
> + ISOLATE_STATIC JavaMethod* initVMThread;
> + ISOLATE_STATIC JavaMethod* runVMThread;
> + ISOLATE_STATIC JavaMethod* groupAddThread;
> + ISOLATE_STATIC JavaField* threadName;
> + ISOLATE_STATIC JavaField* groupName;
> + ISOLATE_STATIC JavaMethod* initGroup;
> + ISOLATE_STATIC JavaField* priority;
> + ISOLATE_STATIC JavaField* daemon;
> + ISOLATE_STATIC JavaField* group;
> + ISOLATE_STATIC JavaField* running;
> + ISOLATE_STATIC UserClass* threadGroup;
> + ISOLATE_STATIC JavaField* rootGroup;
> + ISOLATE_STATIC JavaField* vmThread;
> + ISOLATE_STATIC JavaMethod* getUncaughtExceptionHandler;
> + ISOLATE_STATIC JavaMethod* uncaughtException;
> + ISOLATE_STATIC UserClass* inheritableThreadLocal;
> +
> +
> + ISOLATE_STATIC UserClass* InvocationTargetException;
> + ISOLATE_STATIC UserClass* ArrayStoreException;
> + ISOLATE_STATIC UserClass* ClassCastException;
> + ISOLATE_STATIC UserClass* IllegalMonitorStateException;
> + ISOLATE_STATIC UserClass* IllegalArgumentException;
> + ISOLATE_STATIC UserClass* InterruptedException;
> + ISOLATE_STATIC UserClass* IndexOutOfBoundsException;
> + ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException;
> + ISOLATE_STATIC UserClass* NegativeArraySizeException;
> + ISOLATE_STATIC UserClass* NullPointerException;
> + ISOLATE_STATIC UserClass* SecurityException;
> + ISOLATE_STATIC UserClass* ClassFormatError;
> + ISOLATE_STATIC UserClass* ClassCircularityError;
> + ISOLATE_STATIC UserClass* NoClassDefFoundError;
> + ISOLATE_STATIC UserClass* UnsupportedClassVersionError;
> + ISOLATE_STATIC UserClass* NoSuchFieldError;
> + ISOLATE_STATIC UserClass* NoSuchMethodError;
> + ISOLATE_STATIC UserClass* InstantiationError;
> + ISOLATE_STATIC UserClass* InstantiationException;
> + ISOLATE_STATIC UserClass* IllegalAccessError;
> + ISOLATE_STATIC UserClass* IllegalAccessException;
> + ISOLATE_STATIC UserClass* VerifyError;
> + ISOLATE_STATIC UserClass* ExceptionInInitializerError;
> + ISOLATE_STATIC UserClass* LinkageError;
> + ISOLATE_STATIC UserClass* AbstractMethodError;
> + ISOLATE_STATIC UserClass* UnsatisfiedLinkError;
> + ISOLATE_STATIC UserClass* InternalError;
> + ISOLATE_STATIC UserClass* OutOfMemoryError;
> + ISOLATE_STATIC UserClass* StackOverflowError;
> + ISOLATE_STATIC UserClass* UnknownError;
> + ISOLATE_STATIC UserClass* ClassNotFoundException;
> + ISOLATE_STATIC UserClass* ArithmeticException;
> +
> + ISOLATE_STATIC JavaMethod* InitInvocationTargetException;
> + ISOLATE_STATIC JavaMethod* InitArrayStoreException;
> + ISOLATE_STATIC JavaMethod* InitClassCastException;
> + ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException;
> + ISOLATE_STATIC JavaMethod* InitIllegalArgumentException;
> + ISOLATE_STATIC JavaMethod* InitInterruptedException;
> + ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException;
> + ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException;
> + ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException;
> + ISOLATE_STATIC JavaMethod* InitNullPointerException;
> + ISOLATE_STATIC JavaMethod* InitSecurityException;
> + ISOLATE_STATIC JavaMethod* InitClassFormatError;
> + ISOLATE_STATIC JavaMethod* InitClassCircularityError;
> + ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError;
> + ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError;
> + ISOLATE_STATIC JavaMethod* InitNoSuchFieldError;
> + ISOLATE_STATIC JavaMethod* InitNoSuchMethodError;
> + ISOLATE_STATIC JavaMethod* InitInstantiationError;
> + ISOLATE_STATIC JavaMethod* InitInstantiationException;
> + ISOLATE_STATIC JavaMethod* InitIllegalAccessError;
> + ISOLATE_STATIC JavaMethod* InitIllegalAccessException;
> + ISOLATE_STATIC JavaMethod* InitVerifyError;
> + ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError;
> + ISOLATE_STATIC JavaMethod* InitLinkageError;
> + ISOLATE_STATIC JavaMethod* InitAbstractMethodError;
> + ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError;
> + ISOLATE_STATIC JavaMethod* InitInternalError;
> + ISOLATE_STATIC JavaMethod* InitOutOfMemoryError;
> + ISOLATE_STATIC JavaMethod* InitStackOverflowError;
> + ISOLATE_STATIC JavaMethod* InitUnknownError;
> + ISOLATE_STATIC JavaMethod* InitClassNotFoundException;
> + ISOLATE_STATIC JavaMethod* InitArithmeticException;
> +
> + ISOLATE_STATIC JavaMethod* SystemArraycopy;
> + ISOLATE_STATIC JavaMethod* VMSystemArraycopy;
> + ISOLATE_STATIC Class* SystemClass;
> +
> + ISOLATE_STATIC JavaMethod* IntToString;
> +
> + ISOLATE_STATIC JavaMethod* InitObject;
> + ISOLATE_STATIC JavaMethod* FinalizeObject;
> +
> + ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError;
> + ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError;
> + ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException;
> +
> +
> +
> + ISOLATE_STATIC UserClassArray* ArrayOfByte;
> + ISOLATE_STATIC UserClassArray* ArrayOfChar;
> + ISOLATE_STATIC UserClassArray* ArrayOfInt;
> + ISOLATE_STATIC UserClassArray* ArrayOfShort;
> + ISOLATE_STATIC UserClassArray* ArrayOfBool;
> + ISOLATE_STATIC UserClassArray* ArrayOfLong;
> + ISOLATE_STATIC UserClassArray* ArrayOfFloat;
> + ISOLATE_STATIC UserClassArray* ArrayOfDouble;
> + ISOLATE_STATIC UserClassArray* ArrayOfObject;
> + ISOLATE_STATIC UserClassArray* ArrayOfString;
> +
> + ISOLATE_STATIC UserClassPrimitive* OfByte;
> + ISOLATE_STATIC UserClassPrimitive* OfChar;
> + ISOLATE_STATIC UserClassPrimitive* OfInt;
> + ISOLATE_STATIC UserClassPrimitive* OfShort;
> + ISOLATE_STATIC UserClassPrimitive* OfBool;
> + ISOLATE_STATIC UserClassPrimitive* OfLong;
> + ISOLATE_STATIC UserClassPrimitive* OfFloat;
> + ISOLATE_STATIC UserClassPrimitive* OfDouble;
> + ISOLATE_STATIC UserClassPrimitive* OfVoid;
> +
> + ISOLATE_STATIC UserClass* OfObject;
> +
> + ISOLATE_STATIC JavaField* methodClass;
> + ISOLATE_STATIC JavaField* fieldClass;
> + ISOLATE_STATIC JavaField* constructorClass;
> +
> + ISOLATE_STATIC JavaMethod* EnqueueReference;
> + ISOLATE_STATIC Class* newReference;
> +
> + ISOLATE_STATIC UserClass* EnumClass;
> +
> +private:
> + ISOLATE_STATIC void CreateJavaThread(Jnjvm* vm, JavaThread* myth,
> + const char* name, JavaObject*
> Group);
> +
> +public:
> + ISOLATE_STATIC void InitializeThreading(Jnjvm* vm);
> +};
> +
> +
> +} // end namespace j3
> +
> +#endif
> diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
> b/lib/J3/ClassLib/GNUClasspath/Makefile
> new file mode 100644
> index 0000000..bc695df
> --- /dev/null
> +++ b/lib/J3/ClassLib/GNUClasspath/Makefile
> @@ -0,0 +1,23 @@
> +##===- lib/J3/ClassLib/GNUClasspath/Makefile ---------------*-
> Makefile -*-===##
> +#
> +# The vmkit project
> +#
> +# This file is distributed under the University of Illinois Open Source
> +# License. See LICENSE.TXT for details.
> +#
>
> +##===----------------------------------------------------------------------===##
> +LEVEL = ../../../..
> +
> +
> +EXTRA_DIST = ClasspathConstructor.inc ClasspathField.inc
> Classpath.inc ClasspathMethod.inc \
> + ClasspathVMClass.inc ClasspathVMClassLoader.inc
> ClasspathVMObject.inc \
> + ClasspathVMRuntime.inc ClasspathVMStackWalker.inc
> ClasspathVMSystem.inc \
> + ClasspathVMSystemProperties.inc ClasspathVMThread.inc
> ClasspathVMThrowable.inc
> +
> +include $(LEVEL)/Makefile.config
> +
> +MODULE_WITH_GC = Classpath
> +
> +include $(LEVEL)/Makefile.common
> +
> +CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/J3/VMCore
> -I$(PROJ_SRC_ROOT)/include/j3 -I..
> diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile
> new file mode 100644
> index 0000000..3ecee91
> --- /dev/null
> +++ b/lib/J3/ClassLib/Makefile
> @@ -0,0 +1,15 @@
> +##===- lib/J3/ClassLib/Makefile ----------------------------*-
> Makefile -*-===##
> +#
> +# The vmkit project
> +#
> +# This file is distributed under the University of Illinois Open Source
> +# License. See LICENSE.TXT for details.
> +#
>
> +##===----------------------------------------------------------------------===##
> +LEVEL = ../../..
> +
> +include $(LEVEL)/Makefile.config
> +
> +DIRS = $(CLASSPATH_DIR)
> +
> +include $(LEVEL)/Makefile.common
> diff --git a/lib/J3/ClassLib/OpenJDK/Makefile
> b/lib/J3/ClassLib/OpenJDK/Makefile
> new file mode 100644
> index 0000000..4a97d96
> --- /dev/null
> +++ b/lib/J3/ClassLib/OpenJDK/Makefile
> @@ -0,0 +1,19 @@
> +##===- lib/J3/ClassLib/OpenJDK/Makefile --------------------*-
> Makefile -*-===##
> +#
> +# The vmkit project
> +#
> +# This file is distributed under the University of Illinois Open Source
> +# License. See LICENSE.TXT for details.
> +#
>
> +##===----------------------------------------------------------------------===##
> +LEVEL = ../../../..
> +
> +EXTRA_DIST =
> +
> +include $(LEVEL)/Makefile.config
> +
> +MODULE_WITH_GC = Classpath
> +
> +include $(LEVEL)/Makefile.common
> +
> +CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/J3/VMCore
> -I$(PROJ_SRC_ROOT)/include/j3 -I..
> diff --git a/lib/J3/Classpath/Classpath.h.in b/lib/J3/Classpath/
> Classpath.h.in
> deleted file mode 100644
> index 107510d..0000000
> --- a/lib/J3/Classpath/Classpath.h.in
> +++ /dev/null
> @@ -1,19 +0,0 @@
> -//===-------- Classpath.h - Configuration for classpath
> -------------------===//
> -//
> -// The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -
> -#define GNUClasspathLibs "@classpathlibs@";
> -#define GNUClasspathGlibj "@classpathglibj@";
> -#define GNUClasspathVersion "@classpathversion@";
> -
> -#ifdef NATIVE_JNI
> -#define JNIEXPORT
> -#else
> -#include <jni.h>
> -#endif
> diff --git a/lib/J3/Classpath/Classpath.inc
> b/lib/J3/Classpath/Classpath.inc
> deleted file mode 100644
> index 792b606..0000000
> --- a/lib/J3/Classpath/Classpath.inc
> +++ /dev/null
> @@ -1,392 +0,0 @@
> -//===-------- Classpath.cpp - Configuration for classpath
> -------------------===//
> -//
> -// 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 "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -// Define hasClassInitializer because of a buggy implementation in
> Classpath.
> -JNIEXPORT bool JNICALL
> Java_java_io_VMObjectStreamClass_hasClassInitializer(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - llvm_gcroot(Cl, 0);
> - bool res = false;
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(Cl);
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);
> -
> - if (cl->isClass() &&
> -
> cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,
> -
> vm->bootstrapLoader->clinitType,
> - true, false, 0))
> - res = true;
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -
> -// Redefine some VMObjectStreamClass functions because of a slow
> implementation
> -// in Classpath.
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jboolean val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceInt8Field(obj, (uint8)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jbyte val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceInt8Field(obj, (uint8)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jchar val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jshort val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceInt16Field(obj, (sint16)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jint val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceInt32Field(obj, (sint32)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jlong val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceLongField(obj, (sint64)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jfloat val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceFloatField(obj, (float)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jdouble val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceDoubleField(obj, (double)val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, JavaObject* val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(val, 0);
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(obj);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - field->setInstanceObjectField(obj, val);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_io_VMObjectInputStream_allocateObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(target, 0);
> - llvm_gcroot(constr, 0);
> - llvm_gcroot(cons, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl =
> - (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);
> - res = cl->doNew(vm);
> - JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> - meth->invokeIntSpecial(vm, cl, res);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_VMArray_createObjectArray(
> -#ifdef NATIVE_JNI
> -JNIEnv * env,
> -jclass thisClass,
> -#endif
> -JavaObject* arrayType, jint arrayLength) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(arrayType, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* base =
> - UserCommonClass::resolvedImplClass(vm, arrayType, true);
> - JnjvmClassLoader* loader = base->classLoader;
> - const UTF8* name = base->getName();
> - // -1 because we're adding a new dimension in this method.
> - const int kLimit = 255 - 1;
> - const uint16* elements = name->elements;
> - if (name->size > kLimit && elements[kLimit] == '[') {
> - vm->illegalArgumentException("Too many dimensions for array");
> - }
> - const UTF8* arrayName = loader->constructArrayName(1, name);
> - UserClassArray* array = loader->constructArray(arrayName, base);
> - res = array->doNew(arrayLength, vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -
> -// Never throws.
> -JNIEXPORT
> -bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - return false;
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,
> jlong update) {
> -
> - llvm_gcroot(unsafe, 0);
> - llvm_gcroot(obj, 0);
> - jlong *ptr;
> - jlong value;
> -
> - ptr = (jlong *) (((uint8 *) obj) + offset);
> -
> - value = *ptr;
> -
> - if (value == expect) {
> - *ptr = update;
> - return true;
> - } else {
> - return false;
> - }
> -
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint
> update) {
> -
> - llvm_gcroot(unsafe, 0);
> - llvm_gcroot(obj, 0);
> - jint *ptr;
> -
> - ptr = (jint *) (((uint8 *) obj) + offset);
> -
> - return __sync_bool_compare_and_swap(ptr, expect, update);
> -}
> -
> -// Never throws.
> -JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,
> -JavaObject* update) {
> - llvm_gcroot(unsafe, 0);
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(expect, 0);
> - llvm_gcroot(update, 0);
> -
> - JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> -
> - return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,
> (gc**)ptr, (gc*)expect, (gc*)update);
> -}
> -
> -// Never throws.
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {
> - llvm_gcroot(unsafe, 0);
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(value, 0);
> -
> - JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);
> - mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr,
> (gc*)value);
> -}
> -
> -// TODO: Add the Volatile variants
> -#define GET_PUT_OFFSET(Type,jtype,shorttype) \
> -JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##
> __Ljava_lang_Object_2J( \
> -JavaObject* unsafe, JavaObject* base, jlong offset) { \
> - jtype res = 0; \
> - BEGIN_NATIVE_EXCEPTION(0) \
> - jtype* ptr = (jtype*) (((uint8 *) base) + offset); \
> - res = *ptr; \
> - END_NATIVE_EXCEPTION \
> - \
> - return res; \
> -} \
> - \
> -JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##
> __Ljava_lang_Object_2J ## shorttype( \
> -JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \
> - BEGIN_NATIVE_EXCEPTION(0) \
> - jtype* ptr = (jtype*) (((uint8 *) base) + offset); \
> - *ptr = val; \
> - END_NATIVE_EXCEPTION \
> -}
> -
> -GET_PUT_OFFSET(Boolean,jboolean,Z)
> -GET_PUT_OFFSET(Byte,jbyte,B)
> -GET_PUT_OFFSET(Char,jchar,C)
> -GET_PUT_OFFSET(Short,jshort,S)
> -GET_PUT_OFFSET(Int,jint,I)
> -GET_PUT_OFFSET(Long,jlong,J)
> -GET_PUT_OFFSET(Float,jfloat,F)
> -GET_PUT_OFFSET(Double,jdouble,D)
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathConstructor.inc
> b/lib/J3/Classpath/ClasspathConstructor.inc
> deleted file mode 100644
> index 90a315b..0000000
> --- a/lib/J3/Classpath/ClasspathConstructor.inc
> +++ /dev/null
> @@ -1,222 +0,0 @@
> -//===- 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_Constructor_getParameterTypes(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectConstructor* cons) {
> -
> - JavaObject* res = 0;
> -
> - llvm_gcroot(cons, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(cons);
> - UserClass* cl = JavaObjectConstructor::getClass(cons);
> - JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> - JnjvmClassLoader* loader = cl->classLoader;
> -
> - res = meth->getParameterTypes(loader);
> - END_NATIVE_EXCEPTION
> -
> - return (jobject)res;
> -}
> -
> -JNIEXPORT jint JNICALL
> Java_java_lang_reflect_Constructor_getModifiersInternal(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectConstructor* cons) {
> -
> - llvm_gcroot(cons, 0);
> - jint res = 0;
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(cons);
> - JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> - res = meth->access;
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JavaObject* proceedConstructor(JavaObjectConstructor* cons,
> - ArrayObject* args,
> - JavaObject* Clazz, jint index)
> - __attribute__ ((noinline));
> -
> -JavaObject* proceedConstructor(JavaObjectConstructor* cons,
> - ArrayObject* args,
> - JavaObject* Clazz, jint index) {
> - JavaObject* res = 0;
> - JavaObject* excp = 0;
> -
> - llvm_gcroot(cons, 0);
> - llvm_gcroot(args, 0);
> - llvm_gcroot(Clazz, 0);
> - llvm_gcroot(res, 0);
> - llvm_gcroot(excp, 0);
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> - UserClass* cl = JavaObjectConstructor::getClass(cons);
> - sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
> - Signdef* sign = meth->getSignature();
> - sint32 size = sign->nbArguments;
> -
> - if (isAbstract(cl->access)) vm->instantiationException(cl);
> -
> - mvm::ThreadAllocator allocator;
> - // Allocate a buffer to store the arguments.
> - jvalue* buf = size ?
> - (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;
> -
> - if (nbArgs == size) {
> - UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm,
> Clazz, false);
> - UserClass* cl = _cl->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 {
> - meth->invokeIntSpecialBuf(vm, cl, res, buf);
> - } CATCH {
> - excp = th->getJavaException();
> - } END_CATCH;
> - if (excp) {
> - if
> (JavaObject::getClass(excp)->isAssignableFrom(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_Constructor_constructNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectConstructor* cons, ArrayObject* args, JavaObject* Clazz,
> jint index) {
> -
> - JavaObject* res = 0;
> -
> - llvm_gcroot(res, 0);
> - llvm_gcroot(cons, 0);
> - llvm_gcroot(args, 0);
> - llvm_gcroot(Clazz, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - res = proceedConstructor(cons, args, Clazz, index);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT
> -ArrayObject* JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectConstructor* cons) {
> -
> - ArrayObject* res = 0;
> -
> - llvm_gcroot(res, 0);
> - llvm_gcroot(cons, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(cons);
> - UserClass* cl = JavaObjectConstructor::getClass(cons);
> - JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);
> - JnjvmClassLoader* loader = cl->classLoader;
> -
> - res = (ArrayObject*)meth->getExceptionTypes(loader);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_Constructor_getSignature(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectConstructor* Meth) {
> -
> - JavaObject* result = 0;
> -
> - llvm_gcroot(result, 0);
> - llvm_gcroot(Meth, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(Meth);
> - JavaMethod* meth = JavaObjectConstructor::getInternalMethod(Meth);
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - result = vm->internalUTF8ToStr(meth->type);
> -
> - END_NATIVE_EXCEPTION
> -
> - return result;
> -}
> -
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathField.inc
> b/lib/J3/Classpath/ClasspathField.inc
> deleted file mode 100644
> index 5082caa..0000000
> --- a/lib/J3/Classpath/ClasspathField.inc
> +++ /dev/null
> @@ -1,1171 +0,0 @@
> -//===- 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"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -
> -JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field) {
> - jint res = 0;
> -
> - llvm_gcroot(Field, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - res = field->access;
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_getType(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field) {
> -
> - JavaObject* res = 0;
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - JnjvmClassLoader* loader = cl->classLoader;
> - UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);
> - res = fieldCl->getClassDelegatee(vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jint res = 0;
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - const Typedef* type = field->getSignature();
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getLong(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jlong res = 0;
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getBoolean(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jboolean res = 0;
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getFloat(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jfloat res = 0;
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getByte(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jbyte res = 0;
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getChar(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jchar res = 0;
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getShort(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> -
> - jshort res = 0;
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_getDouble(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> - jdouble res = 0;
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_get(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj) {
> -
> -
> - JavaObject* res = 0;
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_set(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* 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();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - jvalue buf;
> - bool stat = isStatic(field->access);
> -
> -
> - if (stat) {
> - cl->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_Field_setBoolean(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jboolean val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setByte(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jbyte val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setChar(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jchar val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setShort(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jshort val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setInt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jint val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setLong(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jlong val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setFloat(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jfloat val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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_Field_setDouble(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectField* Field, JavaObject* obj, jdouble val) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = JavaObjectField::getClass(Field);
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - bool stat = isStatic(field->access);
> -
> - if (stat) {
> - cl->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
> -}
> -
> -// Never throws.
> -JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* Unsafe, JavaObjectField* Field) {
> -
> - llvm_gcroot(Field, 0);
> - llvm_gcroot(Unsafe, 0);
> -
> - JavaField* field = JavaObjectField::getInternalField(Field);
> - return (jlong)field->ptrOffset;
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathMethod.inc
> b/lib/J3/Classpath/ClasspathMethod.inc
> deleted file mode 100644
> index ee5792d..0000000
> --- a/lib/J3/Classpath/ClasspathMethod.inc
> +++ /dev/null
> @@ -1,304 +0,0 @@
> -//===- ClasspathMethod.cpp
> ------------------------------------------------===//
> -//===------------- GNU classpath java/lang/reflect/Method
> -----------------===//
> -//
> -// 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_Method_getModifiersInternal(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectMethod* Meth) {
> -
> - jint res = 0;
> - llvm_gcroot(Meth, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> - res = meth->access;
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getReturnType(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectMethod* Meth) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(Meth, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - UserClass* cl = JavaObjectMethod::getClass(Meth);
> - JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> - JnjvmClassLoader* loader = cl->classLoader;
> - res = meth->getReturnType(loader);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_reflect_Method_getParameterTypes(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectMethod* Meth) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(Meth, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - UserClass* cl = JavaObjectMethod::getClass(Meth);
> - JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> - JnjvmClassLoader* loader = cl->classLoader;
> -
> - res = meth->getParameterTypes(loader);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
> - ArrayObject* args, JavaObject* Cl, jint index)
> - __attribute__((noinline));
> -
> -JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,
> - ArrayObject* args, JavaObject* Cl, jint index) {
> -
> - JavaObject* res = 0;
> - JavaObject* exc = 0;
> -
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Meth, 0);
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(args, 0);
> - llvm_gcroot(Cl, 0);
> - llvm_gcroot(exc, 0);
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> -
> - JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> -
> - sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;
> - Signdef* sign = meth->getSignature();
> - sint32 size = sign->nbArguments;
> -
> - mvm::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->isAssignableFrom(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_Method_invokeNative(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectMethod* Meth, JavaObject* obj, ArrayObject* args,
> JavaObject* Cl, jint index) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Meth, 0);
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(args, 0);
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - res = proceedMethod(Meth, obj, args, Cl, index);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT ArrayObject* JNICALL
> Java_java_lang_reflect_Method_getExceptionTypes(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectMethod* Meth) {
> -
> - ArrayObject* res = 0;
> - llvm_gcroot(Meth, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(Meth);
> - UserClass* cl = JavaObjectMethod::getClass(Meth);
> - JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> - JnjvmClassLoader* loader = cl->classLoader;
> - res = meth->getExceptionTypes(loader);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getSignature(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObjectMethod* Meth) {
> -
> - JavaObject* result = 0;
> - llvm_gcroot(Meth, 0);
> - llvm_gcroot(result, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(Meth);
> - JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - result = vm->internalUTF8ToStr(meth->type);
> -
> - END_NATIVE_EXCEPTION
> -
> - return result;
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathReflect.cpp
> b/lib/J3/Classpath/ClasspathReflect.cpp
> deleted file mode 100644
> index 90bd617..0000000
> --- a/lib/J3/Classpath/ClasspathReflect.cpp
> +++ /dev/null
> @@ -1,30 +0,0 @@
> -//===- 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 "ClasspathReflect.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
> -
> -namespace j3 {
> -
> -JavaMethod*
> JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*
> self) {
> - llvm_gcroot(self, 0);
> - UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
> - return &(cls->asClass()->virtualMethods[self->slot]);
> -}
> -
> -
> -JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
> - llvm_gcroot(self, 0);
> - UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
> - return &(cls->asClass()->virtualMethods[self->slot]);
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathReflect.h
> b/lib/J3/Classpath/ClasspathReflect.h
> deleted file mode 100644
> index d847b98..0000000
> --- a/lib/J3/Classpath/ClasspathReflect.h
> +++ /dev/null
> @@ -1,222 +0,0 @@
> -//===-- ClasspathReflect.h - 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.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -#ifndef JNJVM_CLASSPATH_REFLECT_H
> -#define JNJVM_CLASSPATH_REFLECT_H
> -
> -#include "MvmGC.h"
> -
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
> -
> -extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);
> -
> -namespace j3 {
> -
> -class JavaObjectClass : public JavaObject {
> -private:
> - JavaObject* signers;
> - JavaObject* pd;
> - UserCommonClass* vmdata;
> - JavaObject* constructor;
> -
> -public:
> -
> - static UserCommonClass* getClass(JavaObjectClass* cl) {
> - llvm_gcroot(cl, 0);
> - return cl->vmdata;
> - }
> -
> - static void setClass(JavaObjectClass* cl, UserCommonClass* vmdata) {
> - llvm_gcroot(cl, 0);
> - cl->vmdata = vmdata;
> - }
> -
> - static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
> - llvm_gcroot(cl, 0);
> - llvm_gcroot(pd, 0);
> - mvm::Collector::objectReferenceWriteBarrier(
> - (gc*)cl, (gc**)&(cl->pd), (gc*)pd);
> - }
> -
> - static JavaObject* getProtectionDomain(JavaObjectClass* cl) {
> - llvm_gcroot(cl, 0);
> - return cl->pd;
> - }
> -
> - static void staticTracer(JavaObjectClass* obj, word_t closure) {
> - mvm::Collector::markAndTrace(obj, &obj->pd, closure);
> - mvm::Collector::markAndTrace(obj, &obj->signers, closure);
> - mvm::Collector::markAndTrace(obj, &obj->constructor, closure);
> - if (obj->vmdata) {
> - JavaObject** Obj =
> obj->vmdata->classLoader->getJavaClassLoaderPtr();
> - if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
> - }
> - }
> -};
> -
> -class JavaObjectField : public JavaObject {
> -private:
> - uint8 flag;
> - JavaObjectClass* declaringClass;
> - JavaObject* name;
> - uint32 slot;
> -
> -public:
> -
> - static void staticTracer(JavaObjectField* obj, word_t closure) {
> - mvm::Collector::markAndTrace(obj, &obj->name, closure);
> - mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
> - }
> -
> - static JavaField* getInternalField(JavaObjectField* self) {
> - llvm_gcroot(self, 0);
> - UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> - return &(cls->asClass()->virtualFields[self->slot]);
> - }
> -
> - static UserClass* getClass(JavaObjectField* self) {
> - llvm_gcroot(self, 0);
> - UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> - return cls->asClass();
> - }
> -
> -};
> -
> -class JavaObjectMethod : public JavaObject {
> -private:
> - uint8 flag;
> - JavaObjectClass* declaringClass;
> - JavaObject* name;
> - uint32 slot;
> -
> -public:
> -
> - static void staticTracer(JavaObjectMethod* obj, word_t closure) {
> - mvm::Collector::markAndTrace(obj, &obj->name, closure);
> - mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
> - }
> -
> - static JavaMethod* getInternalMethod(JavaObjectMethod* self);
> -
> - static UserClass* getClass(JavaObjectMethod* self) {
> - llvm_gcroot(self, 0);
> - UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> - return cls->asClass();
> - }
> -
> -};
> -
> -class JavaObjectConstructor : public JavaObject {
> -private:
> - uint8 flag;
> - JavaObjectClass* declaringClass;
> - uint32 slot;
> -
> -public:
> - static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
> - mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
> - }
> -
> - static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
> -
> - static UserClass* getClass(JavaObjectConstructor* self) {
> - llvm_gcroot(self, 0);
> - UserCommonClass* cls =
> JavaObjectClass::getClass(self->declaringClass);
> - return cls->asClass();
> - }
> -
> -};
> -
> -class JavaObjectVMThread : public JavaObject {
> -private:
> - JavaObject* thread;
> - bool running;
> - JavaThread* vmdata;
> -
> -public:
> - static void staticTracer(JavaObjectVMThread* obj, word_t closure) {
> - mvm::Collector::markAndTrace(obj, &obj->thread, closure);
> - }
> -
> - static void setVmdata(JavaObjectVMThread* vmthread,
> - JavaThread* internal_thread) {
> - llvm_gcroot(vmthread, 0);
> - vmthread->vmdata = internal_thread;
> - }
> -
> -};
> -
> -
> -class JavaObjectThrowable : public JavaObject {
> -private:
> - JavaObject* detailedMessage;
> - JavaObject* cause;
> - JavaObject* stackTrace;
> - JavaObject* vmState;
> -
> -public:
> -
> - static void setDetailedMessage(JavaObjectThrowable* self, JavaObject*
> obj) {
> - llvm_gcroot(self, 0);
> - llvm_gcroot(obj, 0);
> - mvm::Collector::objectReferenceWriteBarrier(
> - (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
> - }
> -
> - static void fillInStackTrace(JavaObjectThrowable* self) {
> - JavaObject* stackTrace = NULL;
> - llvm_gcroot(self, 0);
> - llvm_gcroot(stackTrace, 0);
> -
> - stackTrace = internalFillInStackTrace(self);
> - mvm::Collector::objectReferenceWriteBarrier(
> - (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
> -
> - mvm::Collector::objectReferenceWriteBarrier(
> - (gc*)self, (gc**)&(self->cause), (gc*)self);
> -
> - self->stackTrace = NULL;
> - }
> -};
> -
> -class JavaObjectReference : public JavaObject {
> -private:
> - JavaObject* referent;
> - JavaObject* queue;
> - JavaObject* nextOnQueue;
> -
> -public:
> - static void init(JavaObjectReference* self, JavaObject* r, JavaObject*
> q) {
> - llvm_gcroot(self, 0);
> - llvm_gcroot(r, 0);
> - llvm_gcroot(q, 0);
> - mvm::Collector::objectReferenceWriteBarrier(
> - (gc*)self, (gc**)&(self->referent), (gc*)r);
> - mvm::Collector::objectReferenceWriteBarrier(
> - (gc*)self, (gc**)&(self->queue), (gc*)q);
> - }
> -
> - static JavaObject** getReferentPtr(JavaObjectReference* self) {
> - llvm_gcroot(self, 0);
> - return &(self->referent);
> - }
> -
> - static void setReferent(JavaObjectReference* self, JavaObject* r) {
> - llvm_gcroot(self, 0);
> - llvm_gcroot(r, 0);
> - // No write barrier: this is only called by the GC.
> - self->referent = r;
> - }
> -};
> -
> -}
> -
> -#endif
> diff --git a/lib/J3/Classpath/ClasspathVMClass.inc
> b/lib/J3/Classpath/ClasspathVMClass.inc
> deleted file mode 100644
> index 616f1b4..0000000
> --- a/lib/J3/Classpath/ClasspathVMClass.inc
> +++ /dev/null
> @@ -1,645 +0,0 @@
> -//===---- ClasspathVMClass.cpp - GNU classpath java/lang/VMClass
> ----------===//
> -//
> -// 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 "JavaAccess.h"
> -#include "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaString.h"
> -#include "JavaTypes.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -// Never throws
> -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObjectClass* klass) {
> -
> - llvm_gcroot(klass, 0);
> -
> - UserCommonClass* cl = JavaObjectClass::getClass(klass);
> -
> - return cl->isArray();
> -
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_forName(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaString* str,
> -jboolean clinit,
> -JavaObject* loader) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(loader, 0);
> - llvm_gcroot(str, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(str);
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JnjvmClassLoader* JCL =
> - JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> - UserCommonClass* cl = JCL->loadClassFromJavaString(str, true, false);
> -
> - if (cl != NULL && !cl->isPrimitive()) {
> - if (clinit && cl->asClass()) {
> - cl->asClass()->initialiseClass(vm);
> - }
> - res = cl->getClassDelegatee(vm);
> - } else {
> - vm->classNotFoundException(str);
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_VMClass_getDeclaredConstructors(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -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++;
> - }
> - }
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return ret;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredMethods(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -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++;
> - }
> - }
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return ret;
> -}
> -
> -JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl,
> -jboolean ignore) {
> -
> - jint res = 0;
> - llvm_gcroot(Cl, 0);
> -
> - 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;
> - }
> -
> - END_NATIVE_EXCEPTION
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getName(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - JavaObject* result = 0;
> - llvm_gcroot(Cl, 0);
> - llvm_gcroot(result, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> - const UTF8* iname = cl->getName();
> - result = JavaString::internalToJava(iname, vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return result;
> -}
> -
> -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - jboolean res = 0;
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> - res = cl->isPrimitive();
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - jboolean res = 0;
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> - res = cl->isInterface();
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getComponentType(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Cl, 0);
> -
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> - if (cl->isArray()) {
> - UserCommonClass* bc = cl->asArrayClass()->baseClass();
> - res = bc->getClassDelegatee(vm);
> - } else {
> - res = 0;
> - }
> -
> - END_NATIVE_EXCEPTION
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getClassLoader(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> - res = cl->classLoader->getJavaClassLoader();
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl1, JavaObject* Cl2) {
> -
> - jboolean res = 0;
> - llvm_gcroot(Cl1, 0);
> - llvm_gcroot(Cl2, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - if (!Cl2) vm->nullPointerException();
> -
> - UserCommonClass* cl1 = UserCommonClass::resolvedImplClass(vm, Cl1,
> false);
> - UserCommonClass* cl2 = UserCommonClass::resolvedImplClass(vm, Cl2,
> false);
> -
> - res = cl2->isAssignableFrom(cl1);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getSuperclass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(Cl, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> - if (cl->isInterface()) res = 0;
> - else {
> - if (cl->getSuper()) res = cl->getSuper()->getClassDelegatee(vm);
> - else res = 0;
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl, JavaObject* obj) {
> -
> - bool res = false;
> - llvm_gcroot(Cl, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> - res = JavaObject::instanceOf(obj, cl);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredFields(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -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++;
> - }
> - }
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return ret;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getInterfaces(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - ArrayObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Cl, 0);
> -
> - 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);
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaringClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> - JavaObject* res = 0;
> -
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Cl, 0);
> -
> - 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);
> - }
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredClasses(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl, bool publicOnly) {
> -
> - ArrayObject* result = 0;
> - llvm_gcroot(result, 0);
> - llvm_gcroot(Cl, 0);
> -
> - 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);
> - }
> -
> -
> - END_NATIVE_EXCEPTION
> -
> - return result;
> -
> -}
> -
> -// Only throws.
> -JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* throwable) {
> -
> - llvm_gcroot(throwable, 0);
> -
> - assert(throwable && "Using internal VM throw exception without
> exception");
> - JavaThread::get()->pendingException = (JavaObject*)throwable;
> -}
> -
> -JNIEXPORT ArrayObject* Java_java_lang_VMClass_getDeclaredAnnotations(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -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);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT jboolean Java_java_lang_VMClass_isAnonymousClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - jboolean res = false;
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl,
> false)->asClass();
> -
> - if (cl) res = cl->isAnonymous;
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMClassLoader.inc
> b/lib/J3/Classpath/ClasspathVMClassLoader.inc
> deleted file mode 100644
> index 55a76d0..0000000
> --- a/lib/J3/Classpath/ClasspathVMClassLoader.inc
> +++ /dev/null
> @@ -1,380 +0,0 @@
> -//===- ClasspathVMClassLoader.cpp - GNU classpath
> java/lang/VMClassLoader -===//
> -//
> -// 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 "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaString.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -#include "Reader.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_VMClassLoader_getPrimitiveClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -jchar byteId) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClassPrimitive* prim =
> - UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls);
> -
> - if (!prim) {
> - fprintf(stderr, "unknown byte primitive %c", byteId);
> - abort();
> - }
> -
> - res = prim->getClassDelegatee(vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_java_lang_VMClassLoader_findLoadedClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* loader,
> -JavaString* name) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(loader, 0);
> - llvm_gcroot(name, 0);
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JnjvmClassLoader* JCL =
> - JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> - UserCommonClass* cl = JCL->lookupClassFromJavaString(name);
> -
> - if (cl) res = cl->getClassDelegatee(vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -
> - return 0;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_loadClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaString* str,
> -jboolean doResolve) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(str, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> -
> - JnjvmClassLoader* JCL = vm->bootstrapLoader;
> - UserCommonClass* cl = JCL->loadClassFromJavaString(str, doResolve,
> false);
> -
> - if (cl != 0) res = cl->getClassDelegatee(vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_defineClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* loader,
> -JavaString* str,
> -ArrayUInt8* bytes,
> -jint off,
> -jint len,
> -JavaObject* pd) {
> -
> - JavaObject* res = 0;
> - JavaObject* excp = 0;
> - llvm_gcroot(loader, 0);
> - llvm_gcroot(str, 0);
> - llvm_gcroot(bytes, 0);
> - llvm_gcroot(pd, 0);
> - llvm_gcroot(res, 0);
> - llvm_gcroot(excp, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - // We need a name, which is unfortunately not required by the spec.
> - verifyNull(str);
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> -
> - JnjvmClassLoader* JCL =
> - JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);
> -
> - int32_t size = JavaArray::getSize(bytes);
> - ClassBytes* classBytes = new (JCL->allocator, size) ClassBytes(size);
> - memcpy(classBytes->elements, JavaArray::getElements(bytes), size);
> -
> - // Before creating a class, do a check on the bytes.
> - Reader reader(classBytes);
> - uint32 magic = reader.readU4();
> - if (magic != Jnjvm::Magic) {
> - JavaThread::get()->getJVM()->classFormatError("bad magic number");
> - }
> -
> -
> - const UTF8* name = JavaString::javaToInternal(str, JCL->hashUTF8);
> - UserCommonClass* cl = JCL->lookupClass(name);
> -
> - if (!cl) {
> - UserClass* cl = JCL->constructClass(name, classBytes);
> - cl->resolveClass();
> -
> - res = cl->getClassDelegatee(vm, pd);
> - } else {
> - excp = vm->CreateLinkageError("duplicate class definition");
> - JavaThread::get()->throwException(excp);
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - verifyNull(Cl);
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass::resolvedImplClass(vm, Cl, false);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -#define NUM_BOOT_PACKAGES 168
> -
> -static const char* bootPackages[NUM_BOOT_PACKAGES] = {
> - "java.applet",
> - "java.awt",
> - "java.awt.color",
> - "java.awt.datatransfer",
> - "java.awt.dnd",
> - "java.awt.dnd.peer",
> - "java.awt.event",
> - "java.awt.font",
> - "java.awt.geom",
> - "java.awt.im",
> - "java.awt.im.spi",
> - "java.awt.image",
> - "java.awt.image.renderable",
> - "java.awt.peer",
> - "java.awt.print",
> - "java.beans",
> - "java.beans.beancontext",
> - "java.io",
> - "java.lang",
> - "java.lang.annotation",
> - "java.lang.instrument",
> - "java.lang.management",
> - "java.lang.ref",
> - "java.lang.reflect",
> - "java.math",
> - "java.net",
> - "java.nio",
> - "java.nio.channels",
> - "java.nio.channels.spi",
> - "java.nio.charset",
> - "java.nio.charset.spi",
> - "java.rmi",
> - "java.rmi.activation",
> - "java.rmi.dgc",
> - "java.rmi.registry",
> - "java.rmi.server",
> - "java.security",
> - "java.security.acl",
> - "java.security.cert",
> - "java.security.interfaces",
> - "java.security.spec",
> - "java.sql",
> - "java.text",
> - "java.util",
> - "java.util.concurrent",
> - "java.util.concurrent.atomic",
> - "java.util.concurrent.locks",
> - "java.util.jar",
> - "java.util.logging",
> - "java.util.prefs",
> - "java.util.regex",
> - "java.util.zip",
> - "javax.accessibility",
> - "javax.activity",
> - "javax.crypto",
> - "javax.crypto.interfaces",
> - "javax.crypto.spec",
> - "javax.imageio",
> - "javax.imageio.event",
> - "javax.imageio.metadata",
> - "javax.imageio.plugins.bmp",
> - "javax.imageio.plugins.jpeg",
> - "javax.imageio.spi",
> - "javax.imageio.stream",
> - "javax.management",
> - "javax.management.loading",
> - "javax.management.modelmbean",
> - "javax.management.monitor",
> - "javax.management.openmbean",
> - "javax.management.relation",
> - "javax.management.remote",
> - "javax.management.remote.rmi",
> - "javax.management.timer",
> - "javax.naming",
> - "javax.naming.directory",
> - "javax.naming.event",
> - "javax.naming.ldap",
> - "javax.naming.spi",
> - "javax.net",
> - "javax.net.ssl",
> - "javax.print",
> - "javax.print.attribute",
> - "javax.print.attribute.standard",
> - "javax.print.event",
> - "javax.rmi",
> - "javax.rmi.CORBA",
> - "javax.rmi.ssl",
> - "javax.security.auth",
> - "javax.security.auth.callback",
> - "javax.security.auth.kerberos",
> - "javax.security.auth.login",
> - "javax.security.auth.spi",
> - "javax.security.auth.x500",
> - "javax.security.cert",
> - "javax.security.sasl",
> - "javax.sound.midi",
> - "javax.sound.midi.spi",
> - "javax.sound.sampled",
> - "javax.sound.sampled.spi",
> - "javax.sql",
> - "javax.sql.rowset",
> - "javax.sql.rowset.serial",
> - "javax.sql.rowset.spi",
> - "javax.swing",
> - "javax.swing.border",
> - "javax.swing.colorchooser",
> - "javax.swing.event",
> - "javax.swing.filechooser",
> - "javax.swing.plaf",
> - "javax.swing.plaf.basic",
> - "javax.swing.plaf.metal",
> - "javax.swing.plaf.multi",
> - "javax.swing.plaf.synth",
> - "javax.swing.table",
> - "javax.swing.text",
> - "javax.swing.text.html",
> - "javax.swing.text.html.parser",
> - "javax.swing.text.rtf",
> - "javax.swing.tree",
> - "javax.swing.undo",
> - "javax.transaction",
> - "javax.transaction.xa",
> - "javax.xml",
> - "javax.xml.datatype",
> - "javax.xml.namespace",
> - "javax.xml.parsers",
> - "javax.xml.transform",
> - "javax.xml.transform.dom",
> - "javax.xml.transform.sax",
> - "javax.xml.transform.stream",
> - "javax.xml.validation",
> - "javax.xml.xpath",
> - "org.ietf.jgss",
> - "org.omg.CORBA",
> - "org.omg.CORBA_2_3",
> - "org.omg.CORBA_2_3.portable",
> - "org.omg.CORBA.DynAnyPackage",
> - "org.omg.CORBA.ORBPackage",
> - "org.omg.CORBA.portable",
> - "org.omg.CORBA.TypeCodePackage",
> - "org.omg.CosNaming",
> -
> "org.omg.CosNaming.NamingContextExtPackage",
> - "org.omg.CosNaming.NamingContextPackage",
> - "org.omg.Dynamic",
> - "org.omg.DynamicAny",
> - "org.omg.DynamicAny.DynAnyFactoryPackage",
> - "org.omg.DynamicAny.DynAnyPackage",
> - "org.omg.IOP",
> - "org.omg.IOP.CodecFactoryPackage",
> - "org.omg.IOP.CodecPackage",
> - "org.omg.Messaging",
> - "org.omg.PortableInterceptor",
> -
> "org.omg.PortableInterceptor.ORBInitInfoPackage",
> - "org.omg.PortableServer",
> - "org.omg.PortableServer.CurrentPackage",
> - "org.omg.PortableServer.POAManagerPackage",
> - "org.omg.PortableServer.POAPackage",
> - "org.omg.PortableServer.portable",
> -
> "org.omg.PortableServer.ServantLocatorPackage",
> - "org.omg.SendingContext",
> - "org.omg.stub.java.rmi",
> - "org.w3c.dom",
> - "org.w3c.dom.bootstrap",
> - "org.w3c.dom.events",
> - "org.w3c.dom.ls",
> - "org.xml.sax",
> - "org.xml.sax.ext",
> - "org.xml.sax.helpers"
> -};
> -
> -extern "C" ArrayObject* Java_java_lang_VMClassLoader_getBootPackages__() {
> - ArrayObject* obj = 0;
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - obj = (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES,
> vm);
> - for (uint32 i = 0; i < NUM_BOOT_PACKAGES; ++i) {
> - ArrayObject::setElement(obj, vm->asciizToStr(bootPackages[i]), i);
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return obj;
> -}
> -
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMObject.inc
> b/lib/J3/Classpath/ClasspathVMObject.inc
> deleted file mode 100644
> index ab3f0c5..0000000
> --- a/lib/J3/Classpath/ClasspathVMObject.inc
> +++ /dev/null
> @@ -1,170 +0,0 @@
> -//===------ ClasspathVMObject.cpp - GNU classpath java/lang/VMObject
> ------===//
> -//
> -// 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 "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
> -#include "Jnjvm.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_clone(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* src) {
> -
> - JavaObject* res = NULL;
> - JavaObject* tmp = NULL;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(src, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - UserCommonClass* cl = JavaObject::getClass(src);
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - if (cl->isArray()) {
> - UserClassArray* array = cl->asArrayClass();
> - int length = JavaArray::getSize(src);
> - res = array->doNew(length, vm);
> - UserCommonClass* base = array->baseClass();
> - if (base->isPrimitive()) {
> - int size = length << base->asPrimitiveClass()->logSize;
> - memcpy((void*)((uintptr_t)res + sizeof(JavaObject) +
> sizeof(size_t)),
> - (void*)((uintptr_t)src + sizeof(JavaObject) +
> sizeof(size_t)),
> - size);
> - } else {
> - for (int i = 0; i < length; i++) {
> - tmp = ArrayObject::getElement((ArrayObject*)src, i);
> - ArrayObject::setElement((ArrayObject*)res, tmp, i);
> - }
> - }
> - } else {
> - assert(cl->isClass() && "Not a class!");
> - res = cl->asClass()->doNew(vm);
> - while (cl != NULL) {
> - for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {
> - JavaField& field = cl->asClass()->virtualFields[i];
> - if (field.isReference()) {
> - tmp = field.getInstanceObjectField(src);
> - JavaObject** ptr = field.getInstanceObjectFieldPtr(res);
> - mvm::Collector::objectReferenceWriteBarrier((gc*)res,
> (gc**)ptr, (gc*)tmp);
> - } else if (field.isLong()) {
> - field.setInstanceLongField(res,
> field.getInstanceLongField(src));
> - } else if (field.isDouble()) {
> - field.setInstanceDoubleField(res,
> field.getInstanceDoubleField(src));
> - } else if (field.isInt()) {
> - field.setInstanceInt32Field(res,
> field.getInstanceInt32Field(src));
> - } else if (field.isFloat()) {
> - field.setInstanceFloatField(res,
> field.getInstanceFloatField(src));
> - } else if (field.isShort() || field.isChar()) {
> - field.setInstanceInt16Field(res,
> field.getInstanceInt16Field(src));
> - } else if (field.isByte() || field.isBoolean()) {
> - field.setInstanceInt8Field(res,
> field.getInstanceInt8Field(src));
> - } else {
> - UNREACHABLE();
> - }
> - }
> - cl = cl->super;
> - }
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_getClass(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* obj) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - res = JavaObject::getClass(obj)->getClassDelegatee(vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* obj) {
> -
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObject::notifyAll(obj);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMObject_wait(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* obj, jlong ms, jint ns) {
> -
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - uint32 sec = (uint32) (ms / 1000);
> - uint32 usec = (ns / 1000) + 1000 * (ms % 1000);
> - if (ns && !usec) usec = 1;
> - if (sec || usec) {
> - struct timeval t;
> - t.tv_sec = sec;
> - t.tv_usec = usec;
> - JavaObject::timedWait(obj, t);
> - } else {
> - JavaObject::wait(obj);
> - }
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMObject_notify(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* obj) {
> -
> - llvm_gcroot(obj, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObject::notify(obj);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMRuntime.inc
> b/lib/J3/Classpath/ClasspathVMRuntime.inc
> deleted file mode 100644
> index f79daee..0000000
> --- a/lib/J3/Classpath/ClasspathVMRuntime.inc
> +++ /dev/null
> @@ -1,229 +0,0 @@
> -//===------ ClasspathVMRuntime.cpp - GNU classpath
> java/lang/VMRuntime ----===//
> -//
> -// The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -
> -#include "MvmGC.h"
> -
> -#include "types.h"
> -
> -#include "Classpath.h"
> -#include "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaString.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -
> -#include <cstring>
> -#include <unistd.h>
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMRuntime_mapLibraryName(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaString* strLib) {
> -
> - JavaObject* res = 0;
> - ArrayUInt16* array = 0;
> - const ArrayUInt16* utf8Lib = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(array, 0);
> - llvm_gcroot(utf8Lib, 0);
> - llvm_gcroot(strLib, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> -
> - utf8Lib = JavaString::getValue(strLib);
> - uint32 stLib = strLib->offset;
> - sint32 lgLib = strLib->count;
> - sint32 lgPre = vm->bootstrapLoader->prelib->size;
> - sint32 lgPost = vm->bootstrapLoader->postlib->size;
> -
> - uint32 size = (uint32)(lgPre + lgLib + lgPost);
> - array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);
> - uint16* elements = ArrayUInt16::getElements(array);
> -
> - memmove(elements, vm->bootstrapLoader->prelib->elements,
> - lgPre * sizeof(uint16));
> - memmove(&(elements[lgPre]), ArrayUInt16::getElements(utf8Lib) + stLib,
> - lgLib * sizeof(uint16));
> - memmove(&(elements[lgPre + lgLib]),
> vm->bootstrapLoader->postlib->elements,
> - lgPost * sizeof(uint16));
> -
> - res = vm->constructString(array);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -
> -}
> -
> -typedef int (*onLoad_t)(const void**, void*);
> -extern "C" void j3EndJNI(uint32** old);
> -extern "C" void j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame*
> Frame);
> -
> -extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)
> - __attribute__ ((noinline));
> -
> -extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm)
> - __attribute__ ((noinline));
> -
> -extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm) {
> - func(&vm->javavmEnv, res);
> - return 1;
> -}
> -
> -// Calls the JNI_OnLoad function of a dynamic library.
> -extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)
> {
> -
> - onLoad_t onLoad = (onLoad_t)loader->loadInLib("JNI_OnLoad", res);
> -
> - if (onLoad) {
> - uint32 num = 0;
> - uint32* old = 0;
> - mvm::KnownFrame Frame;
> -
> - j3StartJNI(&num, &old, &Frame);
> - doCall(onLoad, res, vm);
> - j3EndJNI(&old);
> - }
> -}
> -
> -// Never throws.
> -JNIEXPORT jint JNICALL Java_java_lang_VMRuntime_nativeLoad(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaString* str,
> -JavaObject* javaLoader) {
> -
> -
> - llvm_gcroot(str, 0);
> - llvm_gcroot(javaLoader, 0);
> -
> - void* res = 0;
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JnjvmClassLoader* loader =
> - JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);
> -
> - mvm::ThreadAllocator allocator;
> - char* buf = JavaString::strToAsciiz(str, &allocator);
> -
> - res = loader->loadLib(buf);
> -
> - if (res) callOnLoad(res, loader, vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res != 0;
> -}
> -
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_gc(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - mvm::Collector::collect();
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - mvm::Collector::collect();
> - // Sleep a bit.
> - sleep(1);
> - return;
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizationForExit(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - return;
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizersOnExit(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -uint8 value
> -) {
> - return;
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMRuntime_exit(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -jint par1) {
> - mvm::System::Exit(par1);
> -}
> -
> -JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - return (jlong)mvm::Collector::getFreeMemory();
> -}
> -
> -JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - return (jlong)mvm::Collector::getTotalMemory();
> -}
> -
> -JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - return (jlong)mvm::Collector::getMaxMemory();
> -}
> -
> -JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> - return mvm::System::GetNumberOfProcessors();
> -}
> -}
> -
> diff --git a/lib/J3/Classpath/ClasspathVMStackWalker.inc
> b/lib/J3/Classpath/ClasspathVMStackWalker.inc
> deleted file mode 100644
> index b0c94e5..0000000
> --- a/lib/J3/Classpath/ClasspathVMStackWalker.inc
> +++ /dev/null
> @@ -1,86 +0,0 @@
> -//===- ClasspathVMStackWalker.cpp
> -----------------------------------------===//
> -//===------------ GNU classpath gnu/classpath/VMStackWalker
> ---------------===//
> -//
> -// 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 "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_gnu_classpath_VMStackWalker_getClassContext(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> -
> - ArrayObject* result = NULL;
> - JavaObject* delegatee = NULL;
> - llvm_gcroot(result, 0);
> - llvm_gcroot(delegatee, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaThread* th = JavaThread::get();
> - Jnjvm* vm = th->getJVM();
> - uint32 length = th->getFrameContextLength();
> -
> - mvm::ThreadAllocator allocator;
> - uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *
> sizeof(uintptr_t));
> -
> - uint32 finalSize = th->getJavaFrameContext((void**)buffer);
> -
> - result = (ArrayObject*)
> - vm->upcalls->stackTraceArray->doNew(finalSize, vm);
> -
> - for (uint32 i = 0; i != finalSize; ++i) {
> - JavaMethod* meth = ((JavaMethod**)buffer)[i];
> - assert(meth && "Wrong stack trace");
> - delegatee = meth->classDef->getClassDelegatee(vm);;
> - ArrayObject::setElement(result, delegatee, i);
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return result;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL
> Java_gnu_classpath_VMStackWalker_getClassLoader(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* Cl) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(Cl, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);
> - res = cl->classLoader->getJavaClassLoader();
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMSystem.inc
> b/lib/J3/Classpath/ClasspathVMSystem.inc
> deleted file mode 100644
> index 20a558e..0000000
> --- a/lib/J3/Classpath/ClasspathVMSystem.inc
> +++ /dev/null
> @@ -1,119 +0,0 @@
> -//===-- ClasspathVMSystem.cpp - GNU classpath java/lang/VMSystem
> ----------===//
> -//
> -// 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 "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
> -#include "Jnjvm.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass _cl,
> -#endif
> -JavaObject* src,
> -jint sstart,
> -JavaObject* dst,
> -jint dstart,
> -jint len) {
> -
> - JavaObject* cur = 0;
> - llvm_gcroot(src, 0);
> - llvm_gcroot(dst, 0);
> - llvm_gcroot(cur, 0);
> - assert(src->getVirtualTable());
> - assert(dst->getVirtualTable());
> -
> - JavaThread* th = JavaThread::get();
> - Jnjvm *vm = th->getJVM();
> -
> - if (src == NULL || dst == NULL) {
> - th->pendingException = vm->CreateNullPointerException();
> - return;
> - }
> -
> - if (!(JavaObject::getClass(src)->isArray() &&
> - JavaObject::getClass(dst)->isArray())) {
> - th->pendingException = vm->CreateArrayStoreException(
> - (JavaVirtualTable*)dst->getVirtualTable());
> - return;
> - }
> -
> - UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);
> - UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);
> - UserCommonClass* dstType = td->baseClass();
> - UserCommonClass* srcType = ts->baseClass();
> -
> - sint32 srcSize = JavaArray::getSize(src);
> - sint32 dstSize = JavaArray::getSize(dst);
> -
> - if (len > srcSize) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(len);
> - } else if (len > dstSize) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(len);
> - } else if (len + sstart > srcSize) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(len +
> sstart);
> - } else if (len + dstart > dstSize) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(len +
> dstart);
> - } else if (dstart < 0) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(dstart);
> - } else if (sstart < 0) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(sstart);
> - } else if (len < 0) {
> - th->pendingException = vm->CreateIndexOutOfBoundsException(len);
> - } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&
> - srcType != dstType) {
> - th->pendingException = vm->CreateArrayStoreException(
> - (JavaVirtualTable*)dst->getVirtualTable());
> - }
> - if (th->pendingException != NULL) return;
> -
> - if (!(dstType->isPrimitive())) {
> - for (int i = 0; i < len; i++) {
> - cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);
> - if (cur) {
> - if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {
> - th->pendingException = vm->CreateArrayStoreException(
> - (JavaVirtualTable*)dst->getVirtualTable());
> - break;
> - } else {
> - ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);
> - }
> - }
> - }
> - } else {
> - uint32 logSize = dstType->asPrimitiveClass()->logSize;
> - void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) +
> (dstart << logSize));
> - void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) +
> (sstart << logSize));
> - memmove(ptrDst, ptrSrc, len << logSize);
> - }
> -
> -}
> -
> -JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* obj) {
> -
> - llvm_gcroot(obj, 0);
> - if (obj == NULL) return 0;
> - return JavaObject::hashCode(obj);
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMSystemProperties.inc
> b/lib/J3/Classpath/ClasspathVMSystemProperties.inc
> deleted file mode 100644
> index abd9195..0000000
> --- a/lib/J3/Classpath/ClasspathVMSystemProperties.inc
> +++ /dev/null
> @@ -1,154 +0,0 @@
> -//===- ClasspathVMSystem/Properties.cpp
> -----------------------------------===//
> -//===--------------------- GNU classpath
> gnu/classpath/VMSystemProperties -===//
> -//
> -// The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -#include <sys/utsname.h>
> -
> -#include "types.h"
> -
> -#include "Classpath.h"
> -#include "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -void setProperty(Jnjvm* vm, JavaObject* prop, const char* key,
> - const char* val) {
> -
> - JavaString* Val = 0;
> - JavaString* Key = 0;
> - llvm_gcroot(prop, 0);
> - llvm_gcroot(Val, 0);
> - llvm_gcroot(Key, 0);
> -
> - Val = vm->asciizToStr(val);
> - Key = vm->asciizToStr(key);
> -
> - vm->upcalls->setProperty->invokeIntSpecial(
> - vm, (UserClass*)JavaObject::getClass(prop), prop, &Key, &Val);
> -}
> -
> -void setUnameProp(Jnjvm* vm, JavaObject* prop) {
> -
> - llvm_gcroot(prop, 0);
> -
> - struct utsname infos;
> - uname(&infos);
> - setProperty(vm, prop, "os.name", infos.sysname);
> - setProperty(vm, prop, "os.arch", infos.machine);
> - setProperty(vm, prop, "os.version", infos.release);
> - if (!strcmp(infos.machine, "ppc")) {
> - setProperty(vm, prop, "gnu.cpu.endian","big");
> - } else {
> - setProperty(vm, prop, "gnu.cpu.endian","little");
> - }
> -}
> -
> -JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* prop) {
> -
> - llvm_gcroot(prop, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - const char* tmp;
> - setProperty(vm, prop, "java.vm.specification.version", "1.0");
> - setProperty(vm, prop, "java.vm.specification.vendor",
> - "Sun Microsystems, Inc");
> - setProperty(vm, prop, "java.vm.specification.name",
> - "Java Virtual Machine Specification");
> - setProperty(vm, prop, "java.specification.version", "1.5");
> - setProperty(vm, prop, "java.specification.vendor", "Sun Microsystems,
> Inc");
> - setProperty(vm, prop, "java.specification.name",
> - "Java Platform API Specification");
> - setProperty(vm, prop, "java.version", "1.5");
> - setProperty(vm, prop, "java.runtime.version", "1.5");
> - setProperty(vm, prop, "java.vendor", "The VMKit Project");
> - setProperty(vm, prop, "java.vendor.url", "http://vmkit.llvm.org");
> -
> - tmp = getenv("JAVA_HOME");
> - if (!tmp) tmp = "";
> - setProperty(vm, prop, "java.home", tmp);
> -
> - JnjvmBootstrapLoader* JCL = vm->bootstrapLoader;
> - setProperty(vm, prop, "java.class.version", "49.0");
> - setProperty(vm, prop, "java.class.path", vm->classpath);
> - setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv);
> - setProperty(vm, prop, "sun.boot.class.path", JCL->bootClasspathEnv);
> - setProperty(vm, prop, "java.vm.version", "0.28");
> - setProperty(vm, prop, "java.vm.vendor", "The VMKit Project");
> - setProperty(vm, prop, "java.vm.name", "J3");
> - setProperty(vm, prop, "java.specification.version", "1.5");
> - setProperty(vm, prop, "java.io.tmpdir", "/tmp");
> -
> - tmp = getenv("JAVA_COMPILER");
> - if (!tmp) tmp = "gcj";
> - setProperty(vm, prop, "java.compiler", tmp);
> -
> - setProperty(vm, prop, "build.compiler", "gcj");
> - setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv);
> - setProperty(vm, prop, "gnu.classpath.boot.library.path",
> - JCL->libClasspathEnv);
> -
> - setUnameProp(vm, prop);
> -
> - setProperty(vm, prop, "file.separator", vm->dirSeparator);
> - setProperty(vm, prop, "path.separator", vm->envSeparator);
> - setProperty(vm, prop, "line.separator", "\n");
> -
> - tmp = getenv("USERNAME");
> - if (!tmp) tmp = getenv("LOGNAME");
> - if (!tmp) tmp = getenv("NAME");
> - if (!tmp) tmp = "";
> - setProperty(vm, prop, "user.name", tmp);
> -
> - tmp = getenv("HOME");
> - if (!tmp) tmp = "";
> - setProperty(vm, prop, "user.home", tmp);
> -
> - tmp = getenv("PWD");
> - if (!tmp) tmp = "";
> - setProperty(vm, prop, "user.dir", tmp);
> -
> - // Disable this property. The Classpath iconv implementation is really
> - // not optimized (it over-abuses JNI calls).
> - //setProperty(vm, prop, "gnu.classpath.nio.charset.provider.iconv",
> "true");
> - setProperty(vm, prop, "file.encoding", "ISO8859_1");
> - setProperty(vm, prop, "gnu.java.util.zoneinfo.dir",
> "/usr/share/zoneinfo");
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -extern "C" void
>
> Java_gnu_classpath_VMSystemProperties_postInit__Ljava_util_Properties_2(JavaObject*
> prop) {
> -
> - llvm_gcroot(prop, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - for (std::vector<std::pair<char*, char*> >::iterator i =
> - vm->postProperties.begin(), e = vm->postProperties.end(); i!= e;
> i++) {
> - setProperty(vm, prop, i->first, i->second);
> - }
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMThread.inc
> b/lib/J3/Classpath/ClasspathVMThread.inc
> deleted file mode 100644
> index e65e822..0000000
> --- a/lib/J3/Classpath/ClasspathVMThread.inc
> +++ /dev/null
> @@ -1,217 +0,0 @@
> -//===- ClasspathVMThread.cpp - GNU classpath java/lang/VMThread
> -----------===//
> -//
> -// 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 "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -// Never throws.
> -// Never calls Java code.
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThread_currentThread(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz
> -#endif
> -) {
> - return JavaThread::get()->currentThread();
> -}
> -
> -void start(JavaThread* thread) {
> -
> - JavaObjectVMThread* vmThread = NULL;
> - JavaObject* javaThread = NULL;
> - llvm_gcroot(vmThread, 0);
> - llvm_gcroot(javaThread, 0);
> -
> - Jnjvm* vm = thread->getJVM();
> - // Wait some time to let the creator initialise these fields.
> - while ((thread->javaThread == NULL) || (thread->vmThread == NULL)) {
> - mvm::Thread::yield();
> - }
> -
> - // Ok, now that the thread is created we can set the the value of
> vmdata,
> - // which is the JavaThread object.
> - vmThread = (JavaObjectVMThread*)thread->vmThread;
> - assert(vmThread && "Didn't fix the vmThread of a j3 thread");
> - assert(vmThread->getVirtualTable());
> - JavaObjectVMThread::setVmdata(vmThread, thread);
> -
> - UserClass* vmthClass = (UserClass*)JavaObject::getClass(vmThread);
> -
> - javaThread = thread->javaThread;
> - assert(javaThread && "Didn't fix the javaThread of a j3 thread");
> - // If the thread is not a daemon, it is added to the list of threads to
> - // wait until exit.
> - bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);
> -
> - if (!isDaemon) {
> - vm->threadSystem.enter();
> - }
> -
> - assert(vmThread->getVirtualTable());
> - assert(javaThread->getVirtualTable());
> - // Run the VMThread::run function
> - vm->upcalls->runVMThread->invokeIntSpecial(vm, vmthClass, vmThread);
> -
> - // Remove the thread from the list.
> - if (!isDaemon) {
> - vm->threadSystem.leave();
> - }
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMThread_start(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* vmThread, sint64 stackSize) {
> -
> - JavaObject* javaThread = 0;
> - llvm_gcroot(vmThread, 0);
> - llvm_gcroot(javaThread, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> -
> - // Classpath has set this field.
> - javaThread = vm->upcalls->assocThread->getInstanceObjectField(vmThread);
> - assert(javaThread && "VMThread with no Java equivalent");
> -
> - JavaThread* th = new JavaThread(vm);
> - if (!th) vm->outOfMemoryError();
> - th->start((void (*)(mvm::Thread*))start);
> - // Now that the thread has been created, initialise its object fields.
> - th->initialise(javaThread, vmThread);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* vmthread) {
> -
> - llvm_gcroot(vmthread, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JavaField* field = vm->upcalls->vmdataVMThread;
> -
> - // It's possible that the thread to be interrupted has not finished
> - // its initialization. Wait until the initialization is done.
> - while (field->getInstanceObjectField(vmthread) == 0)
> - mvm::Thread::yield();
> -
> - JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);
> - th->lockingThread.interruptFlag = 1;
> - mvm::FatLock* lock = th->lockingThread.waitsOn;
> -
> - // If the thread is blocked on a wait. We also verify nextWaiting in
> case
> - // the thread has been notified.
> - if (lock && th->lockingThread.nextWaiting) {
> - th->lockingThread.state = mvm::LockingThread::StateInterrupted;
> -
> - // Make sure the thread is waiting.
> - uint32 locked = 0;
> - while (true) {
> - locked = (lock->tryAcquire() == 0);
> - if (locked || (lock->getOwner() != th && lock->getOwner() != 0))
> - break;
> - else mvm::Thread::yield();
> - }
> -
> - // Interrupt the thread.
> - th->lockingThread.varcond.signal();
> -
> - // Release the lock if we acquired it.
> - if (locked) lock->release(lock->getAssociatedObject(),
> vm->lockSystem);
> - }
> -
> - // Here we could also raise a signal for interrupting I/O
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -// Never throws.
> -// Never calls Java code.
> -JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - JavaThread* th = JavaThread::get();
> - uint32 interrupt = th->lockingThread.interruptFlag;
> - th->lockingThread.interruptFlag = 0;
> - return (jboolean)interrupt;
> -}
> -
> -// Never throws.
> -// Never calls Java code.
> -JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* vmthread) {
> -
> - llvm_gcroot(vmthread, 0);
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JavaField* field = vm->upcalls->vmdataVMThread;
> - JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);
> - return (jboolean)th->lockingThread.interruptFlag;
> -}
> -
> -// Never throws.
> -// Never calls Java code.
> -JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* vmthread, jint prio) {
> - // Currently not implemented
> - llvm_gcroot(vmthread, 0);
> -}
> -
> -// Never throws.
> -// Never calls Java code.
> -JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* vmthread, JavaObject* exc) {
> - // Currently not implemented
> - llvm_gcroot(vmthread, 0);
> - llvm_gcroot(exc, 0);
> -}
> -
> -// Never throws.
> -// Never calls Java code.
> -JNIEXPORT void JNICALL Java_java_lang_VMThread_yield(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -) {
> - mvm::Thread::yield();
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/ClasspathVMThrowable.inc
> b/lib/J3/Classpath/ClasspathVMThrowable.inc
> deleted file mode 100644
> index 8579e9e..0000000
> --- a/lib/J3/Classpath/ClasspathVMThrowable.inc
> +++ /dev/null
> @@ -1,183 +0,0 @@
> -//===- ClasspathVMClassLoader.cpp - GNU classpath
> java/lang/VMClassLoader -===//
> -//
> -// 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 "JavaAccess.h"
> -#include "JavaArray.h"
> -#include "JavaClass.h"
> -#include "JavaConstantPool.h"
> -#include "JavaObject.h"
> -#include "JavaString.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -#include "Reader.h"
> -
> -using namespace j3;
> -
> -extern "C" {
> -
> -JavaObject* internalFillInStackTrace(JavaObject* throwable) {
> -
> - JavaObject* vmThrowable = 0;
> - ArrayPtr* result = 0;
> - llvm_gcroot(throwable, 0);
> - llvm_gcroot(vmThrowable, 0);
> - llvm_gcroot(result, 0);
> -
> - JavaThread* th = JavaThread::get();
> - Jnjvm* vm = th->getJVM();
> -
> - uint32 length = th->getFrameContextLength();
> -
> - if (sizeof(void*) == 4) {
> - ClassArray* cl = vm->upcalls->ArrayOfInt;
> - result = (ArrayPtr*) cl->doNew(length, vm);
> - } else {
> - ClassArray* cl = vm->upcalls->ArrayOfLong;
> - result = (ArrayPtr*) cl->doNew(length, vm);
> - }
> -
> - // Don't call th->getFrameContext because it is not GC-safe.
> - mvm::StackWalker Walker(th);
> - uint32_t i = 0;
> -
> - while (intptr_t ip = *Walker) {
> - ArrayPtr::setElement(result, ip, i);
> - ++i;
> - ++Walker;
> - }
> -
> - // Set the tempory data in the new VMThrowable object.
> - vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);
> - vm->upcalls->vmDataVMThrowable->setInstanceObjectField(vmThrowable,
> result);
> - return vmThrowable;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_fillInStackTrace(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -jclass clazz,
> -#endif
> -JavaObject* throwable) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> - llvm_gcroot(throwable, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - res = internalFillInStackTrace(throwable);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -
> -JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {
> -
> - JavaString* methodName = 0;
> - JavaString* className = 0;
> - JavaString* sourceName = 0;
> - JavaObject* res = 0;
> - llvm_gcroot(methodName, 0);
> - llvm_gcroot(className, 0);
> - llvm_gcroot(sourceName, 0);
> - llvm_gcroot(res, 0);
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JavaMethod* meth = (JavaMethod*)FI->Metadata;
> - methodName = vm->internalUTF8ToStr(meth->name);
> - Class* cl = meth->classDef;
> - className = JavaString::internalToJava(cl->name, vm);
> -
> - Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);
> -
> - // We don't have the bytes if the class was vmjc'ed.
> - if (sourceAtt && cl->getBytes()) {
> - Reader reader(sourceAtt, cl->bytes);
> - uint16 index = reader.readU2();
> - sourceName =
> vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));
> - }
> -
> - bool native = isNative(meth->access);
> - uint16 lineNumber = meth->lookupLineNumber(FI);
> -
> - UserClass* newS = vm->upcalls->newStackTraceElement;
> - res = newS->doNew(vm);
> - vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,
> - &sourceName,
> - lineNumber,
> - &className,
> - &methodName,
> native);
> - return res;
> -}
> -
> -JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_getStackTrace(
> -#ifdef NATIVE_JNI
> -JNIEnv *env,
> -#endif
> -JavaObject* vmthrow, JavaObject* throwable) {
> -
> - ArrayObject* result = NULL;
> - JavaObject* stack = NULL;
> - llvm_gcroot(vmthrow, 0);
> - llvm_gcroot(throwable, 0);
> - llvm_gcroot(result, 0);
> - llvm_gcroot(stack, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - JavaField* field = vm->upcalls->vmDataVMThrowable;
> - stack = field->getInstanceObjectField(vmthrow);
> -
> - // remove the VMThrowable.fillInStackTrace method and the last method
> - // on the stack.
> - sint32 index = 2;;
> - while (index != JavaArray::getSize(stack)) {
> - mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));
> - if (FI->Metadata == NULL) ++index;
> - else {
> - JavaMethod* meth = (JavaMethod*)FI->Metadata;
> - assert(meth && "Wrong stack trace");
> - if (meth->classDef->isAssignableFrom(vm->upcalls->newThrowable)) {
> - ++index;
> - } else break;
> - }
> - }
> -
> - sint32 size = 0;
> - sint32 cur = index;
> - while (cur < JavaArray::getSize(stack)) {
> - mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));
> - ++cur;
> - if (FI->Metadata != NULL) ++size;
> - }
> -
> - result = (ArrayObject*)
> - vm->upcalls->stackTraceArray->doNew(size, vm);
> -
> - cur = 0;
> - for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {
> - mvm::FrameInfo* FI =
> vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));
> - if (FI->Metadata != NULL) {
> - ArrayObject::setElement(result, consStackElement(FI,
> ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);
> - cur++;
> - }
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return result;
> -}
> -
> -}
> diff --git a/lib/J3/Classpath/JavaUpcalls.cpp
> b/lib/J3/Classpath/JavaUpcalls.cpp
> deleted file mode 100644
> index 3ebac59..0000000
> --- a/lib/J3/Classpath/JavaUpcalls.cpp
> +++ /dev/null
> @@ -1,1076 +0,0 @@
> -//===-------- JavaUpcalls.cpp - Upcalls to Java entities
> ------------------===//
> -//
> -// The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -#include "ClasspathReflect.h"
> -#include "JavaAccess.h"
> -#include "JavaClass.h"
> -#include "JavaObject.h"
> -#include "JavaString.h"
> -#include "JavaThread.h"
> -#include "JavaUpcalls.h"
> -#include "Jnjvm.h"
> -#include "ReferenceQueue.h"
> -
> -#define COMPILE_METHODS(cl) \
> - for (CommonClass::method_iterator i = cl->virtualMethods.begin(), \
> - e = cl->virtualMethods.end(); i!= e; ++i) { \
> - i->second->compiledPtr(); \
> - } \
> - \
> - for (CommonClass::method_iterator i = cl->staticMethods.begin(), \
> - e = cl->staticMethods.end(); i!= e; ++i) { \
> - i->second->compiledPtr(); \
> - }
> -
> -
> -using namespace j3;
> -
> -Class* Classpath::newThread;
> -Class* Classpath::newVMThread;
> -JavaField* Classpath::assocThread;
> -JavaField* Classpath::vmdataVMThread;
> -JavaMethod* Classpath::finaliseCreateInitialThread;
> -JavaMethod* Classpath::initVMThread;
> -JavaMethod* Classpath::initThread;
> -JavaMethod* Classpath::groupAddThread;
> -JavaField* Classpath::threadName;
> -JavaField* Classpath::groupName;
> -JavaMethod* Classpath::initGroup;
> -JavaField* Classpath::priority;
> -JavaField* Classpath::daemon;
> -JavaField* Classpath::group;
> -JavaField* Classpath::running;
> -Class* Classpath::threadGroup;
> -JavaField* Classpath::rootGroup;
> -JavaField* Classpath::vmThread;
> -JavaMethod* Classpath::getUncaughtExceptionHandler;
> -JavaMethod* Classpath::uncaughtException;
> -Class* Classpath::inheritableThreadLocal;
> -
> -JavaMethod* Classpath::runVMThread;
> -JavaMethod* Classpath::setContextClassLoader;
> -JavaMethod* Classpath::getSystemClassLoader;
> -Class* Classpath::newString;
> -Class* Classpath::newClass;
> -Class* Classpath::newThrowable;
> -Class* Classpath::newException;
> -JavaMethod* Classpath::initClass;
> -JavaMethod* Classpath::initClassWithProtectionDomain;
> -JavaField* Classpath::vmdataClass;
> -JavaMethod* Classpath::setProperty;
> -JavaMethod* Classpath::initString;
> -JavaMethod* Classpath::getCallingClassLoader;
> -JavaMethod* Classpath::initConstructor;
> -Class* Classpath::newConstructor;
> -ClassArray* Classpath::constructorArrayClass;
> -ClassArray* Classpath::constructorArrayAnnotation;
> -JavaField* Classpath::constructorSlot;
> -JavaMethod* Classpath::initMethod;
> -JavaMethod* Classpath::initField;
> -Class* Classpath::newField;
> -Class* Classpath::newMethod;
> -ClassArray* Classpath::methodArrayClass;
> -ClassArray* Classpath::fieldArrayClass;
> -JavaField* Classpath::methodSlot;
> -JavaField* Classpath::fieldSlot;
> -ClassArray* Classpath::classArrayClass;
> -JavaMethod* Classpath::loadInClassLoader;
> -JavaMethod* Classpath::initVMThrowable;
> -JavaField* Classpath::vmDataVMThrowable;
> -Class* Classpath::newVMThrowable;
> -JavaField* Classpath::bufferAddress;
> -JavaField* Classpath::dataPointer32;
> -JavaField* Classpath::dataPointer64;
> -Class* Classpath::newPointer32;
> -Class* Classpath::newPointer64;
> -Class* Classpath::newDirectByteBuffer;
> -JavaField* Classpath::vmdataClassLoader;
> -JavaMethod* Classpath::InitDirectByteBuffer;
> -Class* Classpath::newClassLoader;
> -
> -
> -JavaField* Classpath::boolValue;
> -JavaField* Classpath::byteValue;
> -JavaField* Classpath::shortValue;
> -JavaField* Classpath::charValue;
> -JavaField* Classpath::intValue;
> -JavaField* Classpath::longValue;
> -JavaField* Classpath::floatValue;
> -JavaField* Classpath::doubleValue;
> -
> -Class* Classpath::newStackTraceElement;
> -ClassArray* Classpath::stackTraceArray;
> -JavaMethod* Classpath::initStackTraceElement;
> -
> -Class* Classpath::voidClass;
> -Class* Classpath::boolClass;
> -Class* Classpath::byteClass;
> -Class* Classpath::shortClass;
> -Class* Classpath::charClass;
> -Class* Classpath::intClass;
> -Class* Classpath::floatClass;
> -Class* Classpath::doubleClass;
> -Class* Classpath::longClass;
> -
> -Class* Classpath::vmStackWalker;
> -
> -Class* Classpath::InvocationTargetException;
> -Class* Classpath::ArrayStoreException;
> -Class* Classpath::ClassCastException;
> -Class* Classpath::IllegalMonitorStateException;
> -Class* Classpath::IllegalArgumentException;
> -Class* Classpath::InterruptedException;
> -Class* Classpath::IndexOutOfBoundsException;
> -Class* Classpath::ArrayIndexOutOfBoundsException;
> -Class* Classpath::NegativeArraySizeException;
> -Class* Classpath::NullPointerException;
> -Class* Classpath::SecurityException;
> -Class* Classpath::ClassFormatError;
> -Class* Classpath::ClassCircularityError;
> -Class* Classpath::NoClassDefFoundError;
> -Class* Classpath::UnsupportedClassVersionError;
> -Class* Classpath::NoSuchFieldError;
> -Class* Classpath::NoSuchMethodError;
> -Class* Classpath::InstantiationError;
> -Class* Classpath::InstantiationException;
> -Class* Classpath::IllegalAccessError;
> -Class* Classpath::IllegalAccessException;
> -Class* Classpath::VerifyError;
> -Class* Classpath::ExceptionInInitializerError;
> -Class* Classpath::LinkageError;
> -Class* Classpath::AbstractMethodError;
> -Class* Classpath::UnsatisfiedLinkError;
> -Class* Classpath::InternalError;
> -Class* Classpath::OutOfMemoryError;
> -Class* Classpath::StackOverflowError;
> -Class* Classpath::UnknownError;
> -Class* Classpath::ClassNotFoundException;
> -Class* Classpath::ArithmeticException;
> -
> -JavaMethod* Classpath::InitInvocationTargetException;
> -JavaMethod* Classpath::InitArrayStoreException;
> -JavaMethod* Classpath::InitClassCastException;
> -JavaMethod* Classpath::InitIllegalMonitorStateException;
> -JavaMethod* Classpath::InitIllegalArgumentException;
> -JavaMethod* Classpath::InitInterruptedException;
> -JavaMethod* Classpath::InitIndexOutOfBoundsException;
> -JavaMethod* Classpath::InitArrayIndexOutOfBoundsException;
> -JavaMethod* Classpath::InitNegativeArraySizeException;
> -JavaMethod* Classpath::InitNullPointerException;
> -JavaMethod* Classpath::InitSecurityException;
> -JavaMethod* Classpath::InitClassFormatError;
> -JavaMethod* Classpath::InitClassCircularityError;
> -JavaMethod* Classpath::InitNoClassDefFoundError;
> -JavaMethod* Classpath::InitUnsupportedClassVersionError;
> -JavaMethod* Classpath::InitNoSuchFieldError;
> -JavaMethod* Classpath::InitNoSuchMethodError;
> -JavaMethod* Classpath::InitInstantiationError;
> -JavaMethod* Classpath::InitInstantiationException;
> -JavaMethod* Classpath::InitIllegalAccessError;
> -JavaMethod* Classpath::InitIllegalAccessException;
> -JavaMethod* Classpath::InitVerifyError;
> -JavaMethod* Classpath::InitExceptionInInitializerError;
> -JavaMethod* Classpath::InitLinkageError;
> -JavaMethod* Classpath::InitAbstractMethodError;
> -JavaMethod* Classpath::InitUnsatisfiedLinkError;
> -JavaMethod* Classpath::InitInternalError;
> -JavaMethod* Classpath::InitOutOfMemoryError;
> -JavaMethod* Classpath::InitStackOverflowError;
> -JavaMethod* Classpath::InitUnknownError;
> -JavaMethod* Classpath::InitClassNotFoundException;
> -JavaMethod* Classpath::InitArithmeticException;
> -JavaMethod* Classpath::InitObject;
> -JavaMethod* Classpath::FinalizeObject;
> -JavaMethod* Classpath::IntToString;
> -
> -JavaMethod* Classpath::SystemArraycopy;
> -JavaMethod* Classpath::VMSystemArraycopy;
> -Class* Classpath::SystemClass;
> -Class* Classpath::EnumClass;
> -
> -JavaMethod* Classpath::ErrorWithExcpNoClassDefFoundError;
> -JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;
> -JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;
> -
> -ClassArray* Classpath::ArrayOfByte;
> -ClassArray* Classpath::ArrayOfChar;
> -ClassArray* Classpath::ArrayOfString;
> -ClassArray* Classpath::ArrayOfInt;
> -ClassArray* Classpath::ArrayOfShort;
> -ClassArray* Classpath::ArrayOfBool;
> -ClassArray* Classpath::ArrayOfLong;
> -ClassArray* Classpath::ArrayOfFloat;
> -ClassArray* Classpath::ArrayOfDouble;
> -ClassArray* Classpath::ArrayOfObject;
> -
> -ClassPrimitive* Classpath::OfByte;
> -ClassPrimitive* Classpath::OfChar;
> -ClassPrimitive* Classpath::OfInt;
> -ClassPrimitive* Classpath::OfShort;
> -ClassPrimitive* Classpath::OfBool;
> -ClassPrimitive* Classpath::OfLong;
> -ClassPrimitive* Classpath::OfFloat;
> -ClassPrimitive* Classpath::OfDouble;
> -ClassPrimitive* Classpath::OfVoid;
> -
> -Class* Classpath::OfObject;
> -
> -JavaField* Classpath::methodClass;
> -JavaField* Classpath::fieldClass;
> -JavaField* Classpath::constructorClass;
> -
> -JavaMethod* Classpath::EnqueueReference;
> -Class* Classpath::newReference;
> -
> -void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,
> - const char* thName, JavaObject* Group) {
> - JavaObjectVMThread* vmth = NULL;
> - JavaObject* th = NULL;
> - JavaObject* name = NULL;
> - llvm_gcroot(Group, 0);
> - llvm_gcroot(vmth, 0);
> - llvm_gcroot(th, 0);
> - llvm_gcroot(name, 0);
> -
> - th = newThread->doNew(vm);
> - myth->javaThread = th;
> - vmth = (JavaObjectVMThread*)newVMThread->doNew(vm);
> - name = vm->asciizToStr(thName);
> -
> - initThread->invokeIntSpecial(vm, newThread, th, &vmth, &name, 1, 0);
> - vmThread->setInstanceObjectField(th, vmth);
> - assocThread->setInstanceObjectField(vmth, th);
> - running->setInstanceInt8Field(vmth, (uint32)1);
> - JavaObjectVMThread::setVmdata(vmth, myth);
> -
> - group->setInstanceObjectField(th, Group);
> - groupAddThread->invokeIntSpecial(vm, threadGroup, Group, &th);
> -
> - finaliseCreateInitialThread->invokeIntStatic(vm,
> inheritableThreadLocal, &th);
> -}
> -
> -void Classpath::InitializeThreading(Jnjvm* vm) {
> -
> - JavaObject* RG = 0;
> - JavaObject* SystemGroup = 0;
> - JavaObject* systemName = 0;
> - llvm_gcroot(RG, 0);
> - llvm_gcroot(SystemGroup, 0);
> - llvm_gcroot(systemName, 0);
> -
> - // Resolve and initialize classes first.
> - newThread->resolveClass();
> - newThread->initialiseClass(vm);
> -
> - newVMThread->resolveClass();
> - newVMThread->initialiseClass(vm);
> -
> - threadGroup->resolveClass();
> - threadGroup->initialiseClass(vm);
> -
> - // Create the main thread
> - RG = rootGroup->getStaticObjectField();
> - assert(RG && "No root group");
> - assert(vm->getMainThread() && "VM did not set its main thread");
> - CreateJavaThread(vm, (JavaThread*)vm->getMainThread(), "main", RG);
> -
> - // Create the "system" group.
> - SystemGroup = threadGroup->doNew(vm);
> - initGroup->invokeIntSpecial(vm, threadGroup, SystemGroup);
> - systemName = vm->asciizToStr("system");
> - groupName->setInstanceObjectField(SystemGroup, systemName);
> -
> - // Create the finalizer thread.
> - assert(vm->getFinalizerThread() && "VM did not set its finalizer
> thread");
> - CreateJavaThread(vm, vm->getFinalizerThread(), "Finalizer",
> SystemGroup);
> -
> - // Create the enqueue thread.
> - assert(vm->getReferenceThread() && "VM did not set its enqueue thread");
> - CreateJavaThread(vm, vm->getReferenceThread(), "Reference",
> SystemGroup);
> -}
> -
> -extern "C" void
> Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2(
> - JavaObjectReference* reference, JavaObject* referent) {
> - llvm_gcroot(reference, 0);
> - llvm_gcroot(referent, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObjectReference::init(reference, referent, 0);
> -
> JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);
> -
> - END_NATIVE_EXCEPTION
> -
> -}
> -
> -extern "C" void
>
> Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
> - JavaObjectReference* reference,
> - JavaObject* referent,
> - JavaObject* queue) {
> - llvm_gcroot(reference, 0);
> - llvm_gcroot(referent, 0);
> - llvm_gcroot(queue, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObjectReference::init(reference, referent, queue);
> -
> JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);
> -
> - END_NATIVE_EXCEPTION
> -
> -}
> -
> -extern "C" void
> Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2(
> - JavaObjectReference* reference, JavaObject* referent) {
> - llvm_gcroot(reference, 0);
> - llvm_gcroot(referent, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObjectReference::init(reference, referent, 0);
> -
> JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);
> -
> - END_NATIVE_EXCEPTION
> -
> -}
> -
> -extern "C" void
>
> Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
> - JavaObjectReference* reference,
> - JavaObject* referent,
> - JavaObject* queue) {
> - llvm_gcroot(reference, 0);
> - llvm_gcroot(referent, 0);
> - llvm_gcroot(queue, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObjectReference::init(reference, referent, queue);
> -
> JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);
> -
> - END_NATIVE_EXCEPTION
> -
> -}
> -
> -extern "C" void
>
> Java_java_lang_ref_PhantomReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
> - JavaObjectReference* reference,
> - JavaObject* referent,
> - JavaObject* queue) {
> - llvm_gcroot(reference, 0);
> - llvm_gcroot(referent, 0);
> - llvm_gcroot(queue, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaObjectReference::init(reference, referent, queue);
> -
> JavaThread::get()->getJVM()->getReferenceThread()->addPhantomReference(reference);
> -
> - END_NATIVE_EXCEPTION
> -}
> -
> -extern "C" JavaString*
> Java_java_lang_VMString_intern__Ljava_lang_String_2(
> - JavaString* obj) {
> - const ArrayUInt16* array = 0;
> - JavaString* res = 0;
> - llvm_gcroot(obj, 0);
> - llvm_gcroot(array, 0);
> - llvm_gcroot(res, 0);
> - // If the string is already interned, just return.
> - if (obj->getVirtualTable() == JavaString::internStringVT) return obj;
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - array = JavaString::strToArray(obj, vm);
> - res = vm->constructString(array);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -extern "C" uint8 Java_java_lang_Class_isArray__(JavaObjectClass* klass) {
> - llvm_gcroot(klass, 0);
> - UserCommonClass* cl = 0;
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - cl = JavaObjectClass::getClass(klass);
> -
> - END_NATIVE_EXCEPTION
> -
> - return (uint8)cl->isArray();
> -}
> -
> -extern "C" JavaObject*
> Java_gnu_classpath_VMStackWalker_getCallingClass__() {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaThread* th = JavaThread::get();
> - UserClass* cl = th->getCallingClassLevel(2);
> - if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -extern "C" JavaObject*
> Java_gnu_classpath_VMStackWalker_getCallingClassLoader__() {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaThread* th = JavaThread::get();
> - UserClass* cl = th->getCallingClassLevel(2);
> - res = cl->classLoader->getJavaClassLoader();
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -extern "C" JavaObject*
> Java_gnu_classpath_VMStackWalker_firstNonNullClassLoader__() {
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaThread* th = JavaThread::get();
> - res = th->getNonNullClassLoader();
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -extern "C" JavaObject*
> Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {
> -
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - JavaThread* th = JavaThread::get();
> - Jnjvm* vm = th->getJVM();
> - UserClass* cl = th->getCallingClassLevel(index);
> - if (cl) res = cl->getClassDelegatee(vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -extern "C" JavaObject*
> Java_java_lang_reflect_AccessibleObject_getAnnotation__Ljava_lang_Class_2(
> - JavaObject* obj) {
> - llvm_gcroot(obj, 0);
> - return 0;
> -}
> -
> -extern "C" JavaObject*
> Java_java_lang_reflect_AccessibleObject_getDeclaredAnnotations__() {
> - JavaObject* res = 0;
> - llvm_gcroot(res, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
> - res = array->doNew(0, vm);
> -
> - END_NATIVE_EXCEPTION
> -
> - return res;
> -}
> -
> -extern "C" void nativeJavaObjectClassTracer(
> - JavaObjectClass* obj, word_t closure) {
> - JavaObjectClass::staticTracer(obj, closure);
> -}
> -
> -extern "C" void nativeJavaObjectFieldTracer(
> - JavaObjectField* obj, word_t closure) {
> - JavaObjectField::staticTracer(obj, closure);
> -}
> -
> -extern "C" void nativeJavaObjectMethodTracer(
> - JavaObjectMethod* obj, word_t closure) {
> - JavaObjectMethod::staticTracer(obj, closure);
> -}
> -
> -extern "C" void nativeJavaObjectConstructorTracer(
> - JavaObjectConstructor* obj, word_t closure) {
> - JavaObjectConstructor::staticTracer(obj, closure);
> -}
> -
> -extern "C" void nativeJavaObjectVMThreadTracer(
> - JavaObjectVMThread* obj, word_t closure) {
> - JavaObjectVMThread::staticTracer(obj, closure);
> -}
> -
> -extern "C" JavaString*
> Java_java_lang_VMSystem_getenv__Ljava_lang_String_2(JavaString* str) {
> - JavaString* ret = 0;
> - llvm_gcroot(str, 0);
> - llvm_gcroot(ret, 0);
> -
> - BEGIN_NATIVE_EXCEPTION(0)
> -
> - mvm::ThreadAllocator allocator;
> - char* buf = JavaString::strToAsciiz(str, &allocator);
> - char* res = getenv(buf);
> - if (res) {
> - Jnjvm* vm = JavaThread::get()->getJVM();
> - ret = vm->asciizToStr(res);
> - }
> -
> - END_NATIVE_EXCEPTION
> -
> - return ret;
> -}
> -
> -void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
> -
> - newClassLoader =
> - UPCALL_CLASS(loader, "java/lang/ClassLoader");
> -
> - getSystemClassLoader =
> - UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader",
> - "()Ljava/lang/ClassLoader;", ACC_STATIC);
> -
> - setContextClassLoader =
> - UPCALL_METHOD(loader, "java/lang/Thread", "setContextClassLoader",
> - "(Ljava/lang/ClassLoader;)V", ACC_VIRTUAL);
> -
> - newString =
> - UPCALL_CLASS(loader, "java/lang/String");
> -
> - newClass =
> - UPCALL_CLASS(loader, "java/lang/Class");
> -
> - newThrowable =
> - UPCALL_CLASS(loader, "java/lang/Throwable");
> -
> - newException =
> - UPCALL_CLASS(loader, "java/lang/Exception");
> -
> - newPointer32 =
> - UPCALL_CLASS(loader, "gnu/classpath/Pointer32");
> -
> - newPointer64 =
> - UPCALL_CLASS(loader, "gnu/classpath/Pointer64");
> -
> - newDirectByteBuffer =
> - UPCALL_CLASS(loader, "java/nio/DirectByteBufferImpl$ReadWrite");
> -
> - InitDirectByteBuffer =
> - UPCALL_METHOD(loader, "java/nio/DirectByteBufferImpl$ReadWrite",
> "<init>",
> - "(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V",
> - ACC_VIRTUAL);
> -
> - initClass =
> - UPCALL_METHOD(loader, "java/lang/Class", "<init>",
> "(Ljava/lang/Object;)V",
> - ACC_VIRTUAL);
> -
> - initClassWithProtectionDomain =
> - UPCALL_METHOD(loader, "java/lang/Class", "<init>",
> - "(Ljava/lang/Object;Ljava/security/ProtectionDomain;)V",
> - ACC_VIRTUAL);
> -
> - vmdataClass =
> - UPCALL_FIELD(loader, "java/lang/Class", "vmdata",
> "Ljava/lang/Object;",
> - ACC_VIRTUAL);
> -
> - setProperty =
> - UPCALL_METHOD(loader, "java/util/Properties", "setProperty",
> -
> "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
> - ACC_VIRTUAL);
> -
> - initString =
> - UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V",
> ACC_VIRTUAL);
> -
> - initConstructor =
> - UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",
> - "(Ljava/lang/Class;I)V", ACC_VIRTUAL);
> -
> - newConstructor =
> - UPCALL_CLASS(loader, "java/lang/reflect/Constructor");
> -
> - constructorArrayClass =
> - UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);
> -
> - constructorArrayAnnotation =
> - UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);
> -
> - constructorSlot =
> - UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot",
> "I", ACC_VIRTUAL);
> -
> - initMethod =
> - UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",
> - "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
> -
> - newMethod =
> - UPCALL_CLASS(loader, "java/lang/reflect/Method");
> -
> - methodArrayClass =
> - UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);
> -
> - methodSlot =
> - UPCALL_FIELD(loader, "java/lang/reflect/Method", "slot", "I",
> ACC_VIRTUAL);
> -
> - initField =
> - UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",
> - "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
> -
> - newField =
> - UPCALL_CLASS(loader, "java/lang/reflect/Field");
> -
> - fieldArrayClass =
> - UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);
> -
> - fieldSlot =
> - UPCALL_FIELD(loader, "java/lang/reflect/Field", "slot", "I",
> ACC_VIRTUAL);
> -
> -
> - classArrayClass =
> - UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);
> -
> - newVMThrowable =
> - UPCALL_CLASS(loader, "java/lang/VMThrowable");
> -
> - initVMThrowable =
> - UPCALL_METHOD(loader, "java/lang/VMThrowable", "<init>", "()V",
> ACC_VIRTUAL);
> -
> - vmDataVMThrowable =
> - UPCALL_FIELD(loader, "java/lang/VMThrowable", "vmdata",
> "Ljava/lang/Object;",
> - ACC_VIRTUAL);
> -
> - bufferAddress =
> - UPCALL_FIELD(loader, "java/nio/Buffer", "address",
> "Lgnu/classpath/Pointer;",
> - ACC_VIRTUAL);
> -
> - dataPointer32 =
> - UPCALL_FIELD(loader, "gnu/classpath/Pointer32", "data", "I",
> ACC_VIRTUAL);
> -
> - dataPointer64 =
> - UPCALL_FIELD(loader, "gnu/classpath/Pointer64", "data", "J",
> ACC_VIRTUAL);
> -
> - vmdataClassLoader =
> - UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",
> "Ljava/lang/Object;",
> - ACC_VIRTUAL);
> -
> - newStackTraceElement =
> - UPCALL_CLASS(loader, "java/lang/StackTraceElement");
> -
> - stackTraceArray =
> - UPCALL_ARRAY_CLASS(loader, "java/lang/StackTraceElement", 1);
> -
> - initStackTraceElement =
> - UPCALL_METHOD(loader, "java/lang/StackTraceElement", "<init>",
> -
> "(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Z)V",
> - ACC_VIRTUAL);
> -
> - boolValue =
> - UPCALL_FIELD(loader, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);
> -
> - byteValue =
> - UPCALL_FIELD(loader, "java/lang/Byte", "value", "B", ACC_VIRTUAL);
> -
> - shortValue =
> - UPCALL_FIELD(loader, "java/lang/Short", "value", "S", ACC_VIRTUAL);
> -
> - charValue =
> - UPCALL_FIELD(loader, "java/lang/Character", "value", "C",
> ACC_VIRTUAL);
> -
> - intValue =
> - UPCALL_FIELD(loader, "java/lang/Integer", "value", "I", ACC_VIRTUAL);
> -
> - longValue =
> - UPCALL_FIELD(loader, "java/lang/Long", "value", "J", ACC_VIRTUAL);
> -
> - floatValue =
> - UPCALL_FIELD(loader, "java/lang/Float", "value", "F", ACC_VIRTUAL);
> -
> - doubleValue =
> - UPCALL_FIELD(loader, "java/lang/Double", "value", "D", ACC_VIRTUAL);
> -
> - Classpath::voidClass =
> - UPCALL_CLASS(loader, "java/lang/Void");
> -
> - Classpath::boolClass =
> - UPCALL_CLASS(loader, "java/lang/Boolean");
> -
> - Classpath::byteClass =
> - UPCALL_CLASS(loader, "java/lang/Byte");
> -
> - Classpath::shortClass =
> - UPCALL_CLASS(loader, "java/lang/Short");
> -
> - Classpath::charClass =
> - UPCALL_CLASS(loader, "java/lang/Character");
> -
> - Classpath::intClass =
> - UPCALL_CLASS(loader, "java/lang/Integer");
> -
> - Classpath::floatClass =
> - UPCALL_CLASS(loader, "java/lang/Float");
> -
> - Classpath::doubleClass =
> - UPCALL_CLASS(loader, "java/lang/Double");
> -
> - Classpath::longClass =
> - UPCALL_CLASS(loader, "java/lang/Long");
> -
> - Classpath::OfObject =
> - UPCALL_CLASS(loader, "java/lang/Object");
> -
> - vmStackWalker =
> - UPCALL_CLASS(loader, "gnu/classpath/VMStackWalker");
> -
> - loadInClassLoader =
> - UPCALL_METHOD(loader, "java/lang/ClassLoader", "loadClass",
> - "(Ljava/lang/String;)Ljava/lang/Class;", ACC_VIRTUAL);
> -
> - JavaMethod* internString =
> - UPCALL_METHOD(loader, "java/lang/VMString", "intern",
> - "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
> - internString->setNative();
> -
> - JavaMethod* isArray =
> - UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z",
> ACC_VIRTUAL);
> - isArray->setNative();
> -
> - // Make sure classes the JIT optimizes on are loaded.
> - UPCALL_CLASS(loader, "java/lang/VMFloat");
> - UPCALL_CLASS(loader, "java/lang/VMDouble");
> -
> - UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException);
> - UPCALL_CLASS_EXCEPTION(loader, ArrayStoreException);
> - UPCALL_CLASS_EXCEPTION(loader, ClassCastException);
> - UPCALL_CLASS_EXCEPTION(loader, IllegalMonitorStateException);
> - UPCALL_CLASS_EXCEPTION(loader, IllegalArgumentException);
> - UPCALL_CLASS_EXCEPTION(loader, InterruptedException);
> - UPCALL_CLASS_EXCEPTION(loader, IndexOutOfBoundsException);
> - UPCALL_CLASS_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
> - UPCALL_CLASS_EXCEPTION(loader, NegativeArraySizeException);
> - UPCALL_CLASS_EXCEPTION(loader, NullPointerException);
> - UPCALL_CLASS_EXCEPTION(loader, SecurityException);
> - UPCALL_CLASS_EXCEPTION(loader, ClassFormatError);
> - UPCALL_CLASS_EXCEPTION(loader, ClassCircularityError);
> - UPCALL_CLASS_EXCEPTION(loader, NoClassDefFoundError);
> - UPCALL_CLASS_EXCEPTION(loader, UnsupportedClassVersionError);
> - UPCALL_CLASS_EXCEPTION(loader, NoSuchFieldError);
> - UPCALL_CLASS_EXCEPTION(loader, NoSuchMethodError);
> - UPCALL_CLASS_EXCEPTION(loader, InstantiationError);
> - UPCALL_CLASS_EXCEPTION(loader, InstantiationException);
> - UPCALL_CLASS_EXCEPTION(loader, IllegalAccessError);
> - UPCALL_CLASS_EXCEPTION(loader, IllegalAccessException);
> - UPCALL_CLASS_EXCEPTION(loader, VerifyError);
> - UPCALL_CLASS_EXCEPTION(loader, ExceptionInInitializerError);
> - UPCALL_CLASS_EXCEPTION(loader, LinkageError);
> - UPCALL_CLASS_EXCEPTION(loader, AbstractMethodError);
> - UPCALL_CLASS_EXCEPTION(loader, UnsatisfiedLinkError);
> - UPCALL_CLASS_EXCEPTION(loader, InternalError);
> - UPCALL_CLASS_EXCEPTION(loader, OutOfMemoryError);
> - UPCALL_CLASS_EXCEPTION(loader, StackOverflowError);
> - UPCALL_CLASS_EXCEPTION(loader, UnknownError);
> - UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);
> - UPCALL_CLASS_EXCEPTION(loader, ArithmeticException);
> -
> - UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);
> - UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);
> - UPCALL_METHOD_EXCEPTION(loader, ClassCastException);
> - UPCALL_METHOD_EXCEPTION(loader, IllegalMonitorStateException);
> - UPCALL_METHOD_EXCEPTION(loader, IllegalArgumentException);
> - UPCALL_METHOD_EXCEPTION(loader, InterruptedException);
> - UPCALL_METHOD_EXCEPTION(loader, IndexOutOfBoundsException);
> - UPCALL_METHOD_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
> - UPCALL_METHOD_EXCEPTION(loader, NegativeArraySizeException);
> - UPCALL_METHOD_EXCEPTION(loader, NullPointerException);
> - UPCALL_METHOD_EXCEPTION(loader, SecurityException);
> - UPCALL_METHOD_EXCEPTION(loader, ClassFormatError);
> - UPCALL_METHOD_EXCEPTION(loader, ClassCircularityError);
> - UPCALL_METHOD_EXCEPTION(loader, NoClassDefFoundError);
> - UPCALL_METHOD_EXCEPTION(loader, UnsupportedClassVersionError);
> - UPCALL_METHOD_EXCEPTION(loader, NoSuchFieldError);
> - UPCALL_METHOD_EXCEPTION(loader, NoSuchMethodError);
> - UPCALL_METHOD_EXCEPTION(loader, InstantiationError);
> - UPCALL_METHOD_EXCEPTION(loader, InstantiationException);
> - UPCALL_METHOD_EXCEPTION(loader, IllegalAccessError);
> - UPCALL_METHOD_EXCEPTION(loader, IllegalAccessException);
> - UPCALL_METHOD_EXCEPTION(loader, VerifyError);
> - UPCALL_METHOD_EXCEPTION(loader, ExceptionInInitializerError);
> - UPCALL_METHOD_EXCEPTION(loader, LinkageError);
> - UPCALL_METHOD_EXCEPTION(loader, AbstractMethodError);
> - UPCALL_METHOD_EXCEPTION(loader, UnsatisfiedLinkError);
> - UPCALL_METHOD_EXCEPTION(loader, InternalError);
> - UPCALL_METHOD_EXCEPTION(loader, OutOfMemoryError);
> - UPCALL_METHOD_EXCEPTION(loader, StackOverflowError);
> - UPCALL_METHOD_EXCEPTION(loader, UnknownError);
> - UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);
> - UPCALL_METHOD_EXCEPTION(loader, ArithmeticException);
> -
> - UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);
> - UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
> - UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);
> -
> - InitObject = UPCALL_METHOD(loader, "java/lang/Object", "<init>", "()V",
> - ACC_VIRTUAL);
> -
> - FinalizeObject = UPCALL_METHOD(loader, "java/lang/Object", "finalize",
> "()V",
> - ACC_VIRTUAL);
> -
> - IntToString = UPCALL_METHOD(loader, "java/lang/Integer", "toString",
> - "(II)Ljava/lang/String;", ACC_STATIC);
> -
> - SystemArraycopy = UPCALL_METHOD(loader, "java/lang/System", "arraycopy",
> -
> "(Ljava/lang/Object;ILjava/lang/Object;II)V",
> - ACC_STATIC);
> -
> - VMSystemArraycopy = UPCALL_METHOD(loader, "java/lang/VMSystem",
> "arraycopy",
> -
> "(Ljava/lang/Object;ILjava/lang/Object;II)V",
> - ACC_STATIC);
> -
> - SystemClass = UPCALL_CLASS(loader, "java/lang/System");
> - EnumClass = UPCALL_CLASS(loader, "java/lang/Enum");
> -
> - newThread =
> - UPCALL_CLASS(loader, "java/lang/Thread");
> -
> - newVMThread =
> - UPCALL_CLASS(loader, "java/lang/VMThread");
> -
> - assocThread =
> - UPCALL_FIELD(loader, "java/lang/VMThread", "thread",
> "Ljava/lang/Thread;",
> - ACC_VIRTUAL);
> -
> - vmdataVMThread =
> - UPCALL_FIELD(loader, "java/lang/VMThread", "vmdata",
> "Ljava/lang/Object;",
> - ACC_VIRTUAL);
> -
> - inheritableThreadLocal =
> - UPCALL_CLASS(loader, "java/lang/InheritableThreadLocal");
> -
> - finaliseCreateInitialThread =
> - UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal",
> "newChildThread",
> - "(Ljava/lang/Thread;)V", ACC_STATIC);
> -
> - initThread =
> - UPCALL_METHOD(loader, "java/lang/Thread", "<init>",
> - "(Ljava/lang/VMThread;Ljava/lang/String;IZ)V",
> ACC_VIRTUAL);
> -
> - initVMThread =
> - UPCALL_METHOD(loader, "java/lang/VMThread", "<init>",
> - "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
> -
> - runVMThread =
> - UPCALL_METHOD(loader, "java/lang/VMThread", "run", "()V",
> ACC_VIRTUAL);
> -
> -
> - groupAddThread =
> - UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread",
> - "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
> -
> - initGroup =
> - UPCALL_METHOD(loader, "java/lang/ThreadGroup", "<init>",
> - "()V", ACC_VIRTUAL);
> -
> - groupName =
> - UPCALL_FIELD(loader, "java/lang/ThreadGroup", "name",
> "Ljava/lang/String;",
> - ACC_VIRTUAL);
> -
> - threadName =
> - UPCALL_FIELD(loader, "java/lang/Thread", "name",
> "Ljava/lang/String;",
> - ACC_VIRTUAL);
> -
> -
> - priority =
> - UPCALL_FIELD(loader, "java/lang/Thread", "priority", "I",
> ACC_VIRTUAL);
> -
> - daemon =
> - UPCALL_FIELD(loader, "java/lang/Thread", "daemon", "Z", ACC_VIRTUAL);
> -
> - group =
> - UPCALL_FIELD(loader, "java/lang/Thread", "group",
> - "Ljava/lang/ThreadGroup;", ACC_VIRTUAL);
> -
> - running =
> - UPCALL_FIELD(loader, "java/lang/VMThread", "running", "Z",
> ACC_VIRTUAL);
> -
> - threadGroup =
> - UPCALL_CLASS(loader, "java/lang/ThreadGroup");
> -
> - rootGroup =
> - UPCALL_FIELD(loader, "java/lang/ThreadGroup", "root",
> - "Ljava/lang/ThreadGroup;", ACC_STATIC);
> -
> - vmThread =
> - UPCALL_FIELD(loader, "java/lang/Thread", "vmThread",
> - "Ljava/lang/VMThread;", ACC_VIRTUAL);
> -
> - getUncaughtExceptionHandler =
> - UPCALL_METHOD(loader, "java/lang/Thread",
> "getUncaughtExceptionHandler",
> - "()Ljava/lang/Thread$UncaughtExceptionHandler;",
> ACC_VIRTUAL);
> -
> - uncaughtException =
> - UPCALL_METHOD(loader, "java/lang/Thread$UncaughtExceptionHandler",
> - "uncaughtException",
> - "(Ljava/lang/Thread;Ljava/lang/Throwable;)V",
> ACC_VIRTUAL);
> -
> -
> - methodClass =
> - UPCALL_FIELD(loader, "java/lang/reflect/Method", "declaringClass",
> - "Ljava/lang/Class;", ACC_VIRTUAL);
> -
> - fieldClass =
> - UPCALL_FIELD(loader, "java/lang/reflect/Field", "declaringClass",
> - "Ljava/lang/Class;", ACC_VIRTUAL);
> -
> - constructorClass =
> - UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "clazz",
> - "Ljava/lang/Class;", ACC_VIRTUAL);
> -
> - loader->loadName(loader->asciizConstructUTF8("java/lang/String"),
> - true, false, NULL);
> -
> - loader->loadName(loader->asciizConstructUTF8("java/lang/Object"),
> - true, false, NULL);
> -
> - // Don't compile methods here, we still don't know where to allocate
> Java
> - // strings.
> -
> - JavaMethod* getEnv =
> - UPCALL_METHOD(loader, "java/lang/VMSystem", "getenv",
> - "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
> - getEnv->setNative();
> -
> - JavaMethod* getCallingClass =
> - UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
> "getCallingClass",
> - "()Ljava/lang/Class;", ACC_STATIC);
> - getCallingClass->setNative();
> -
> - JavaMethod* getCallingClassLoader =
> - UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
> "getCallingClassLoader",
> - "()Ljava/lang/ClassLoader;", ACC_STATIC);
> - getCallingClassLoader->setNative();
> -
> - JavaMethod* firstNonNullClassLoader =
> - UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
> "firstNonNullClassLoader",
> - "()Ljava/lang/ClassLoader;", ACC_STATIC);
> - firstNonNullClassLoader->setNative();
> -
> - JavaMethod* getCallerClass =
> - UPCALL_METHOD(loader, "sun/reflect/Reflection", "getCallerClass",
> - "(I)Ljava/lang/Class;", ACC_STATIC);
> - getCallerClass->setNative();
> -
> - JavaMethod* postProperties =
> - UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit",
> - "(Ljava/util/Properties;)V", ACC_STATIC);
> - postProperties->setNative();
> -
> - // Also implement these twos, implementation in GNU Classpath
> 0.97.2 is buggy.
> - JavaMethod* getAnnotation =
> - UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",
> "getAnnotation",
> - "(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;",
> - ACC_VIRTUAL);
> - getAnnotation->setNative();
> -
> - JavaMethod* getAnnotations =
> - UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",
> - "getDeclaredAnnotations",
> - "()[Ljava/lang/annotation/Annotation;",
> - ACC_VIRTUAL);
> - getAnnotations->setNative();
> -
> - JavaMethod* getBootPackages =
> - UPCALL_METHOD(loader, "java/lang/VMClassLoader", "getBootPackages",
> - "()[Ljava/lang/String;", ACC_STATIC);
> - getBootPackages->setNative();
> -
> -
> //===----------------------------------------------------------------------===//
> - //
> - // To make classes non GC-allocated, we have to bypass the tracer
> functions of
> - // java.lang.Class, java.lang.reflect.Field, java.lang.reflect.Method
> and
> - // java.lang.reflect.constructor. The new tracer functions trace
> the classloader
> - // instead of the class/field/method.
> - //
> -
> //===----------------------------------------------------------------------===//
> -
> - newClass->getVirtualVT()->setNativeTracer(
> - (word_t)nativeJavaObjectClassTracer,
> - "nativeJavaObjectClassTracer");
> -
> - newConstructor->getVirtualVT()->setNativeTracer(
> - (word_t)nativeJavaObjectConstructorTracer,
> - "nativeJavaObjectConstructorTracer");
> -
> - newMethod->getVirtualVT()->setNativeTracer(
> - (word_t)nativeJavaObjectMethodTracer,
> - "nativeJavaObjectMethodTracer");
> -
> - newField->getVirtualVT()->setNativeTracer(
> - (word_t)nativeJavaObjectFieldTracer,
> - "nativeJavaObjectFieldTracer");
> -
> - newVMThread->getVirtualVT()->setNativeTracer(
> - (word_t)nativeJavaObjectVMThreadTracer,
> - "nativeJavaObjectVMThreadTracer");
> -
> - newReference = UPCALL_CLASS(loader, "java/lang/ref/Reference");
> -
> - EnqueueReference =
> - UPCALL_METHOD(loader, "java/lang/ref/Reference", "enqueue", "()Z",
> - ACC_VIRTUAL);
> -
> - JavaMethod* initWeakReference =
> - UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
> - "(Ljava/lang/Object;)V",
> - ACC_VIRTUAL);
> - initWeakReference->setNative();
> -
> - initWeakReference =
> - UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
> - "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
> - ACC_VIRTUAL);
> - initWeakReference->setNative();
> -
> - JavaMethod* initSoftReference =
> - UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",
> - "(Ljava/lang/Object;)V",
> - ACC_VIRTUAL);
> - initSoftReference->setNative();
> -
> - initSoftReference =
> - UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",
> - "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
> - ACC_VIRTUAL);
> - initSoftReference->setNative();
> -
> - JavaMethod* initPhantomReference =
> - UPCALL_METHOD(loader, "java/lang/ref/PhantomReference", "<init>",
> - "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
> - ACC_VIRTUAL);
> - initPhantomReference->setNative();
> -}
> -
> -#include "ClasspathConstructor.inc"
> -#include "Classpath.inc"
> -#include "ClasspathField.inc"
> -#include "ClasspathMethod.inc"
> -#include "ClasspathVMClass.inc"
> -#include "ClasspathVMClassLoader.inc"
> -#include "ClasspathVMObject.inc"
> -#include "ClasspathVMRuntime.inc"
> -#include "ClasspathVMStackWalker.inc"
> -#include "ClasspathVMSystem.inc"
> -#include "ClasspathVMSystemProperties.inc"
> -#include "ClasspathVMThread.inc"
> -#include "ClasspathVMThrowable.inc"
> diff --git a/lib/J3/Classpath/JavaUpcalls.h
> b/lib/J3/Classpath/JavaUpcalls.h
> deleted file mode 100644
> index f30f3ac..0000000
> --- a/lib/J3/Classpath/JavaUpcalls.h
> +++ /dev/null
> @@ -1,283 +0,0 @@
> -//===---------- JavaUpcalls.h - Upcalls to Java entities
> ------------------===//
> -//
> -// The VMKit project
> -//
> -// This file is distributed under the University of Illinois Open Source
> -// License. See LICENSE.TXT for details.
> -//
>
> -//===----------------------------------------------------------------------===//
> -
> -#ifndef JNJVM_JAVA_UPCALLS_H
> -#define JNJVM_JAVA_UPCALLS_H
> -
> -#include "mvm/Allocator.h"
> -
> -#include "JnjvmConfig.h"
> -
> -#define UPCALL_CLASS(vm, name)
> \
> - vm->loadName(vm->asciizConstructUTF8(name), true, false, NULL)
> -
> -#define UPCALL_PRIMITIVE_CLASS(loader, name, nb)
> \
> - new(loader->allocator, "Primitive class")
> \
> - UserClassPrimitive(loader,
> loader->asciizConstructUTF8(name), nb) \
> -
> -#define UPCALL_FIELD(vm, cl, name, type, acc)
> \
> - UPCALL_CLASS(vm,
> cl)->lookupFieldDontThrow(vm->asciizConstructUTF8(name), \
> -
> vm->asciizConstructUTF8(type), \
> - isStatic(acc), false, 0)
> -
> -#define UPCALL_METHOD(vm, cl, name, type, acc)
> \
> - UPCALL_CLASS(vm,
> cl)->lookupMethodDontThrow(vm->asciizConstructUTF8(name), \
> -
> vm->asciizConstructUTF8(type), \
> - isStatic(acc), false, 0)
> -
> -#define UPCALL_ARRAY_CLASS(loader, name, depth)
> \
> - loader->constructArray(
> \
> - loader->constructArrayName(depth,
> loader->asciizConstructUTF8(name)))
> -
> -#define UPCALL_CLASS_EXCEPTION(loader, name)
> \
> - name = UPCALL_CLASS(loader, "java/lang/"#name)
> -
> -#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name)
> \
> - name = UPCALL_CLASS(loader, "java/lang/reflect/"#name)
> -
> -#define UPCALL_METHOD_EXCEPTION(loader, name) \
> - Init##name =
> name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \
> -
> loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \
> - false, false, 0);
> -
> -#define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \
> - ErrorWithExcp##name =
> name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \
> -
> loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \
> - false, false, 0);
> -
> -namespace j3 {
> -
> -class Jnjvm;
> -class JavaField;
> -class JavaMethod;
> -class JavaObject;
> -class JavaThread;
> -class Class;
> -class ClassArray;
> -class JnjvmClassLoader;
> -
> -class Classpath : public mvm::PermanentObject {
> -public:
> - ISOLATE_STATIC UserClass* newClassLoader;
> - ISOLATE_STATIC JavaMethod* getSystemClassLoader;
> - ISOLATE_STATIC JavaMethod* setContextClassLoader;
> - ISOLATE_STATIC UserClass* newString;
> - ISOLATE_STATIC UserClass* newClass;
> - ISOLATE_STATIC UserClass* newThrowable;
> - ISOLATE_STATIC UserClass* newException;
> - ISOLATE_STATIC JavaMethod* initClass;
> - ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain;
> - ISOLATE_STATIC JavaField* vmdataClass;
> - ISOLATE_STATIC JavaMethod* setProperty;
> - ISOLATE_STATIC JavaMethod* initString;
> - ISOLATE_STATIC JavaMethod* getCallingClassLoader;
> - ISOLATE_STATIC JavaMethod* initConstructor;
> - ISOLATE_STATIC UserClassArray* constructorArrayClass;
> - ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;
> - ISOLATE_STATIC UserClass* newConstructor;
> - ISOLATE_STATIC JavaField* constructorSlot;
> - ISOLATE_STATIC JavaMethod* initMethod;
> - ISOLATE_STATIC JavaMethod* initField;
> - ISOLATE_STATIC UserClassArray* methodArrayClass;
> - ISOLATE_STATIC UserClassArray* fieldArrayClass;
> - ISOLATE_STATIC UserClass* newMethod;
> - ISOLATE_STATIC UserClass* newField;
> - ISOLATE_STATIC JavaField* methodSlot;
> - ISOLATE_STATIC JavaField* fieldSlot;
> - ISOLATE_STATIC UserClassArray* classArrayClass;
> - ISOLATE_STATIC JavaMethod* loadInClassLoader;
> - ISOLATE_STATIC JavaMethod* initVMThrowable;
> - ISOLATE_STATIC JavaField* vmDataVMThrowable;
> - ISOLATE_STATIC UserClass* newVMThrowable;
> - ISOLATE_STATIC JavaField* bufferAddress;
> - ISOLATE_STATIC JavaField* dataPointer32;
> - ISOLATE_STATIC JavaField* dataPointer64;
> - ISOLATE_STATIC UserClass* newPointer32;
> - ISOLATE_STATIC UserClass* newPointer64;
> - ISOLATE_STATIC UserClass* newDirectByteBuffer;
> - ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;
> - ISOLATE_STATIC JavaField* vmdataClassLoader;
> - ISOLATE_STATIC UserClass* enumClass;
> -
> - ISOLATE_STATIC JavaField* boolValue;
> - ISOLATE_STATIC JavaField* byteValue;
> - ISOLATE_STATIC JavaField* shortValue;
> - ISOLATE_STATIC JavaField* charValue;
> - ISOLATE_STATIC JavaField* intValue;
> - ISOLATE_STATIC JavaField* longValue;
> - ISOLATE_STATIC JavaField* floatValue;
> - ISOLATE_STATIC JavaField* doubleValue;
> -
> - ISOLATE_STATIC UserClass* newStackTraceElement;
> - ISOLATE_STATIC UserClassArray* stackTraceArray;
> - ISOLATE_STATIC JavaMethod* initStackTraceElement;
> -
> - ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader);
> -
> - ISOLATE_STATIC UserClass* voidClass;
> - ISOLATE_STATIC UserClass* boolClass;
> - ISOLATE_STATIC UserClass* byteClass;
> - ISOLATE_STATIC UserClass* shortClass;
> - ISOLATE_STATIC UserClass* charClass;
> - ISOLATE_STATIC UserClass* intClass;
> - ISOLATE_STATIC UserClass* floatClass;
> - ISOLATE_STATIC UserClass* doubleClass;
> - ISOLATE_STATIC UserClass* longClass;
> -
> - ISOLATE_STATIC UserClass* vmStackWalker;
> -
> - ISOLATE_STATIC UserClass* newThread;
> - ISOLATE_STATIC UserClass* newVMThread;
> - ISOLATE_STATIC JavaField* assocThread;
> - ISOLATE_STATIC JavaField* vmdataVMThread;
> - ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread;
> - ISOLATE_STATIC JavaMethod* initThread;
> - ISOLATE_STATIC JavaMethod* initVMThread;
> - ISOLATE_STATIC JavaMethod* runVMThread;
> - ISOLATE_STATIC JavaMethod* groupAddThread;
> - ISOLATE_STATIC JavaField* threadName;
> - ISOLATE_STATIC JavaField* groupName;
> - ISOLATE_STATIC JavaMethod* initGroup;
> - ISOLATE_STATIC JavaField* priority;
> - ISOLATE_STATIC JavaField* daemon;
> - ISOLATE_STATIC JavaField* group;
> - ISOLATE_STATIC JavaField* running;
> - ISOLATE_STATIC UserClass* threadGroup;
> - ISOLATE_STATIC JavaField* rootGroup;
> - ISOLATE_STATIC JavaField* vmThread;
> - ISOLATE_STATIC JavaMethod* getUncaughtExceptionHandler;
> - ISOLATE_STATIC JavaMethod* uncaughtException;
> - ISOLATE_STATIC UserClass* inheritableThreadLocal;
> -
> -
> - ISOLATE_STATIC UserClass* InvocationTargetException;
> - ISOLATE_STATIC UserClass* ArrayStoreException;
> - ISOLATE_STATIC UserClass* ClassCastException;
> - ISOLATE_STATIC UserClass* IllegalMonitorStateException;
> - ISOLATE_STATIC UserClass* IllegalArgumentException;
> - ISOLATE_STATIC UserClass* InterruptedException;
> - ISOLATE_STATIC UserClass* IndexOutOfBoundsException;
> - ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException;
> - ISOLATE_STATIC UserClass* NegativeArraySizeException;
> - ISOLATE_STATIC UserClass* NullPointerException;
> - ISOLATE_STATIC UserClass* SecurityException;
> - ISOLATE_STATIC UserClass* ClassFormatError;
> - ISOLATE_STATIC UserClass* ClassCircularityError;
> - ISOLATE_STATIC UserClass* NoClassDefFoundError;
> - ISOLATE_STATIC UserClass* UnsupportedClassVersionError;
> - ISOLATE_STATIC UserClass* NoSuchFieldError;
> - ISOLATE_STATIC UserClass* NoSuchMethodError;
> - ISOLATE_STATIC UserClass* InstantiationError;
> - ISOLATE_STATIC UserClass* InstantiationException;
> - ISOLATE_STATIC UserClass* IllegalAccessError;
> - ISOLATE_STATIC UserClass* IllegalAccessException;
> - ISOLATE_STATIC UserClass* VerifyError;
> - ISOLATE_STATIC UserClass* ExceptionInInitializerError;
> - ISOLATE_STATIC UserClass* LinkageError;
> - ISOLATE_STATIC UserClass* AbstractMethodError;
> - ISOLATE_STATIC UserClass* UnsatisfiedLinkError;
> - ISOLATE_STATIC UserClass* InternalError;
> - ISOLATE_STATIC UserClass* OutOfMemoryError;
> - ISOLATE_STATIC UserClass* StackOverflowError;
> - ISOLATE_STATIC UserClass* UnknownError;
> - ISOLATE_STATIC UserClass* ClassNotFoundException;
> - ISOLATE_STATIC UserClass* ArithmeticException;
> -
> - ISOLATE_STATIC JavaMethod* InitInvocationTargetException;
> - ISOLATE_STATIC JavaMethod* InitArrayStoreException;
> - ISOLATE_STATIC JavaMethod* InitClassCastException;
> - ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException;
> - ISOLATE_STATIC JavaMethod* InitIllegalArgumentException;
> - ISOLATE_STATIC JavaMethod* InitInterruptedException;
> - ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException;
> - ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException;
> - ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException;
> - ISOLATE_STATIC JavaMethod* InitNullPointerException;
> - ISOLATE_STATIC JavaMethod* InitSecurityException;
> - ISOLATE_STATIC JavaMethod* InitClassFormatError;
> - ISOLATE_STATIC JavaMethod* InitClassCircularityError;
> - ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError;
> - ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError;
> - ISOLATE_STATIC JavaMethod* InitNoSuchFieldError;
> - ISOLATE_STATIC JavaMethod* InitNoSuchMethodError;
> - ISOLATE_STATIC JavaMethod* InitInstantiationError;
> - ISOLATE_STATIC JavaMethod* InitInstantiationException;
> - ISOLATE_STATIC JavaMethod* InitIllegalAccessError;
> - ISOLATE_STATIC JavaMethod* InitIllegalAccessException;
> - ISOLATE_STATIC JavaMethod* InitVerifyError;
> - ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError;
> - ISOLATE_STATIC JavaMethod* InitLinkageError;
> - ISOLATE_STATIC JavaMethod* InitAbstractMethodError;
> - ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError;
> - ISOLATE_STATIC JavaMethod* InitInternalError;
> - ISOLATE_STATIC JavaMethod* InitOutOfMemoryError;
> - ISOLATE_STATIC JavaMethod* InitStackOverflowError;
> - ISOLATE_STATIC JavaMethod* InitUnknownError;
> - ISOLATE_STATIC JavaMethod* InitClassNotFoundException;
> - ISOLATE_STATIC JavaMethod* InitArithmeticException;
> -
> - ISOLATE_STATIC JavaMethod* SystemArraycopy;
> - ISOLATE_STATIC JavaMethod* VMSystemArraycopy;
> - ISOLATE_STATIC Class* SystemClass;
> -
> - ISOLATE_STATIC JavaMethod* IntToString;
> -
> - ISOLATE_STATIC JavaMethod* InitObject;
> - ISOLATE_STATIC JavaMethod* FinalizeObject;
> -
> - ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError;
> - ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError;
> - ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException;
> -
> -
> -
> - ISOLATE_STATIC UserClassArray* ArrayOfByte;
> - ISOLATE_STATIC UserClassArray* ArrayOfChar;
> - ISOLATE_STATIC UserClassArray* ArrayOfInt;
> - ISOLATE_STATIC UserClassArray* ArrayOfShort;
> - ISOLATE_STATIC UserClassArray* ArrayOfBool;
> - ISOLATE_STATIC UserClassArray* ArrayOfLong;
> - ISOLATE_STATIC UserClassArray* ArrayOfFloat;
> - ISOLATE_STATIC UserClassArray* ArrayOfDouble;
> - ISOLATE_STATIC UserClassArray* ArrayOfObject;
> - ISOLATE_STATIC UserClassArray* ArrayOfString;
> -
> - ISOLATE_STATIC UserClassPrimitive* OfByte;
> - ISOLATE_STATIC UserClassPrimitive* OfChar;
> - ISOLATE_STATIC UserClassPrimitive* OfInt;
> - ISOLATE_STATIC UserClassPrimitive* OfShort;
> - ISOLATE_STATIC UserClassPrimitive* OfBool;
> - ISOLATE_STATIC UserClassPrimitive* OfLong;
> - ISOLATE_STATIC UserClassPrimitive* OfFloat;
> - ISOLATE_STATIC UserClassPrimitive* OfDouble;
> - ISOLATE_STATIC UserClassPrimitive* OfVoid;
> -
> - ISOLATE_STATIC UserClass* OfObject;
> -
> - ISOLATE_STATIC JavaField* methodClass;
> - ISOLATE_STATIC JavaField* fieldClass;
> - ISOLATE_STATIC JavaField* constructorClass;
> -
> - ISOLATE_STATIC JavaMethod* EnqueueReference;
> - ISOLATE_STATIC Class* newReference;
> -
> - ISOLATE_STATIC UserClass* EnumClass;
> -
> -private:
> - ISOLATE_STATIC void CreateJavaThread(Jnjvm* vm, JavaThread* myth,
> - const char* name, JavaObject*
> Group);
> -
> -public:
> - ISOLATE_STATIC void InitializeThreading(Jnjvm* vm);
> -};
> -
> -
> -} // end namespace j3
> -
> -#endif
> diff --git a/lib/J3/Classpath/Makefile b/lib/J3/Classpath/Makefile
> deleted file mode 100644
> index e0d6799..0000000
> --- a/lib/J3/Classpath/Makefile
> +++ /dev/null
> @@ -1,23 +0,0 @@
> -##===- lib/JnJVM/Classpath/Makefile ------------------------*-
> Makefile -*-===##
> -#
> -# The vmkit project
> -#
> -# This file is distributed under the University of Illinois Open Source
> -# License. See LICENSE.TXT for details.
> -#
>
> -##===----------------------------------------------------------------------===##
> -LEVEL = ../../..
> -
> -
> -EXTRA_DIST = ClasspathConstructor.inc ClasspathField.inc
> Classpath.inc ClasspathMethod.inc \
> - ClasspathVMClass.inc ClasspathVMClassLoader.inc
> ClasspathVMObject.inc \
> - ClasspathVMRuntime.inc ClasspathVMStackWalker.inc
> ClasspathVMSystem.inc \
> - ClasspathVMSystemProperties.inc ClasspathVMThread.inc
> ClasspathVMThrowable.inc
> -
> -include $(LEVEL)/Makefile.config
> -
> -MODULE_WITH_GC = Classpath
> -
> -include $(LEVEL)/Makefile.common
> -
> -CXX.Flags += -I$(PROJ_SRC_DIR)/../VMCore
> -I$(PROJ_SRC_DIR)/../../../include/j3
> diff --git a/lib/J3/Compiler/Makefile b/lib/J3/Compiler/Makefile
> index 43cd44a..58bb2e1 100644
> --- a/lib/J3/Compiler/Makefile
> +++ b/lib/J3/Compiler/Makefile
> @@ -14,4 +14,4 @@ MODULE_WITH_GC = J3Compiler
>
> include $(LEVEL)/Makefile.common
>
> -CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../Classpath -I$(PROJ_SRC_DIR)/../VMCore
> +CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
> -I$(PROJ_SRC_DIR)/../VMCore
> diff --git a/lib/J3/Makefile b/lib/J3/Makefile
> index 6f951d6..d6e81dc 100644
> --- a/lib/J3/Makefile
> +++ b/lib/J3/Makefile
> @@ -8,7 +8,7 @@
>
> ##===----------------------------------------------------------------------===##
> LEVEL = ../..
>
> -DIRS = LLVMRuntime VMCore Classpath Compiler
> +DIRS = LLVMRuntime VMCore ClassLib Compiler
>
> include $(LEVEL)/Makefile.config
> include $(LEVEL)/Makefile.common
> diff --git a/lib/J3/VMCore/Makefile b/lib/J3/VMCore/Makefile
> index c539835..5e08bd2 100644
> --- a/lib/J3/VMCore/Makefile
> +++ b/lib/J3/VMCore/Makefile
> @@ -14,4 +14,4 @@ MODULE_WITH_GC = J3
>
> include $(LEVEL)/Makefile.common
>
> -CXX.Flags += -I$(PROJ_OBJ_DIR)/../Classpath
> -I$(PROJ_OBJ_DIR)/../LLVMRuntime -I$(PROJ_SRC_DIR)/../Classpath
> -I$(PROJ_SRC_DIR)/../../../include/j3
> +CXX.Flags += -I$(PROJ_OBJ_DIR)/../ClassLib/
> -I$(PROJ_OBJ_DIR)/../LLVMRuntime
> -I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)
> -I$(PROJ_SRC_DIR)/../../../include/j3
> --
> 1.7.5.
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111025/225dc98e/attachment.html>
More information about the vmkit-commits
mailing list