[vmkit-commits] [PATCH] Move classpath to subdirectory, infrastructure for both runtimes
Will Dietz
wdietz2 at illinois.edu
Mon Oct 24 15:32:48 PDT 2011
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.
More information about the vmkit-commits
mailing list