Patch looks good! Hopefully you've just made svn move? (or the git equivalent)<br><br><div class="gmail_quote">On Tue, Oct 25, 2011 at 12:32 AM, Will Dietz <span dir="ltr"><<a href="mailto:wdietz2@illinois.edu">wdietz2@illinois.edu</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">File-level refactoring, sorry for noisy diff.<br>
<br>
Essentially move lib/J3/Classpath/* to lib/J3/ClasLib/GNUClasspath/*,<br>
and update Makefiles.<br>
<br>
<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a> is only exception--it goes in lib/J3/ClassLib/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a>.<br>
<br>
No intended functionality changes.<br>
<br>
~Will<br>
<br>
>From accdc80f91a029abc79f16fd867b8b45ec964ccf Mon Sep 17 00:00:00 2001<br>
From: Will Dietz <<a href="mailto:w@wdtz.org">w@wdtz.org</a>><br>
Date: Fri, 14 Oct 2011 02:54:01 -0500<br>
Subject: [PATCH 01/29] Move Classpath to subdirectory, infrastructure for<br>
both runtimes.<br>
<br>
---<br>
lib/J3/ClassLib/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a> | 22 +<br>
lib/J3/ClassLib/GNUClasspath/Classpath.inc | 392 +++++++<br>
.../ClassLib/GNUClasspath/ClasspathConstructor.inc | 222 ++++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathField.inc | 1171 ++++++++++++++++++++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc | 304 +++++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp | 30 +<br>
lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h | 222 ++++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc | 645 +++++++++++<br>
.../GNUClasspath/ClasspathVMClassLoader.inc | 380 +++++++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc | 170 +++<br>
.../ClassLib/GNUClasspath/ClasspathVMRuntime.inc | 228 ++++<br>
.../GNUClasspath/ClasspathVMStackWalker.inc | 86 ++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc | 119 ++<br>
.../GNUClasspath/ClasspathVMSystemProperties.inc | 154 +++<br>
lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc | 217 ++++<br>
.../ClassLib/GNUClasspath/ClasspathVMThrowable.inc | 183 +++<br>
lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp | 1076 ++++++++++++++++++<br>
lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h | 283 +++++<br>
lib/J3/ClassLib/GNUClasspath/Makefile | 23 +<br>
lib/J3/ClassLib/Makefile | 15 +<br>
lib/J3/ClassLib/OpenJDK/Makefile | 19 +<br>
lib/J3/Classpath/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a> | 19 -<br>
lib/J3/Classpath/Classpath.inc | 392 -------<br>
lib/J3/Classpath/ClasspathConstructor.inc | 222 ----<br>
lib/J3/Classpath/ClasspathField.inc | 1171 --------------------<br>
lib/J3/Classpath/ClasspathMethod.inc | 304 -----<br>
lib/J3/Classpath/ClasspathReflect.cpp | 30 -<br>
lib/J3/Classpath/ClasspathReflect.h | 222 ----<br>
lib/J3/Classpath/ClasspathVMClass.inc | 645 -----------<br>
lib/J3/Classpath/ClasspathVMClassLoader.inc | 380 -------<br>
lib/J3/Classpath/ClasspathVMObject.inc | 170 ---<br>
lib/J3/Classpath/ClasspathVMRuntime.inc | 229 ----<br>
lib/J3/Classpath/ClasspathVMStackWalker.inc | 86 --<br>
lib/J3/Classpath/ClasspathVMSystem.inc | 119 --<br>
lib/J3/Classpath/ClasspathVMSystemProperties.inc | 154 ---<br>
lib/J3/Classpath/ClasspathVMThread.inc | 217 ----<br>
lib/J3/Classpath/ClasspathVMThrowable.inc | 183 ---<br>
lib/J3/Classpath/JavaUpcalls.cpp | 1076 ------------------<br>
lib/J3/Classpath/JavaUpcalls.h | 283 -----<br>
lib/J3/Classpath/Makefile | 23 -<br>
lib/J3/Compiler/Makefile | 2 +-<br>
lib/J3/Makefile | 2 +-<br>
lib/J3/VMCore/Makefile | 2 +-<br>
43 files changed, 5964 insertions(+), 5928 deletions(-)<br>
create mode 100644 lib/J3/ClassLib/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a><br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/Classpath.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathField.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h<br>
create mode 100644 lib/J3/ClassLib/GNUClasspath/Makefile<br>
create mode 100644 lib/J3/ClassLib/Makefile<br>
create mode 100644 lib/J3/ClassLib/OpenJDK/Makefile<br>
delete mode 100644 lib/J3/Classpath/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a><br>
delete mode 100644 lib/J3/Classpath/Classpath.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathConstructor.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathField.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathMethod.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathReflect.cpp<br>
delete mode 100644 lib/J3/Classpath/ClasspathReflect.h<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMClass.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMClassLoader.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMObject.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMRuntime.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMStackWalker.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMSystem.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMSystemProperties.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMThread.inc<br>
delete mode 100644 lib/J3/Classpath/ClasspathVMThrowable.inc<br>
delete mode 100644 lib/J3/Classpath/JavaUpcalls.cpp<br>
delete mode 100644 lib/J3/Classpath/JavaUpcalls.h<br>
delete mode 100644 lib/J3/Classpath/Makefile<br>
<br>
diff --git a/lib/J3/ClassLib/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a> b/lib/J3/ClassLib/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a><br>
new file mode 100644<br>
index 0000000..a409582<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a><br>
@@ -0,0 +1,22 @@<br>
+//===-------- Classpath.h - Configuration for classpath<br>
-------------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#ifdef NATIVE_JNI<br>
+#define JNIEXPORT<br>
+#else<br>
+#include <jni.h><br>
+#endif<br>
+<br>
+// GNU Classpath values<br>
+#define GNUClasspathLibs "@classpathlibs@";<br>
+#define GNUClasspathGlibj "@classpathglibj@";<br>
+#define GNUClasspathVersion "@classpathversion@";<br>
+<br>
+// OpenJDK values<br>
+// TODO: Add me!<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc<br>
b/lib/J3/ClassLib/GNUClasspath/Classpath.inc<br>
new file mode 100644<br>
index 0000000..b33a5f6<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/Classpath.inc<br>
@@ -0,0 +1,392 @@<br>
+//===-------- Classpath.cpp - Configuration for classpath<br>
-------------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+<br>
+<br>
+#include "Classpath.h"<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+// Define hasClassInitializer because of a buggy implementation in Classpath.<br>
+JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ llvm_gcroot(Cl, 0);<br>
+ bool res = false;<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(Cl);<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);<br>
+<br>
+ if (cl->isClass() &&<br>
+ cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,<br>
+ vm->bootstrapLoader->clinitType,<br>
+ true, false, 0))<br>
+ res = true;<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+<br>
+// Redefine some VMObjectStreamClass functions because of a slow implementation<br>
+// in Classpath.<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jboolean val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceInt8Field(obj, (uint8)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jbyte val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceInt8Field(obj, (uint8)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jchar val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jshort val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceInt16Field(obj, (sint16)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jint val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceInt32Field(obj, (sint32)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jlong val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceLongField(obj, (sint64)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jfloat val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceFloatField(obj, (float)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jdouble val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, JavaObject* val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(val, 0);<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(obj);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ field->setInstanceObjectField(obj, val);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(target, 0);<br>
+ llvm_gcroot(constr, 0);<br>
+ llvm_gcroot(cons, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl =<br>
+ (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);<br>
+ res = cl->doNew(vm);<br>
+ JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
+ meth->invokeIntSpecial(vm, cl, res);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv * env,<br>
+jclass thisClass,<br>
+#endif<br>
+JavaObject* arrayType, jint arrayLength) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(arrayType, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* base =<br>
+ UserCommonClass::resolvedImplClass(vm, arrayType, true);<br>
+ JnjvmClassLoader* loader = base->classLoader;<br>
+ const UTF8* name = base->getName();<br>
+ // -1 because we're adding a new dimension in this method.<br>
+ const int kLimit = 255 - 1;<br>
+ const uint16* elements = name->elements;<br>
+ if (name->size > kLimit && elements[kLimit] == '[') {<br>
+ vm->illegalArgumentException("Too many dimensions for array");<br>
+ }<br>
+ const UTF8* arrayName = loader->constructArrayName(1, name);<br>
+ UserClassArray* array = loader->constructArray(arrayName, base);<br>
+ res = array->doNew(arrayLength, vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+<br>
+// Never throws.<br>
+JNIEXPORT<br>
+bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ return false;<br>
+}<br>
+<br>
+// Never throws.<br>
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,<br>
jlong update) {<br>
+<br>
+ llvm_gcroot(unsafe, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ jlong *ptr;<br>
+ jlong value;<br>
+<br>
+ ptr = (jlong *) (((uint8 *) obj) + offset);<br>
+<br>
+ value = *ptr;<br>
+<br>
+ if (value == expect) {<br>
+ *ptr = update;<br>
+ return true;<br>
+ } else {<br>
+ return false;<br>
+ }<br>
+<br>
+}<br>
+<br>
+// Never throws.<br>
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {<br>
+<br>
+ llvm_gcroot(unsafe, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ jint *ptr;<br>
+<br>
+ ptr = (jint *) (((uint8 *) obj) + offset);<br>
+<br>
+ return __sync_bool_compare_and_swap(ptr, expect, update);<br>
+}<br>
+<br>
+// Never throws.<br>
+JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,<br>
+JavaObject* update) {<br>
+ llvm_gcroot(unsafe, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(expect, 0);<br>
+ llvm_gcroot(update, 0);<br>
+<br>
+ JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);<br>
+<br>
+ return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,<br>
(gc**)ptr, (gc*)expect, (gc*)update);<br>
+}<br>
+<br>
+// Never throws.<br>
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {<br>
+ llvm_gcroot(unsafe, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(value, 0);<br>
+<br>
+ JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);<br>
+ mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr, (gc*)value);<br>
+}<br>
+<br>
+// TODO: Add the Volatile variants<br>
+#define GET_PUT_OFFSET(Type,jtype,shorttype) \<br>
+JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##<br>
__Ljava_lang_Object_2J( \<br>
+JavaObject* unsafe, JavaObject* base, jlong offset) { \<br>
+ jtype res = 0; \<br>
+ BEGIN_NATIVE_EXCEPTION(0) \<br>
+ jtype* ptr = (jtype*) (((uint8 *) base) + offset); \<br>
+ res = *ptr; \<br>
+ END_NATIVE_EXCEPTION \<br>
+ \<br>
+ return res; \<br>
+} \<br>
+ \<br>
+JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##<br>
__Ljava_lang_Object_2J ## shorttype( \<br>
+JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \<br>
+ BEGIN_NATIVE_EXCEPTION(0) \<br>
+ jtype* ptr = (jtype*) (((uint8 *) base) + offset); \<br>
+ *ptr = val; \<br>
+ END_NATIVE_EXCEPTION \<br>
+}<br>
+<br>
+GET_PUT_OFFSET(Boolean,jboolean,Z)<br>
+GET_PUT_OFFSET(Byte,jbyte,B)<br>
+GET_PUT_OFFSET(Char,jchar,C)<br>
+GET_PUT_OFFSET(Short,jshort,S)<br>
+GET_PUT_OFFSET(Int,jint,I)<br>
+GET_PUT_OFFSET(Long,jlong,J)<br>
+GET_PUT_OFFSET(Float,jfloat,F)<br>
+GET_PUT_OFFSET(Double,jdouble,D)<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc<br>
new file mode 100644<br>
index 0000000..8c506f4<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc<br>
@@ -0,0 +1,222 @@<br>
+//===- ClasspathConstructor.cpp<br>
-------------------------------------------===//<br>
+//===----------- GNU classpath java/lang/reflect/Constructor<br>
--------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaTypes.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+#include "JnjvmClassLoader.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getParameterTypes(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectConstructor* cons) {<br>
+<br>
+ JavaObject* res = 0;<br>
+<br>
+ llvm_gcroot(cons, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(cons);<br>
+ UserClass* cl = JavaObjectConstructor::getClass(cons);<br>
+ JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
+ JnjvmClassLoader* loader = cl->classLoader;<br>
+<br>
+ res = meth->getParameterTypes(loader);<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return (jobject)res;<br>
+}<br>
+<br>
+JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectConstructor* cons) {<br>
+<br>
+ llvm_gcroot(cons, 0);<br>
+ jint res = 0;<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(cons);<br>
+ JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
+ res = meth->access;<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JavaObject* proceedConstructor(JavaObjectConstructor* cons,<br>
+ ArrayObject* args,<br>
+ JavaObject* Clazz, jint index)<br>
+ __attribute__ ((noinline));<br>
+<br>
+JavaObject* proceedConstructor(JavaObjectConstructor* cons,<br>
+ ArrayObject* args,<br>
+ JavaObject* Clazz, jint index) {<br>
+ JavaObject* res = 0;<br>
+ JavaObject* excp = 0;<br>
+<br>
+ llvm_gcroot(cons, 0);<br>
+ llvm_gcroot(args, 0);<br>
+ llvm_gcroot(Clazz, 0);<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(excp, 0);<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
+ UserClass* cl = JavaObjectConstructor::getClass(cons);<br>
+ sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;<br>
+ Signdef* sign = meth->getSignature();<br>
+ sint32 size = sign->nbArguments;<br>
+<br>
+ if (isAbstract(cl->access)) vm->instantiationException(cl);<br>
+<br>
+ mvm::ThreadAllocator allocator;<br>
+ // Allocate a buffer to store the arguments.<br>
+ jvalue* buf = size ?<br>
+ (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;<br>
+<br>
+ if (nbArgs == size) {<br>
+ UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm,<br>
Clazz, false);<br>
+ UserClass* cl = _cl->asClass();<br>
+ if (cl) {<br>
+ cl->initialiseClass(vm);<br>
+ res = cl->doNew(vm);<br>
+ JavaObject** ptr = (JavaObject**)ArrayObject::getElements(args);<br>
+<br>
+ Typedef* const* arguments = sign->getArgumentsType();<br>
+ // Store the arguments, unboxing primitives if necessary.<br>
+ for (sint32 i = 0; i < size; ++i) {<br>
+ JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);<br>
+ if (!arguments[i]->isPrimitive()) {<br>
+ buf[i].l = reinterpret_cast<jobject>(&ptr[i]);<br>
+ }<br>
+ }<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ TRY {<br>
+ meth->invokeIntSpecialBuf(vm, cl, res, buf);<br>
+ } CATCH {<br>
+ excp = th->getJavaException();<br>
+ } END_CATCH;<br>
+ if (excp) {<br>
+ if (JavaObject::getClass(excp)->isAssignableFrom(vm->upcalls->newException))<br>
{<br>
+ th->clearException();<br>
+ // If it's an exception, we encapsule it in an<br>
+ // invocationTargetException<br>
+ vm->invocationTargetException(excp);<br>
+ } else {<br>
+ // If it's an error, throw it again.<br>
+ th->throwPendingException();<br>
+ }<br>
+ return NULL;<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("class is not a regular class");<br>
+ return NULL;<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong number of arguments");<br>
+ return NULL;<br>
+ }<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL<br>
Java_java_lang_reflect_Constructor_constructNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectConstructor* cons, ArrayObject* args, JavaObject* Clazz,<br>
jint index) {<br>
+<br>
+ JavaObject* res = 0;<br>
+<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(cons, 0);<br>
+ llvm_gcroot(args, 0);<br>
+ llvm_gcroot(Clazz, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ res = proceedConstructor(cons, args, Clazz, index);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT<br>
+ArrayObject* JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectConstructor* cons) {<br>
+<br>
+ ArrayObject* res = 0;<br>
+<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(cons, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(cons);<br>
+ UserClass* cl = JavaObjectConstructor::getClass(cons);<br>
+ JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
+ JnjvmClassLoader* loader = cl->classLoader;<br>
+<br>
+ res = (ArrayObject*)meth->getExceptionTypes(loader);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Constructor_getSignature(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectConstructor* Meth) {<br>
+<br>
+ JavaObject* result = 0;<br>
+<br>
+ llvm_gcroot(result, 0);<br>
+ llvm_gcroot(Meth, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(Meth);<br>
+ JavaMethod* meth = JavaObjectConstructor::getInternalMethod(Meth);<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ result = vm->internalUTF8ToStr(meth->type);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return result;<br>
+}<br>
+<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc<br>
new file mode 100644<br>
index 0000000..e56c82f<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc<br>
@@ -0,0 +1,1171 @@<br>
+//===- ClasspathVMField.cpp - GNU classpath java/lang/reflect/Field<br>
-------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "Classpath.h"<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaTypes.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+<br>
+JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field) {<br>
+ jint res = 0;<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ res = field->access;<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_getType(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field) {<br>
+<br>
+ JavaObject* res = 0;<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ JnjvmClassLoader* loader = cl->classLoader;<br>
+ UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);<br>
+ res = fieldCl->getClassDelegatee(vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jint res = 0;<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ const Typedef* type = field->getSignature();<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+<br>
+ if (prim->isInt()) {<br>
+ if (stat) {<br>
+ res = (sint32)field->getStaticInt32Field();<br>
+ } else {<br>
+ res = (sint32)field->getInstanceInt32Field(obj);<br>
+ }<br>
+ } else if (prim->isChar()) {<br>
+ if (stat) {<br>
+ res = (uint32)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (uint32)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isByte()) {<br>
+ if (stat) {<br>
+ res = (sint32)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (sint32)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else if (prim->isShort()) {<br>
+ if (stat) {<br>
+ res = (sint32)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (sint32)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+JNIEXPORT jlong JNICALL Java_java_lang_reflect_Field_getLong(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jlong res = 0;<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+<br>
+ if (prim->isInt()) {<br>
+ if (stat) {<br>
+ res = (sint64)field->getStaticInt32Field();<br>
+ } else {<br>
+ res = (sint64)field->getInstanceInt32Field(obj);<br>
+ }<br>
+ } else if (prim->isChar()) {<br>
+ if (stat) {<br>
+ res = (uint64)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (uint64)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isByte()) {<br>
+ if (stat) {<br>
+ res = (sint64)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (sint64)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else if (prim->isShort()) {<br>
+ if (stat) {<br>
+ res = (sint64)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (sint64)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ res = (sint64)field->getStaticLongField();<br>
+ } else {<br>
+ res = (sint64)field->getInstanceLongField(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_reflect_Field_getBoolean(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jboolean res = 0;<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isBool()) {<br>
+ if (stat) {<br>
+ res = (uint8)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (uint8)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+JNIEXPORT jfloat JNICALL Java_java_lang_reflect_Field_getFloat(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jfloat res = 0;<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isByte()) {<br>
+ if (stat) {<br>
+ res = (jfloat)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (jfloat)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else if (prim->isInt()) {<br>
+ if (stat) {<br>
+ res = (jfloat)field->getStaticInt32Field();<br>
+ } else {<br>
+ res = (jfloat)field->getInstanceInt32Field(obj);<br>
+ }<br>
+ } else if (prim->isShort()) {<br>
+ if (stat) {<br>
+ res = (jfloat)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (jfloat)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ res = (jfloat)field->getStaticLongField();<br>
+ } else {<br>
+ res = (jfloat)field->getInstanceLongField(obj);<br>
+ }<br>
+ } else if (prim->isChar()) {<br>
+ // Cast to uint32 because char is unsigned.<br>
+ if (stat) {<br>
+ res = (jfloat)(uint32)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (jfloat)(uint32)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ res = (jfloat)field->getStaticFloatField();<br>
+ } else {<br>
+ res = (jfloat)field->getInstanceFloatField(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jbyte JNICALL Java_java_lang_reflect_Field_getByte(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jbyte res = 0;<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isByte()) {<br>
+ if (stat) {<br>
+ res = (sint8)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (sint8)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jchar JNICALL Java_java_lang_reflect_Field_getChar(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jchar res = 0;<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isChar()) {<br>
+ if (stat) {<br>
+ res = (uint16)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (uint16)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+JNIEXPORT jshort JNICALL Java_java_lang_reflect_Field_getShort(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+<br>
+ jshort res = 0;<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isShort()) {<br>
+ if (stat) {<br>
+ res = (sint16)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (sint16)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isByte()) {<br>
+ if (stat) {<br>
+ res = (sint16)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (sint16)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jdouble JNICALL Java_java_lang_reflect_Field_getDouble(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+ jdouble res = 0;<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isByte()) {<br>
+ if (stat) {<br>
+ res = (jdouble)(sint64)field->getStaticInt8Field();<br>
+ } else {<br>
+ res = (jdouble)(sint64)field->getInstanceInt8Field(obj);<br>
+ }<br>
+ } else if (prim->isInt()) {<br>
+ if (stat) {<br>
+ res = (jdouble)(sint64)field->getStaticInt32Field();<br>
+ } else {<br>
+ res = (jdouble)(sint64)field->getInstanceInt32Field(obj);<br>
+ }<br>
+ } else if (prim->isShort()) {<br>
+ if (stat) {<br>
+ res = (jdouble)(sint64)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (jdouble)(sint64)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ res = (jdouble)(sint64)field->getStaticLongField();<br>
+ } else {<br>
+ res = (jdouble)(sint64)field->getInstanceLongField(obj);<br>
+ }<br>
+ } else if (prim->isChar()) {<br>
+ if (stat) {<br>
+ res = (jdouble)(uint64)field->getStaticInt16Field();<br>
+ } else {<br>
+ res = (jdouble)(uint64)field->getInstanceInt16Field(obj);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ res = (jdouble)field->getStaticFloatField();<br>
+ } else {<br>
+ res = (jdouble)field->getInstanceFloatField(obj);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ res = (jdouble)field->getStaticDoubleField();<br>
+ } else {<br>
+ res = (jdouble)field->getInstanceDoubleField(obj);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_get(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj) {<br>
+<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isBool()) {<br>
+ uint8 val = stat ? field->getStaticInt8Field() :<br>
+ field->getInstanceInt8Field(obj);<br>
+ res = vm->upcalls->boolClass->doNew(vm);<br>
+ vm->upcalls->boolValue->setInstanceInt8Field(res, val);<br>
+ } else if (prim->isByte()) {<br>
+ sint8 val = stat ? field->getStaticInt8Field() :<br>
+ field->getInstanceInt8Field(obj);<br>
+ res = vm->upcalls->byteClass->doNew(vm);<br>
+ vm->upcalls->byteValue->setInstanceInt8Field(res, val);<br>
+ } else if (prim->isChar()) {<br>
+ uint16 val = stat ? field->getStaticInt16Field() :<br>
+ field->getInstanceInt16Field(obj);<br>
+ res = vm->upcalls->charClass->doNew(vm);<br>
+ vm->upcalls->charValue->setInstanceInt16Field(res, val);<br>
+ } else if (prim->isShort()) {<br>
+ sint16 val = stat ? field->getStaticInt16Field() :<br>
+ field->getInstanceInt16Field(obj);<br>
+ res = vm->upcalls->shortClass->doNew(vm);<br>
+ vm->upcalls->shortValue->setInstanceInt16Field(res, val);<br>
+ } else if (prim->isInt()) {<br>
+ sint64 val = stat ? field->getStaticInt32Field() :<br>
+ field->getInstanceInt32Field(obj);<br>
+ res = vm->upcalls->intClass->doNew(vm);<br>
+ vm->upcalls->intValue->setInstanceInt32Field(res, val);<br>
+ } else if (prim->isLong()) {<br>
+ sint64 val = stat ? field->getStaticLongField() :<br>
+ field->getInstanceLongField(obj);<br>
+ res = vm->upcalls->longClass->doNew(vm);<br>
+ vm->upcalls->longValue->setInstanceLongField(res, val);<br>
+ } else if (prim->isFloat()) {<br>
+ float val = stat ? field->getStaticFloatField() :<br>
+ field->getInstanceFloatField(obj);<br>
+ res = vm->upcalls->floatClass->doNew(vm);<br>
+ vm->upcalls->floatValue->setInstanceFloatField(res, val);<br>
+ } else if (prim->isDouble()) {<br>
+ double val = stat ? field->getStaticDoubleField() :<br>
+ field->getInstanceDoubleField(obj);<br>
+ res = vm->upcalls->doubleClass->doNew(vm);<br>
+ vm->upcalls->doubleValue->setInstanceDoubleField(res, val);<br>
+ }<br>
+ } else {<br>
+ if (stat) {<br>
+ res = field->getStaticObjectField();<br>
+ } else {<br>
+ res = field->getInstanceObjectField(obj);<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_set(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, JavaObject* val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(val, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ jvalue buf;<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ JavaObject::decapsulePrimitive(val, vm, &buf, type);<br>
+<br>
+<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isBool()) {<br>
+ if (stat) {<br>
+ field->setStaticInt8Field(buf.z);<br>
+ } else {<br>
+ field->setInstanceInt8Field(obj, buf.z);<br>
+ }<br>
+ } else if (prim->isByte()) {<br>
+ if (stat) {<br>
+ field->setStaticInt8Field(buf.b);<br>
+ } else {<br>
+ field->setInstanceInt8Field(obj, buf.b);<br>
+ }<br>
+ } else if (prim->isChar()) {<br>
+ if (stat) {<br>
+ field->setStaticInt16Field(buf.c);<br>
+ } else {<br>
+ field->setInstanceInt16Field(obj, buf.c);<br>
+ }<br>
+ } else if (prim->isShort()) {<br>
+ if (stat) {<br>
+ field->setStaticInt16Field(buf.s);<br>
+ } else {<br>
+ field->setInstanceInt16Field(obj, buf.s);<br>
+ }<br>
+ } else if (prim->isInt()) {<br>
+ if (stat) {<br>
+ field->setStaticInt32Field(buf.i);<br>
+ } else {<br>
+ field->setInstanceInt32Field(obj, buf.i);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ field->setStaticLongField(buf.j);<br>
+ } else {<br>
+ field->setInstanceLongField(obj, buf.j);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField(buf.f);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, buf.f);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField(buf.d);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, buf.d);<br>
+ }<br>
+ }<br>
+ } else {<br>
+ if (stat) {<br>
+ field->setStaticObjectField(val);<br>
+ } else {<br>
+ field->setInstanceObjectField(obj, val);<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jboolean val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isBool()) {<br>
+ if (stat) {<br>
+ field->setStaticInt8Field((uint8)val);<br>
+ } else {<br>
+ field->setInstanceInt8Field(obj, (uint8)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setByte(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jbyte val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isByte()) {<br>
+ if (stat) {<br>
+ field->setStaticInt8Field((sint8)val);<br>
+ } else {<br>
+ field->setInstanceInt8Field(obj, (sint8)val);<br>
+ }<br>
+ } else if (prim->isShort()) {<br>
+ if (stat) {<br>
+ field->setStaticInt16Field((sint16)val);<br>
+ } else {<br>
+ field->setInstanceInt16Field(obj, (sint16)val);<br>
+ }<br>
+ } else if (prim->isInt()) {<br>
+ if (stat) {<br>
+ field->setStaticInt32Field((sint32)val);<br>
+ } else {<br>
+ field->setInstanceInt32Field(obj, (sint32)val);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ field->setStaticLongField((sint64)val);<br>
+ } else {<br>
+ field->setInstanceLongField(obj, (sint64)val);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField((float)val);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, (float)val);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jchar val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isChar()) {<br>
+ if (stat) {<br>
+ field->setStaticInt16Field((uint16)val);<br>
+ } else {<br>
+ field->setInstanceInt16Field(obj, (uint16)val);<br>
+ }<br>
+ } else if (prim->isInt()) {<br>
+ if (stat) {<br>
+ field->setStaticInt32Field((uint32)val);<br>
+ } else {<br>
+ field->setInstanceInt32Field(obj, (uint32)val);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ field->setStaticLongField((uint64)val);<br>
+ } else {<br>
+ field->setInstanceLongField(obj, (uint64)val);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField((float)(uint32)val);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, (float)(uint32)val);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)(uint64)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)(uint64)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jshort val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isShort()) {<br>
+ if (stat) {<br>
+ field->setStaticInt16Field((sint16)val);<br>
+ } else {<br>
+ field->setInstanceInt16Field(obj, (sint16)val);<br>
+ }<br>
+ } else if (prim->isInt()) {<br>
+ if (stat) {<br>
+ field->setStaticInt32Field((sint32)val);<br>
+ } else {<br>
+ field->setInstanceInt32Field(obj, (sint32)val);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ field->setStaticLongField((sint64)val);<br>
+ } else {<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField((float)val);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, (float)val);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jint val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isInt()) {<br>
+ if (stat) {<br>
+ field->setStaticInt32Field((sint32)val);<br>
+ } else {<br>
+ field->setInstanceInt32Field(obj, (sint32)val);<br>
+ }<br>
+ } else if (prim->isLong()) {<br>
+ if (stat) {<br>
+ field->setStaticLongField((sint64)val);<br>
+ } else {<br>
+ field->setInstanceLongField(obj, (sint64)val);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField((float)val);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, (float)val);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jlong val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isLong()) {<br>
+ if (stat) {<br>
+ field->setStaticLongField((sint64)val);<br>
+ } else {<br>
+ field->setInstanceLongField(obj, (sint64)val);<br>
+ }<br>
+ } else if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField((float)val);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, (float)val);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jfloat val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isFloat()) {<br>
+ if (stat) {<br>
+ field->setStaticFloatField((float)val);<br>
+ } else {<br>
+ field->setInstanceFloatField(obj, (float)val);<br>
+ }<br>
+ } else if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectField* Field, JavaObject* obj, jdouble val) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = JavaObjectField::getClass(Field);<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ bool stat = isStatic(field->access);<br>
+<br>
+ if (stat) {<br>
+ cl->initialiseClass(vm);<br>
+ } else {<br>
+ verifyNull(obj);<br>
+ }<br>
+<br>
+ const Typedef* type = field->getSignature();<br>
+ if (type->isPrimitive()) {<br>
+ const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
+ if (prim->isDouble()) {<br>
+ if (stat) {<br>
+ field->setStaticDoubleField((double)val);<br>
+ } else {<br>
+ field->setInstanceDoubleField(obj, (double)val);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong type");<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+// Never throws.<br>
+JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* Unsafe, JavaObjectField* Field) {<br>
+<br>
+ llvm_gcroot(Field, 0);<br>
+ llvm_gcroot(Unsafe, 0);<br>
+<br>
+ JavaField* field = JavaObjectField::getInternalField(Field);<br>
+ return (jlong)field->ptrOffset;<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc<br>
new file mode 100644<br>
index 0000000..fcfea1c<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc<br>
@@ -0,0 +1,304 @@<br>
+//===- ClasspathMethod.cpp<br>
------------------------------------------------===//<br>
+//===------------- GNU classpath java/lang/reflect/Method<br>
-----------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaTypes.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+#include "JnjvmClassLoader.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JNIEXPORT jint JNICALL Java_java_lang_reflect_Method_getModifiersInternal(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectMethod* Meth) {<br>
+<br>
+ jint res = 0;<br>
+ llvm_gcroot(Meth, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
+ res = meth->access;<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getReturnType(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectMethod* Meth) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(Meth, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ UserClass* cl = JavaObjectMethod::getClass(Meth);<br>
+ JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
+ JnjvmClassLoader* loader = cl->classLoader;<br>
+ res = meth->getReturnType(loader);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getParameterTypes(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectMethod* Meth) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(Meth, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ UserClass* cl = JavaObjectMethod::getClass(Meth);<br>
+ JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
+ JnjvmClassLoader* loader = cl->classLoader;<br>
+<br>
+ res = meth->getParameterTypes(loader);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,<br>
+ ArrayObject* args, JavaObject* Cl, jint index)<br>
+ __attribute__((noinline));<br>
+<br>
+JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,<br>
+ ArrayObject* args, JavaObject* Cl, jint index) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ JavaObject* exc = 0;<br>
+<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Meth, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(args, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(exc, 0);<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+<br>
+ JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
+<br>
+ sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;<br>
+ Signdef* sign = meth->getSignature();<br>
+ sint32 size = sign->nbArguments;<br>
+<br>
+ mvm::ThreadAllocator allocator;<br>
+ jvalue* buf = size ?<br>
+ (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;<br>
+<br>
+ if (nbArgs == size) {<br>
+ UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ UserClass* cl = (UserClass*)_cl;<br>
+<br>
+ if (isVirtual(meth->access)) {<br>
+ verifyNull(obj);<br>
+ UserCommonClass* objCl = JavaObject::getClass(obj);<br>
+ if (!(objCl->isAssignableFrom(cl))) {<br>
+ vm->illegalArgumentException("<this> is not a valid type");<br>
+ }<br>
+<br>
+ if (isInterface(cl->access)) {<br>
+ cl->initialiseClass(vm);<br>
+ UserClass* methodCl = 0;<br>
+ UserClass* lookup = objCl->isArray() ? objCl->super : objCl->asClass();<br>
+ meth = lookup->lookupMethod(meth->name, meth->type, false, true,<br>
+ &methodCl);<br>
+ }<br>
+ } else {<br>
+ cl->initialiseClass(vm);<br>
+ }<br>
+<br>
+ JavaObject** ptr = ArrayObject::getElements(args);<br>
+ Typedef* const* arguments = sign->getArgumentsType();<br>
+ for (sint32 i = 0; i < size; ++i) {<br>
+ JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);<br>
+ if (!arguments[i]->isPrimitive()) {<br>
+ buf[i].l = reinterpret_cast<jobject>(&ptr[i]);<br>
+ }<br>
+ }<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+<br>
+#define RUN_METH(TYPE, VAR)<br>
\<br>
+ TRY {<br>
\<br>
+ if (isVirtual(meth->access)) {<br>
\<br>
+ if (isPublic(meth->access) && !isFinal(meth->access) &&<br>
\<br>
+ !isFinal(meth->classDef->access)) {<br>
\<br>
+ VAR = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, buf);<br>
\<br>
+ } else {<br>
\<br>
+ VAR = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, buf);<br>
\<br>
+ }<br>
\<br>
+ } else {<br>
\<br>
+ VAR = meth->invoke##TYPE##StaticBuf(vm, cl, buf);<br>
\<br>
+ }<br>
\<br>
+ } CATCH {<br>
\<br>
+ exc = th->getJavaException();<br>
\<br>
+ } END_CATCH;<br>
\<br>
+ if (exc) {<br>
\<br>
+ th->clearException();<br>
\<br>
+ th->getJVM()->invocationTargetException(exc);<br>
\<br>
+ return NULL;<br>
\<br>
+ }<br>
+<br>
+ Typedef* retType = sign->getReturnType();<br>
+ if (retType->isPrimitive()) {<br>
+ PrimitiveTypedef* prim = (PrimitiveTypedef*)retType;<br>
+ if (prim->isVoid()) {<br>
+ res = 0;<br>
+ uint32 val = 0;<br>
+ RUN_METH(Int, val);<br>
+ } else if (prim->isBool()) {<br>
+ uint32 val = 0;<br>
+ RUN_METH(Int, val);<br>
+ res = vm->upcalls->boolClass->doNew(vm);<br>
+ vm->upcalls->boolValue->setInstanceInt8Field(res, val);<br>
+ } else if (prim->isByte()) {<br>
+ uint32 val = 0;<br>
+ RUN_METH(Int, val);<br>
+ res = vm->upcalls->byteClass->doNew(vm);<br>
+ vm->upcalls->byteValue->setInstanceInt8Field(res, val);<br>
+ } else if (prim->isChar()) {<br>
+ uint32 val = 0;<br>
+ RUN_METH(Int, val);<br>
+ res = vm->upcalls->charClass->doNew(vm);<br>
+ vm->upcalls->charValue->setInstanceInt16Field(res, val);<br>
+ } else if (prim->isShort()) {<br>
+ uint32 val = 0;<br>
+ RUN_METH(Int, val);<br>
+ res = vm->upcalls->shortClass->doNew(vm);<br>
+ vm->upcalls->shortValue->setInstanceInt16Field(res, val);<br>
+ } else if (prim->isInt()) {<br>
+ uint32 val = 0;<br>
+ RUN_METH(Int, val);<br>
+ res = vm->upcalls->intClass->doNew(vm);<br>
+ vm->upcalls->intValue->setInstanceInt32Field(res, val);<br>
+ } else if (prim->isLong()) {<br>
+ sint64 val = 0;<br>
+ RUN_METH(Long, val);<br>
+ res = vm->upcalls->longClass->doNew(vm);<br>
+ vm->upcalls->longValue->setInstanceLongField(res, val);<br>
+ } else if (prim->isFloat()) {<br>
+ float val = 0;<br>
+ RUN_METH(Float, val);<br>
+ res = vm->upcalls->floatClass->doNew(vm);<br>
+ vm->upcalls->floatValue->setInstanceFloatField(res, val);<br>
+ } else if (prim->isDouble()) {<br>
+ double val = 0;<br>
+ RUN_METH(Double, val);<br>
+ res = vm->upcalls->doubleClass->doNew(vm);<br>
+ vm->upcalls->doubleValue->setInstanceDoubleField(res, val);<br>
+ }<br>
+ } else {<br>
+ RUN_METH(JavaObject, res);<br>
+ }<br>
+ } else {<br>
+ vm->illegalArgumentException("wrong number of arguments");<br>
+ return NULL;<br>
+ }<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+#undef RUN_METH<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_invokeNative(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectMethod* Meth, JavaObject* obj, ArrayObject* args,<br>
JavaObject* Cl, jint index) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Meth, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(args, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ res = proceedMethod(Meth, obj, args, Cl, index);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT ArrayObject* JNICALL Java_java_lang_reflect_Method_getExceptionTypes(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectMethod* Meth) {<br>
+<br>
+ ArrayObject* res = 0;<br>
+ llvm_gcroot(Meth, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(Meth);<br>
+ UserClass* cl = JavaObjectMethod::getClass(Meth);<br>
+ JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
+ JnjvmClassLoader* loader = cl->classLoader;<br>
+ res = meth->getExceptionTypes(loader);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getSignature(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObjectMethod* Meth) {<br>
+<br>
+ JavaObject* result = 0;<br>
+ llvm_gcroot(Meth, 0);<br>
+ llvm_gcroot(result, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(Meth);<br>
+ JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ result = vm->internalUTF8ToStr(meth->type);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return result;<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp<br>
new file mode 100644<br>
index 0000000..3d69fa4<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.cpp<br>
@@ -0,0 +1,30 @@<br>
+//===- ClasspathReflect.cpp - Internal representation of core system<br>
classes -//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+<br>
+namespace j3 {<br>
+<br>
+JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*<br>
self) {<br>
+ llvm_gcroot(self, 0);<br>
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
+ return &(cls->asClass()->virtualMethods[self->slot]);<br>
+}<br>
+<br>
+<br>
+JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {<br>
+ llvm_gcroot(self, 0);<br>
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
+ return &(cls->asClass()->virtualMethods[self->slot]);<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h<br>
new file mode 100644<br>
index 0000000..494e444<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathReflect.h<br>
@@ -0,0 +1,222 @@<br>
+//===-- ClasspathReflect.h - Internal representation of core system<br>
classes --//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#ifndef JNJVM_CLASSPATH_REFLECT_H<br>
+#define JNJVM_CLASSPATH_REFLECT_H<br>
+<br>
+#include "MvmGC.h"<br>
+<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+<br>
+extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);<br>
+<br>
+namespace j3 {<br>
+<br>
+class JavaObjectClass : public JavaObject {<br>
+private:<br>
+ JavaObject* signers;<br>
+ JavaObject* pd;<br>
+ UserCommonClass* vmdata;<br>
+ JavaObject* constructor;<br>
+<br>
+public:<br>
+<br>
+ static UserCommonClass* getClass(JavaObjectClass* cl) {<br>
+ llvm_gcroot(cl, 0);<br>
+ return cl->vmdata;<br>
+ }<br>
+<br>
+ static void setClass(JavaObjectClass* cl, UserCommonClass* vmdata) {<br>
+ llvm_gcroot(cl, 0);<br>
+ cl->vmdata = vmdata;<br>
+ }<br>
+<br>
+ static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {<br>
+ llvm_gcroot(cl, 0);<br>
+ llvm_gcroot(pd, 0);<br>
+ mvm::Collector::objectReferenceWriteBarrier(<br>
+ (gc*)cl, (gc**)&(cl->pd), (gc*)pd);<br>
+ }<br>
+<br>
+ static JavaObject* getProtectionDomain(JavaObjectClass* cl) {<br>
+ llvm_gcroot(cl, 0);<br>
+ return cl->pd;<br>
+ }<br>
+<br>
+ static void staticTracer(JavaObjectClass* obj, word_t closure) {<br>
+ mvm::Collector::markAndTrace(obj, &obj->pd, closure);<br>
+ mvm::Collector::markAndTrace(obj, &obj->signers, closure);<br>
+ mvm::Collector::markAndTrace(obj, &obj->constructor, closure);<br>
+ if (obj->vmdata) {<br>
+ JavaObject** Obj = obj->vmdata->classLoader->getJavaClassLoaderPtr();<br>
+ if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);<br>
+ }<br>
+ }<br>
+};<br>
+<br>
+class JavaObjectField : public JavaObject {<br>
+private:<br>
+ uint8 flag;<br>
+ JavaObjectClass* declaringClass;<br>
+ JavaObject* name;<br>
+ uint32 slot;<br>
+<br>
+public:<br>
+<br>
+ static void staticTracer(JavaObjectField* obj, word_t closure) {<br>
+ mvm::Collector::markAndTrace(obj, &obj->name, closure);<br>
+ mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);<br>
+ }<br>
+<br>
+ static JavaField* getInternalField(JavaObjectField* self) {<br>
+ llvm_gcroot(self, 0);<br>
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
+ return &(cls->asClass()->virtualFields[self->slot]);<br>
+ }<br>
+<br>
+ static UserClass* getClass(JavaObjectField* self) {<br>
+ llvm_gcroot(self, 0);<br>
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
+ return cls->asClass();<br>
+ }<br>
+<br>
+};<br>
+<br>
+class JavaObjectMethod : public JavaObject {<br>
+private:<br>
+ uint8 flag;<br>
+ JavaObjectClass* declaringClass;<br>
+ JavaObject* name;<br>
+ uint32 slot;<br>
+<br>
+public:<br>
+<br>
+ static void staticTracer(JavaObjectMethod* obj, word_t closure) {<br>
+ mvm::Collector::markAndTrace(obj, &obj->name, closure);<br>
+ mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);<br>
+ }<br>
+<br>
+ static JavaMethod* getInternalMethod(JavaObjectMethod* self);<br>
+<br>
+ static UserClass* getClass(JavaObjectMethod* self) {<br>
+ llvm_gcroot(self, 0);<br>
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
+ return cls->asClass();<br>
+ }<br>
+<br>
+};<br>
+<br>
+class JavaObjectConstructor : public JavaObject {<br>
+private:<br>
+ uint8 flag;<br>
+ JavaObjectClass* declaringClass;<br>
+ uint32 slot;<br>
+<br>
+public:<br>
+ static void staticTracer(JavaObjectConstructor* obj, word_t closure) {<br>
+ mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);<br>
+ }<br>
+<br>
+ static JavaMethod* getInternalMethod(JavaObjectConstructor* self);<br>
+<br>
+ static UserClass* getClass(JavaObjectConstructor* self) {<br>
+ llvm_gcroot(self, 0);<br>
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
+ return cls->asClass();<br>
+ }<br>
+<br>
+};<br>
+<br>
+class JavaObjectVMThread : public JavaObject {<br>
+private:<br>
+ JavaObject* thread;<br>
+ bool running;<br>
+ JavaThread* vmdata;<br>
+<br>
+public:<br>
+ static void staticTracer(JavaObjectVMThread* obj, word_t closure) {<br>
+ mvm::Collector::markAndTrace(obj, &obj->thread, closure);<br>
+ }<br>
+<br>
+ static void setVmdata(JavaObjectVMThread* vmthread,<br>
+ JavaThread* internal_thread) {<br>
+ llvm_gcroot(vmthread, 0);<br>
+ vmthread->vmdata = internal_thread;<br>
+ }<br>
+<br>
+};<br>
+<br>
+<br>
+class JavaObjectThrowable : public JavaObject {<br>
+private:<br>
+ JavaObject* detailedMessage;<br>
+ JavaObject* cause;<br>
+ JavaObject* stackTrace;<br>
+ JavaObject* vmState;<br>
+<br>
+public:<br>
+<br>
+ static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {<br>
+ llvm_gcroot(self, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+ mvm::Collector::objectReferenceWriteBarrier(<br>
+ (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);<br>
+ }<br>
+<br>
+ static void fillInStackTrace(JavaObjectThrowable* self) {<br>
+ JavaObject* stackTrace = NULL;<br>
+ llvm_gcroot(self, 0);<br>
+ llvm_gcroot(stackTrace, 0);<br>
+<br>
+ stackTrace = internalFillInStackTrace(self);<br>
+ mvm::Collector::objectReferenceWriteBarrier(<br>
+ (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);<br>
+<br>
+ mvm::Collector::objectReferenceWriteBarrier(<br>
+ (gc*)self, (gc**)&(self->cause), (gc*)self);<br>
+<br>
+ self->stackTrace = NULL;<br>
+ }<br>
+};<br>
+<br>
+class JavaObjectReference : public JavaObject {<br>
+private:<br>
+ JavaObject* referent;<br>
+ JavaObject* queue;<br>
+ JavaObject* nextOnQueue;<br>
+<br>
+public:<br>
+ static void init(JavaObjectReference* self, JavaObject* r, JavaObject* q) {<br>
+ llvm_gcroot(self, 0);<br>
+ llvm_gcroot(r, 0);<br>
+ llvm_gcroot(q, 0);<br>
+ mvm::Collector::objectReferenceWriteBarrier(<br>
+ (gc*)self, (gc**)&(self->referent), (gc*)r);<br>
+ mvm::Collector::objectReferenceWriteBarrier(<br>
+ (gc*)self, (gc**)&(self->queue), (gc*)q);<br>
+ }<br>
+<br>
+ static JavaObject** getReferentPtr(JavaObjectReference* self) {<br>
+ llvm_gcroot(self, 0);<br>
+ return &(self->referent);<br>
+ }<br>
+<br>
+ static void setReferent(JavaObjectReference* self, JavaObject* r) {<br>
+ llvm_gcroot(self, 0);<br>
+ llvm_gcroot(r, 0);<br>
+ // No write barrier: this is only called by the GC.<br>
+ self->referent = r;<br>
+ }<br>
+};<br>
+<br>
+}<br>
+<br>
+#endif<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc<br>
new file mode 100644<br>
index 0000000..26fa36a<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClass.inc<br>
@@ -0,0 +1,645 @@<br>
+//===---- ClasspathVMClass.cpp - GNU classpath java/lang/VMClass<br>
----------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaAccess.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaString.h"<br>
+#include "JavaTypes.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+// Never throws<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObjectClass* klass) {<br>
+<br>
+ llvm_gcroot(klass, 0);<br>
+<br>
+ UserCommonClass* cl = JavaObjectClass::getClass(klass);<br>
+<br>
+ return cl->isArray();<br>
+<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_forName(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaString* str,<br>
+jboolean clinit,<br>
+JavaObject* loader) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(loader, 0);<br>
+ llvm_gcroot(str, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(str);<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JnjvmClassLoader* JCL =<br>
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);<br>
+ UserCommonClass* cl = JCL->loadClassFromJavaString(str, true, false);<br>
+<br>
+ if (cl != NULL && !cl->isPrimitive()) {<br>
+ if (clinit && cl->asClass()) {<br>
+ cl->asClass()->initialiseClass(vm);<br>
+ }<br>
+ res = cl->getClassDelegatee(vm);<br>
+ } else {<br>
+ vm->classNotFoundException(str);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredConstructors(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl,<br>
+jboolean publicOnly) {<br>
+<br>
+ ArrayObject* ret = 0;<br>
+ JavaObject* tmp = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(ret, 0);<br>
+ llvm_gcroot(tmp, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {<br>
+ ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);<br>
+ } else {<br>
+ UserClass* realCl = cl->asClass();;<br>
+ JnjvmClassLoader* classLoader = cl->classLoader;<br>
+ uint32 size = 0;<br>
+<br>
+ for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {<br>
+ JavaMethod* meth = &realCl->virtualMethods[i];<br>
+ bool pub = isPublic(meth->access);<br>
+ if (meth->name->equals(classLoader->bootstrapLoader->initName) &&<br>
+ (!publicOnly || pub)) {<br>
+ ++size;<br>
+ }<br>
+ }<br>
+<br>
+ ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);<br>
+<br>
+ sint32 index = 0;<br>
+ for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {<br>
+ JavaMethod* meth = &realCl->virtualMethods[i];<br>
+ bool pub = isPublic(meth->access);<br>
+ if (meth->name->equals(classLoader->bootstrapLoader->initName) &&<br>
+ (!publicOnly || pub)) {<br>
+ UserClass* Cons = vm->upcalls->newConstructor;<br>
+ tmp = Cons->doNew(vm);<br>
+ vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);<br>
+ ArrayObject::setElement(ret, tmp, index);<br>
+ index++;<br>
+ }<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return ret;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredMethods(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl,<br>
+jboolean publicOnly) {<br>
+<br>
+ ArrayObject* ret = 0;<br>
+ JavaObject* tmp = 0;<br>
+ JavaString* str = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(ret, 0);<br>
+ llvm_gcroot(tmp, 0);<br>
+ llvm_gcroot(str, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ Classpath* upcalls = vm->upcalls;<br>
+<br>
+ if (cl->isArray() || cl->isPrimitive()) {<br>
+ ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);<br>
+ } else {<br>
+ UserClass* realCl = cl->asClass();<br>
+ JnjvmClassLoader* classLoader = cl->classLoader;<br>
+ uint32 size = 0;<br>
+<br>
+ for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;<br>
+ ++i) {<br>
+ JavaMethod* meth = &realCl->virtualMethods[i];<br>
+ bool pub = isPublic(meth->access);<br>
+ if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&<br>
+ !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&<br>
+ (!publicOnly || pub)) {<br>
+ ++size;<br>
+ }<br>
+ }<br>
+<br>
+<br>
+ ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);<br>
+<br>
+ sint32 index = 0;<br>
+ for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;<br>
+ ++i) {<br>
+ JavaMethod* meth = &realCl->virtualMethods[i];<br>
+ bool pub = isPublic(meth->access);<br>
+ if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&<br>
+ !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&<br>
+ (!publicOnly || pub)) {<br>
+ // TODO: check parameter types<br>
+ UserClass* Meth = vm->upcalls->newMethod;<br>
+ tmp = Meth->doNew(vm);<br>
+ str = vm->internalUTF8ToStr(meth->name);<br>
+ upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);<br>
+ ArrayObject::setElement(ret, tmp, index);<br>
+ index++;<br>
+ }<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return ret;<br>
+}<br>
+<br>
+JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl,<br>
+jboolean ignore) {<br>
+<br>
+ jint res = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ res = cl->getAccess();<br>
+<br>
+ if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {<br>
+ // javac may put that flag to inner classes of enum classes.<br>
+ res &= ~ACC_ENUM;<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getName(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ JavaObject* result = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(result, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ const UTF8* iname = cl->getName();<br>
+ result = JavaString::internalToJava(iname, vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return result;<br>
+}<br>
+<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ jboolean res = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ res = cl->isPrimitive();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ jboolean res = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ res = cl->isInterface();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getComponentType(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ if (cl->isArray()) {<br>
+ UserCommonClass* bc = cl->asArrayClass()->baseClass();<br>
+ res = bc->getClassDelegatee(vm);<br>
+ } else {<br>
+ res = 0;<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getClassLoader(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ res = cl->classLoader->getJavaClassLoader();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl1, JavaObject* Cl2) {<br>
+<br>
+ jboolean res = 0;<br>
+ llvm_gcroot(Cl1, 0);<br>
+ llvm_gcroot(Cl2, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ if (!Cl2) vm->nullPointerException();<br>
+<br>
+ UserCommonClass* cl1 = UserCommonClass::resolvedImplClass(vm, Cl1, false);<br>
+ UserCommonClass* cl2 = UserCommonClass::resolvedImplClass(vm, Cl2, false);<br>
+<br>
+ res = cl2->isAssignableFrom(cl1);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getSuperclass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ if (cl->isInterface()) res = 0;<br>
+ else {<br>
+ if (cl->getSuper()) res = cl->getSuper()->getClassDelegatee(vm);<br>
+ else res = 0;<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl, JavaObject* obj) {<br>
+<br>
+ bool res = false;<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ res = JavaObject::instanceOf(obj, cl);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredFields(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl, jboolean publicOnly) {<br>
+<br>
+ ArrayObject* ret = 0;<br>
+ JavaObject* tmp = 0;<br>
+ JavaString* name = 0;<br>
+ llvm_gcroot(Cl, 0);<br>
+ llvm_gcroot(ret, 0);<br>
+ llvm_gcroot(tmp, 0);<br>
+ llvm_gcroot(name, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ if (!cl->isClass()) {<br>
+ ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);<br>
+ } else {<br>
+ UserClass* realCl = cl->asClass();<br>
+ uint32 size = 0;<br>
+ for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;<br>
+ ++i) {<br>
+ JavaField* field = &realCl->virtualFields[i];<br>
+ if (!publicOnly || isPublic(field->access)) {<br>
+ ++size;<br>
+ }<br>
+ }<br>
+<br>
+<br>
+ ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);<br>
+<br>
+ sint32 index = 0;<br>
+ for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;<br>
+ ++i) {<br>
+ JavaField* field = &realCl->virtualFields[i];<br>
+ if (!publicOnly || isPublic(field->access)) {<br>
+ // TODO: check parameter types<br>
+ UserClass* Field = vm->upcalls->newField;<br>
+ tmp = Field->doNew(vm);<br>
+ name = vm->internalUTF8ToStr(field->name);<br>
+ vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,<br>
&name, i);<br>
+ ArrayObject::setElement(ret, tmp, index);<br>
+ index++;<br>
+ }<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return ret;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getInterfaces(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ ArrayObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,<br>
vm);<br>
+<br>
+ for (uint16 i = 0; i < cl->nbInterfaces; ++i) {<br>
+ UserClass* klass = cl->interfaces[i];<br>
+ ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaringClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+ JavaObject* res = 0;<br>
+<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();<br>
+<br>
+ if (cl) {<br>
+ cl->resolveInnerOuterClasses();<br>
+ UserClass* outer = cl->getOuterClass();<br>
+ if (outer) {<br>
+ res = outer->getClassDelegatee(vm);<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredClasses(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl, bool publicOnly) {<br>
+<br>
+ ArrayObject* result = 0;<br>
+ llvm_gcroot(result, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();<br>
+ if (cl) {<br>
+ cl->resolveInnerOuterClasses();<br>
+ UserClassArray* array = vm->upcalls->constructorArrayClass;<br>
+<br>
+ uint16 sizeArray = 0;<br>
+<br>
+ if (publicOnly) {<br>
+ for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {<br>
+ UserClass* klass = cl->innerClasses[i];<br>
+ if (isPublic(klass->innerAccess)) ++sizeArray;<br>
+ }<br>
+ } else {<br>
+ sizeArray = cl->nbInnerClasses;<br>
+ }<br>
+<br>
+ result = (ArrayObject*)array->doNew(sizeArray, vm);<br>
+ int index = 0;<br>
+ for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {<br>
+ UserClass* klass = cl->innerClasses[i];<br>
+ if (!publicOnly || isPublic(klass->innerAccess))<br>
+ ArrayObject::setElement(result, klass->getClassDelegatee(vm), index++);<br>
+ }<br>
+ assert(index == sizeArray);<br>
+ }<br>
+<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return result;<br>
+<br>
+}<br>
+<br>
+// Only throws.<br>
+JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* throwable) {<br>
+<br>
+ llvm_gcroot(throwable, 0);<br>
+<br>
+ assert(throwable && "Using internal VM throw exception without exception");<br>
+ JavaThread::get()->pendingException = (JavaObject*)throwable;<br>
+}<br>
+<br>
+JNIEXPORT ArrayObject* Java_java_lang_VMClass_getDeclaredAnnotations(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+ // TODO implement me<br>
+<br>
+ ArrayObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClassArray* array = vm->upcalls->constructorArrayAnnotation;<br>
+ res = (ArrayObject*)array->doNew(0, vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT jboolean Java_java_lang_VMClass_isAnonymousClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ jboolean res = false;<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();<br>
+<br>
+ if (cl) res = cl->isAnonymous;<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc<br>
new file mode 100644<br>
index 0000000..8a57db4<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMClassLoader.inc<br>
@@ -0,0 +1,380 @@<br>
+//===- ClasspathVMClassLoader.cpp - GNU classpath<br>
java/lang/VMClassLoader -===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaString.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+#include "Reader.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+jchar byteId) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClassPrimitive* prim =<br>
+ UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls);<br>
+<br>
+ if (!prim) {<br>
+ fprintf(stderr, "unknown byte primitive %c", byteId);<br>
+ abort();<br>
+ }<br>
+<br>
+ res = prim->getClassDelegatee(vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_findLoadedClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* loader,<br>
+JavaString* name) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(loader, 0);<br>
+ llvm_gcroot(name, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JnjvmClassLoader* JCL =<br>
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);<br>
+ UserCommonClass* cl = JCL->lookupClassFromJavaString(name);<br>
+<br>
+ if (cl) res = cl->getClassDelegatee(vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+ return 0;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_loadClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaString* str,<br>
+jboolean doResolve) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(str, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+<br>
+ JnjvmClassLoader* JCL = vm->bootstrapLoader;<br>
+ UserCommonClass* cl = JCL->loadClassFromJavaString(str, doResolve, false);<br>
+<br>
+ if (cl != 0) res = cl->getClassDelegatee(vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_defineClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* loader,<br>
+JavaString* str,<br>
+ArrayUInt8* bytes,<br>
+jint off,<br>
+jint len,<br>
+JavaObject* pd) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ JavaObject* excp = 0;<br>
+ llvm_gcroot(loader, 0);<br>
+ llvm_gcroot(str, 0);<br>
+ llvm_gcroot(bytes, 0);<br>
+ llvm_gcroot(pd, 0);<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(excp, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ // We need a name, which is unfortunately not required by the spec.<br>
+ verifyNull(str);<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+<br>
+ JnjvmClassLoader* JCL =<br>
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);<br>
+<br>
+ int32_t size = JavaArray::getSize(bytes);<br>
+ ClassBytes* classBytes = new (JCL->allocator, size) ClassBytes(size);<br>
+ memcpy(classBytes->elements, JavaArray::getElements(bytes), size);<br>
+<br>
+ // Before creating a class, do a check on the bytes.<br>
+ Reader reader(classBytes);<br>
+ uint32 magic = reader.readU4();<br>
+ if (magic != Jnjvm::Magic) {<br>
+ JavaThread::get()->getJVM()->classFormatError("bad magic number");<br>
+ }<br>
+<br>
+<br>
+ const UTF8* name = JavaString::javaToInternal(str, JCL->hashUTF8);<br>
+ UserCommonClass* cl = JCL->lookupClass(name);<br>
+<br>
+ if (!cl) {<br>
+ UserClass* cl = JCL->constructClass(name, classBytes);<br>
+ cl->resolveClass();<br>
+<br>
+ res = cl->getClassDelegatee(vm, pd);<br>
+ } else {<br>
+ excp = vm->CreateLinkageError("duplicate class definition");<br>
+ JavaThread::get()->throwException(excp);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ verifyNull(Cl);<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+#define NUM_BOOT_PACKAGES 168<br>
+<br>
+static const char* bootPackages[NUM_BOOT_PACKAGES] = {<br>
+ "java.applet",<br>
+ "java.awt",<br>
+ "java.awt.color",<br>
+ "java.awt.datatransfer",<br>
+ "java.awt.dnd",<br>
+ "java.awt.dnd.peer",<br>
+ "java.awt.event",<br>
+ "java.awt.font",<br>
+ "java.awt.geom",<br>
+ "<a href="http://java.awt.im" target="_blank">java.awt.im</a>",<br>
+ "java.awt.im.spi",<br>
+ "java.awt.image",<br>
+ "java.awt.image.renderable",<br>
+ "java.awt.peer",<br>
+ "java.awt.print",<br>
+ "java.beans",<br>
+ "java.beans.beancontext",<br>
+ "<a href="http://java.io" target="_blank">java.io</a>",<br>
+ "java.lang",<br>
+ "java.lang.annotation",<br>
+ "java.lang.instrument",<br>
+ "java.lang.management",<br>
+ "java.lang.ref",<br>
+ "java.lang.reflect",<br>
+ "java.math",<br>
+ "<a href="http://java.net" target="_blank">java.net</a>",<br>
+ "java.nio",<br>
+ "java.nio.channels",<br>
+ "java.nio.channels.spi",<br>
+ "java.nio.charset",<br>
+ "java.nio.charset.spi",<br>
+ "java.rmi",<br>
+ "java.rmi.activation",<br>
+ "java.rmi.dgc",<br>
+ "java.rmi.registry",<br>
+ "java.rmi.server",<br>
+ "java.security",<br>
+ "java.security.acl",<br>
+ "java.security.cert",<br>
+ "java.security.interfaces",<br>
+ "java.security.spec",<br>
+ "java.sql",<br>
+ "java.text",<br>
+ "java.util",<br>
+ "java.util.concurrent",<br>
+ "java.util.concurrent.atomic",<br>
+ "java.util.concurrent.locks",<br>
+ "java.util.jar",<br>
+ "java.util.logging",<br>
+ "java.util.prefs",<br>
+ "java.util.regex",<br>
+ "java.util.zip",<br>
+ "javax.accessibility",<br>
+ "javax.activity",<br>
+ "javax.crypto",<br>
+ "javax.crypto.interfaces",<br>
+ "javax.crypto.spec",<br>
+ "javax.imageio",<br>
+ "javax.imageio.event",<br>
+ "javax.imageio.metadata",<br>
+ "javax.imageio.plugins.bmp",<br>
+ "javax.imageio.plugins.jpeg",<br>
+ "javax.imageio.spi",<br>
+ "javax.imageio.stream",<br>
+ "javax.management",<br>
+ "javax.management.loading",<br>
+ "javax.management.modelmbean",<br>
+ "javax.management.monitor",<br>
+ "javax.management.openmbean",<br>
+ "javax.management.relation",<br>
+ "javax.management.remote",<br>
+ "javax.management.remote.rmi",<br>
+ "javax.management.timer",<br>
+ "javax.naming",<br>
+ "javax.naming.directory",<br>
+ "javax.naming.event",<br>
+ "javax.naming.ldap",<br>
+ "javax.naming.spi",<br>
+ "<a href="http://javax.net" target="_blank">javax.net</a>",<br>
+ "javax.net.ssl",<br>
+ "javax.print",<br>
+ "javax.print.attribute",<br>
+ "javax.print.attribute.standard",<br>
+ "javax.print.event",<br>
+ "javax.rmi",<br>
+ "javax.rmi.CORBA",<br>
+ "javax.rmi.ssl",<br>
+ "javax.security.auth",<br>
+ "javax.security.auth.callback",<br>
+ "javax.security.auth.kerberos",<br>
+ "javax.security.auth.login",<br>
+ "javax.security.auth.spi",<br>
+ "javax.security.auth.x500",<br>
+ "javax.security.cert",<br>
+ "javax.security.sasl",<br>
+ "javax.sound.midi",<br>
+ "javax.sound.midi.spi",<br>
+ "javax.sound.sampled",<br>
+ "javax.sound.sampled.spi",<br>
+ "javax.sql",<br>
+ "javax.sql.rowset",<br>
+ "javax.sql.rowset.serial",<br>
+ "javax.sql.rowset.spi",<br>
+ "javax.swing",<br>
+ "javax.swing.border",<br>
+ "javax.swing.colorchooser",<br>
+ "javax.swing.event",<br>
+ "javax.swing.filechooser",<br>
+ "javax.swing.plaf",<br>
+ "javax.swing.plaf.basic",<br>
+ "javax.swing.plaf.metal",<br>
+ "javax.swing.plaf.multi",<br>
+ "javax.swing.plaf.synth",<br>
+ "javax.swing.table",<br>
+ "javax.swing.text",<br>
+ "javax.swing.text.html",<br>
+ "javax.swing.text.html.parser",<br>
+ "javax.swing.text.rtf",<br>
+ "javax.swing.tree",<br>
+ "javax.swing.undo",<br>
+ "javax.transaction",<br>
+ "javax.transaction.xa",<br>
+ "javax.xml",<br>
+ "javax.xml.datatype",<br>
+ "javax.xml.namespace",<br>
+ "javax.xml.parsers",<br>
+ "javax.xml.transform",<br>
+ "javax.xml.transform.dom",<br>
+ "javax.xml.transform.sax",<br>
+ "javax.xml.transform.stream",<br>
+ "javax.xml.validation",<br>
+ "javax.xml.xpath",<br>
+ "org.ietf.jgss",<br>
+ "org.omg.CORBA",<br>
+ "org.omg.CORBA_2_3",<br>
+ "org.omg.CORBA_2_3.portable",<br>
+ "org.omg.CORBA.DynAnyPackage",<br>
+ "org.omg.CORBA.ORBPackage",<br>
+ "org.omg.CORBA.portable",<br>
+ "org.omg.CORBA.TypeCodePackage",<br>
+ "org.omg.CosNaming",<br>
+ "org.omg.CosNaming.NamingContextExtPackage",<br>
+ "org.omg.CosNaming.NamingContextPackage",<br>
+ "org.omg.Dynamic",<br>
+ "org.omg.DynamicAny",<br>
+ "org.omg.DynamicAny.DynAnyFactoryPackage",<br>
+ "org.omg.DynamicAny.DynAnyPackage",<br>
+ "org.omg.IOP",<br>
+ "org.omg.IOP.CodecFactoryPackage",<br>
+ "org.omg.IOP.CodecPackage",<br>
+ "org.omg.Messaging",<br>
+ "org.omg.PortableInterceptor",<br>
+ "org.omg.PortableInterceptor.ORBInitInfoPackage",<br>
+ "org.omg.PortableServer",<br>
+ "org.omg.PortableServer.CurrentPackage",<br>
+ "org.omg.PortableServer.POAManagerPackage",<br>
+ "org.omg.PortableServer.POAPackage",<br>
+ "org.omg.PortableServer.portable",<br>
+ "org.omg.PortableServer.ServantLocatorPackage",<br>
+ "org.omg.SendingContext",<br>
+ "org.omg.stub.java.rmi",<br>
+ "org.w3c.dom",<br>
+ "org.w3c.dom.bootstrap",<br>
+ "org.w3c.dom.events",<br>
+ "<a href="http://org.w3c.dom.ls" target="_blank">org.w3c.dom.ls</a>",<br>
+ "org.xml.sax",<br>
+ "org.xml.sax.ext",<br>
+ "org.xml.sax.helpers"<br>
+};<br>
+<br>
+extern "C" ArrayObject* Java_java_lang_VMClassLoader_getBootPackages__() {<br>
+ ArrayObject* obj = 0;<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ obj = (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES, vm);<br>
+ for (uint32 i = 0; i < NUM_BOOT_PACKAGES; ++i) {<br>
+ ArrayObject::setElement(obj, vm->asciizToStr(bootPackages[i]), i);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return obj;<br>
+}<br>
+<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc<br>
new file mode 100644<br>
index 0000000..c71fb5b<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMObject.inc<br>
@@ -0,0 +1,170 @@<br>
+//===------ ClasspathVMObject.cpp - GNU classpath java/lang/VMObject<br>
------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_clone(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* src) {<br>
+<br>
+ JavaObject* res = NULL;<br>
+ JavaObject* tmp = NULL;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(src, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ UserCommonClass* cl = JavaObject::getClass(src);<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ if (cl->isArray()) {<br>
+ UserClassArray* array = cl->asArrayClass();<br>
+ int length = JavaArray::getSize(src);<br>
+ res = array->doNew(length, vm);<br>
+ UserCommonClass* base = array->baseClass();<br>
+ if (base->isPrimitive()) {<br>
+ int size = length << base->asPrimitiveClass()->logSize;<br>
+ memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),<br>
+ (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),<br>
+ size);<br>
+ } else {<br>
+ for (int i = 0; i < length; i++) {<br>
+ tmp = ArrayObject::getElement((ArrayObject*)src, i);<br>
+ ArrayObject::setElement((ArrayObject*)res, tmp, i);<br>
+ }<br>
+ }<br>
+ } else {<br>
+ assert(cl->isClass() && "Not a class!");<br>
+ res = cl->asClass()->doNew(vm);<br>
+ while (cl != NULL) {<br>
+ for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {<br>
+ JavaField& field = cl->asClass()->virtualFields[i];<br>
+ if (field.isReference()) {<br>
+ tmp = field.getInstanceObjectField(src);<br>
+ JavaObject** ptr = field.getInstanceObjectFieldPtr(res);<br>
+ mvm::Collector::objectReferenceWriteBarrier((gc*)res,<br>
(gc**)ptr, (gc*)tmp);<br>
+ } else if (field.isLong()) {<br>
+ field.setInstanceLongField(res, field.getInstanceLongField(src));<br>
+ } else if (field.isDouble()) {<br>
+ field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));<br>
+ } else if (field.isInt()) {<br>
+ field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));<br>
+ } else if (field.isFloat()) {<br>
+ field.setInstanceFloatField(res, field.getInstanceFloatField(src));<br>
+ } else if (field.isShort() || field.isChar()) {<br>
+ field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));<br>
+ } else if (field.isByte() || field.isBoolean()) {<br>
+ field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));<br>
+ } else {<br>
+ UNREACHABLE();<br>
+ }<br>
+ }<br>
+ cl = cl->super;<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_getClass(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* obj) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ res = JavaObject::getClass(obj)->getClassDelegatee(vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* obj) {<br>
+<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObject::notifyAll(obj);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMObject_wait(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* obj, jlong ms, jint ns) {<br>
+<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ uint32 sec = (uint32) (ms / 1000);<br>
+ uint32 usec = (ns / 1000) + 1000 * (ms % 1000);<br>
+ if (ns && !usec) usec = 1;<br>
+ if (sec || usec) {<br>
+ struct timeval t;<br>
+ t.tv_sec = sec;<br>
+ t.tv_usec = usec;<br>
+ JavaObject::timedWait(obj, t);<br>
+ } else {<br>
+ JavaObject::wait(obj);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMObject_notify(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* obj) {<br>
+<br>
+ llvm_gcroot(obj, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObject::notify(obj);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc<br>
new file mode 100644<br>
index 0000000..3a39c4f<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMRuntime.inc<br>
@@ -0,0 +1,228 @@<br>
+//===------ ClasspathVMRuntime.cpp - GNU classpath<br>
java/lang/VMRuntime ----===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+<br>
+#include "MvmGC.h"<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaString.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+#include <cstring><br>
+#include <unistd.h><br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMRuntime_mapLibraryName(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaString* strLib) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ ArrayUInt16* array = 0;<br>
+ const ArrayUInt16* utf8Lib = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(array, 0);<br>
+ llvm_gcroot(utf8Lib, 0);<br>
+ llvm_gcroot(strLib, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+<br>
+ utf8Lib = JavaString::getValue(strLib);<br>
+ uint32 stLib = strLib->offset;<br>
+ sint32 lgLib = strLib->count;<br>
+ sint32 lgPre = vm->bootstrapLoader->prelib->size;<br>
+ sint32 lgPost = vm->bootstrapLoader->postlib->size;<br>
+<br>
+ uint32 size = (uint32)(lgPre + lgLib + lgPost);<br>
+ array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);<br>
+ uint16* elements = ArrayUInt16::getElements(array);<br>
+<br>
+ memmove(elements, vm->bootstrapLoader->prelib->elements,<br>
+ lgPre * sizeof(uint16));<br>
+ memmove(&(elements[lgPre]), ArrayUInt16::getElements(utf8Lib) + stLib,<br>
+ lgLib * sizeof(uint16));<br>
+ memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements,<br>
+ lgPost * sizeof(uint16));<br>
+<br>
+ res = vm->constructString(array);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+<br>
+}<br>
+<br>
+typedef int (*onLoad_t)(const void**, void*);<br>
+extern "C" void j3EndJNI(uint32** old);<br>
+extern "C" void j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame* Frame);<br>
+<br>
+extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)<br>
+ __attribute__ ((noinline));<br>
+<br>
+extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm)<br>
+ __attribute__ ((noinline));<br>
+<br>
+extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm) {<br>
+ func(&vm->javavmEnv, res);<br>
+ return 1;<br>
+}<br>
+<br>
+// Calls the JNI_OnLoad function of a dynamic library.<br>
+extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm) {<br>
+<br>
+ onLoad_t onLoad = (onLoad_t)loader->loadInLib("JNI_OnLoad", res);<br>
+<br>
+ if (onLoad) {<br>
+ uint32 num = 0;<br>
+ uint32* old = 0;<br>
+ mvm::KnownFrame Frame;<br>
+<br>
+ j3StartJNI(&num, &old, &Frame);<br>
+ doCall(onLoad, res, vm);<br>
+ j3EndJNI(&old);<br>
+ }<br>
+}<br>
+<br>
+// Never throws.<br>
+JNIEXPORT jint JNICALL Java_java_lang_VMRuntime_nativeLoad(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaString* str,<br>
+JavaObject* javaLoader) {<br>
+<br>
+<br>
+ llvm_gcroot(str, 0);<br>
+ llvm_gcroot(javaLoader, 0);<br>
+<br>
+ void* res = 0;<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JnjvmClassLoader* loader =<br>
+ JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);<br>
+<br>
+ mvm::ThreadAllocator allocator;<br>
+ char* buf = JavaString::strToAsciiz(str, &allocator);<br>
+<br>
+ res = loader->loadLib(buf);<br>
+<br>
+ if (res) callOnLoad(res, loader, vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res != 0;<br>
+}<br>
+<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMRuntime_gc(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ mvm::Collector::collect();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ mvm::Collector::collect();<br>
+ // Sleep a bit.<br>
+ sleep(1);<br>
+ return;<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizationForExit(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ return;<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizersOnExit(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+uint8 value<br>
+) {<br>
+ return;<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMRuntime_exit(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+jint par1) {<br>
+ mvm::System::Exit(par1);<br>
+}<br>
+<br>
+JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ return (jlong)mvm::Collector::getFreeMemory();<br>
+}<br>
+<br>
+JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ return (jlong)mvm::Collector::getTotalMemory();<br>
+}<br>
+<br>
+JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ return (jlong)mvm::Collector::getMaxMemory();<br>
+}<br>
+<br>
+JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+ return mvm::System::GetNumberOfProcessors();<br>
+}<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc<br>
new file mode 100644<br>
index 0000000..361ec45<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMStackWalker.inc<br>
@@ -0,0 +1,86 @@<br>
+//===- ClasspathVMStackWalker.cpp<br>
-----------------------------------------===//<br>
+//===------------ GNU classpath gnu/classpath/VMStackWalker<br>
---------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_gnu_classpath_VMStackWalker_getClassContext(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+<br>
+ ArrayObject* result = NULL;<br>
+ JavaObject* delegatee = NULL;<br>
+ llvm_gcroot(result, 0);<br>
+ llvm_gcroot(delegatee, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ Jnjvm* vm = th->getJVM();<br>
+ uint32 length = th->getFrameContextLength();<br>
+<br>
+ mvm::ThreadAllocator allocator;<br>
+ uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *<br>
sizeof(uintptr_t));<br>
+<br>
+ uint32 finalSize = th->getJavaFrameContext((void**)buffer);<br>
+<br>
+ result = (ArrayObject*)<br>
+ vm->upcalls->stackTraceArray->doNew(finalSize, vm);<br>
+<br>
+ for (uint32 i = 0; i != finalSize; ++i) {<br>
+ JavaMethod* meth = ((JavaMethod**)buffer)[i];<br>
+ assert(meth && "Wrong stack trace");<br>
+ delegatee = meth->classDef->getClassDelegatee(vm);;<br>
+ ArrayObject::setElement(result, delegatee, i);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return result;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* Cl) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(Cl, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
+ res = cl->classLoader->getJavaClassLoader();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc<br>
new file mode 100644<br>
index 0000000..38bc9ec<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystem.inc<br>
@@ -0,0 +1,119 @@<br>
+//===-- ClasspathVMSystem.cpp - GNU classpath java/lang/VMSystem<br>
----------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass _cl,<br>
+#endif<br>
+JavaObject* src,<br>
+jint sstart,<br>
+JavaObject* dst,<br>
+jint dstart,<br>
+jint len) {<br>
+<br>
+ JavaObject* cur = 0;<br>
+ llvm_gcroot(src, 0);<br>
+ llvm_gcroot(dst, 0);<br>
+ llvm_gcroot(cur, 0);<br>
+ assert(src->getVirtualTable());<br>
+ assert(dst->getVirtualTable());<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ Jnjvm *vm = th->getJVM();<br>
+<br>
+ if (src == NULL || dst == NULL) {<br>
+ th->pendingException = vm->CreateNullPointerException();<br>
+ return;<br>
+ }<br>
+<br>
+ if (!(JavaObject::getClass(src)->isArray() &&<br>
+ JavaObject::getClass(dst)->isArray())) {<br>
+ th->pendingException = vm->CreateArrayStoreException(<br>
+ (JavaVirtualTable*)dst->getVirtualTable());<br>
+ return;<br>
+ }<br>
+<br>
+ UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);<br>
+ UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);<br>
+ UserCommonClass* dstType = td->baseClass();<br>
+ UserCommonClass* srcType = ts->baseClass();<br>
+<br>
+ sint32 srcSize = JavaArray::getSize(src);<br>
+ sint32 dstSize = JavaArray::getSize(dst);<br>
+<br>
+ if (len > srcSize) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(len);<br>
+ } else if (len > dstSize) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(len);<br>
+ } else if (len + sstart > srcSize) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(len + sstart);<br>
+ } else if (len + dstart > dstSize) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(len + dstart);<br>
+ } else if (dstart < 0) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(dstart);<br>
+ } else if (sstart < 0) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(sstart);<br>
+ } else if (len < 0) {<br>
+ th->pendingException = vm->CreateIndexOutOfBoundsException(len);<br>
+ } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&<br>
+ srcType != dstType) {<br>
+ th->pendingException = vm->CreateArrayStoreException(<br>
+ (JavaVirtualTable*)dst->getVirtualTable());<br>
+ }<br>
+ if (th->pendingException != NULL) return;<br>
+<br>
+ if (!(dstType->isPrimitive())) {<br>
+ for (int i = 0; i < len; i++) {<br>
+ cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);<br>
+ if (cur) {<br>
+ if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {<br>
+ th->pendingException = vm->CreateArrayStoreException(<br>
+ (JavaVirtualTable*)dst->getVirtualTable());<br>
+ break;<br>
+ } else {<br>
+ ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);<br>
+ }<br>
+ }<br>
+ }<br>
+ } else {<br>
+ uint32 logSize = dstType->asPrimitiveClass()->logSize;<br>
+ void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) +<br>
(dstart << logSize));<br>
+ void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) +<br>
(sstart << logSize));<br>
+ memmove(ptrDst, ptrSrc, len << logSize);<br>
+ }<br>
+<br>
+}<br>
+<br>
+JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* obj) {<br>
+<br>
+ llvm_gcroot(obj, 0);<br>
+ if (obj == NULL) return 0;<br>
+ return JavaObject::hashCode(obj);<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc<br>
new file mode 100644<br>
index 0000000..7e9e5c1<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMSystemProperties.inc<br>
@@ -0,0 +1,154 @@<br>
+//===- ClasspathVMSystem/Properties.cpp<br>
-----------------------------------===//<br>
+//===--------------------- GNU classpath<br>
gnu/classpath/VMSystemProperties -===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include <sys/utsname.h><br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+void setProperty(Jnjvm* vm, JavaObject* prop, const char* key,<br>
+ const char* val) {<br>
+<br>
+ JavaString* Val = 0;<br>
+ JavaString* Key = 0;<br>
+ llvm_gcroot(prop, 0);<br>
+ llvm_gcroot(Val, 0);<br>
+ llvm_gcroot(Key, 0);<br>
+<br>
+ Val = vm->asciizToStr(val);<br>
+ Key = vm->asciizToStr(key);<br>
+<br>
+ vm->upcalls->setProperty->invokeIntSpecial(<br>
+ vm, (UserClass*)JavaObject::getClass(prop), prop, &Key, &Val);<br>
+}<br>
+<br>
+void setUnameProp(Jnjvm* vm, JavaObject* prop) {<br>
+<br>
+ llvm_gcroot(prop, 0);<br>
+<br>
+ struct utsname infos;<br>
+ uname(&infos);<br>
+ setProperty(vm, prop, "<a href="http://os.name" target="_blank">os.name</a>", infos.sysname);<br>
+ setProperty(vm, prop, "os.arch", infos.machine);<br>
+ setProperty(vm, prop, "os.version", infos.release);<br>
+ if (!strcmp(infos.machine, "ppc")) {<br>
+ setProperty(vm, prop, "gnu.cpu.endian","big");<br>
+ } else {<br>
+ setProperty(vm, prop, "gnu.cpu.endian","little");<br>
+ }<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* prop) {<br>
+<br>
+ llvm_gcroot(prop, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ const char* tmp;<br>
+ setProperty(vm, prop, "java.vm.specification.version", "1.0");<br>
+ setProperty(vm, prop, "java.vm.specification.vendor",<br>
+ "Sun Microsystems, Inc");<br>
+ setProperty(vm, prop, "<a href="http://java.vm.specification.name" target="_blank">java.vm.specification.name</a>",<br>
+ "Java Virtual Machine Specification");<br>
+ setProperty(vm, prop, "java.specification.version", "1.5");<br>
+ setProperty(vm, prop, "java.specification.vendor", "Sun Microsystems, Inc");<br>
+ setProperty(vm, prop, "<a href="http://java.specification.name" target="_blank">java.specification.name</a>",<br>
+ "Java Platform API Specification");<br>
+ setProperty(vm, prop, "java.version", "1.5");<br>
+ setProperty(vm, prop, "java.runtime.version", "1.5");<br>
+ setProperty(vm, prop, "java.vendor", "The VMKit Project");<br>
+ setProperty(vm, prop, "java.vendor.url", "<a href="http://vmkit.llvm.org" target="_blank">http://vmkit.llvm.org</a>");<br>
+<br>
+ tmp = getenv("JAVA_HOME");<br>
+ if (!tmp) tmp = "";<br>
+ setProperty(vm, prop, "java.home", tmp);<br>
+<br>
+ JnjvmBootstrapLoader* JCL = vm->bootstrapLoader;<br>
+ setProperty(vm, prop, "java.class.version", "49.0");<br>
+ setProperty(vm, prop, "java.class.path", vm->classpath);<br>
+ setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv);<br>
+ setProperty(vm, prop, "sun.boot.class.path", JCL->bootClasspathEnv);<br>
+ setProperty(vm, prop, "java.vm.version", "0.28");<br>
+ setProperty(vm, prop, "java.vm.vendor", "The VMKit Project");<br>
+ setProperty(vm, prop, "<a href="http://java.vm.name" target="_blank">java.vm.name</a>", "J3");<br>
+ setProperty(vm, prop, "java.specification.version", "1.5");<br>
+ setProperty(vm, prop, "java.io.tmpdir", "/tmp");<br>
+<br>
+ tmp = getenv("JAVA_COMPILER");<br>
+ if (!tmp) tmp = "gcj";<br>
+ setProperty(vm, prop, "java.compiler", tmp);<br>
+<br>
+ setProperty(vm, prop, "build.compiler", "gcj");<br>
+ setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv);<br>
+ setProperty(vm, prop, "gnu.classpath.boot.library.path",<br>
+ JCL->libClasspathEnv);<br>
+<br>
+ setUnameProp(vm, prop);<br>
+<br>
+ setProperty(vm, prop, "file.separator", vm->dirSeparator);<br>
+ setProperty(vm, prop, "path.separator", vm->envSeparator);<br>
+ setProperty(vm, prop, "line.separator", "\n");<br>
+<br>
+ tmp = getenv("USERNAME");<br>
+ if (!tmp) tmp = getenv("LOGNAME");<br>
+ if (!tmp) tmp = getenv("NAME");<br>
+ if (!tmp) tmp = "";<br>
+ setProperty(vm, prop, "<a href="http://user.name" target="_blank">user.name</a>", tmp);<br>
+<br>
+ tmp = getenv("HOME");<br>
+ if (!tmp) tmp = "";<br>
+ setProperty(vm, prop, "user.home", tmp);<br>
+<br>
+ tmp = getenv("PWD");<br>
+ if (!tmp) tmp = "";<br>
+ setProperty(vm, prop, "user.dir", tmp);<br>
+<br>
+ // Disable this property. The Classpath iconv implementation is really<br>
+ // not optimized (it over-abuses JNI calls).<br>
+ //setProperty(vm, prop, "gnu.classpath.nio.charset.provider.iconv", "true");<br>
+ setProperty(vm, prop, "file.encoding", "ISO8859_1");<br>
+ setProperty(vm, prop, "gnu.java.util.zoneinfo.dir", "/usr/share/zoneinfo");<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+extern "C" void<br>
Java_gnu_classpath_VMSystemProperties_postInit__Ljava_util_Properties_2(JavaObject*<br>
prop) {<br>
+<br>
+ llvm_gcroot(prop, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ for (std::vector<std::pair<char*, char*> >::iterator i =<br>
+ vm->postProperties.begin(), e = vm->postProperties.end(); i!= e; i++) {<br>
+ setProperty(vm, prop, i->first, i->second);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc<br>
new file mode 100644<br>
index 0000000..da283d0<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThread.inc<br>
@@ -0,0 +1,217 @@<br>
+//===- ClasspathVMThread.cpp - GNU classpath java/lang/VMThread<br>
-----------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+// Never throws.<br>
+// Never calls Java code.<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThread_currentThread(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz<br>
+#endif<br>
+) {<br>
+ return JavaThread::get()->currentThread();<br>
+}<br>
+<br>
+void start(JavaThread* thread) {<br>
+<br>
+ JavaObjectVMThread* vmThread = NULL;<br>
+ JavaObject* javaThread = NULL;<br>
+ llvm_gcroot(vmThread, 0);<br>
+ llvm_gcroot(javaThread, 0);<br>
+<br>
+ Jnjvm* vm = thread->getJVM();<br>
+ // Wait some time to let the creator initialise these fields.<br>
+ while ((thread->javaThread == NULL) || (thread->vmThread == NULL)) {<br>
+ mvm::Thread::yield();<br>
+ }<br>
+<br>
+ // Ok, now that the thread is created we can set the the value of vmdata,<br>
+ // which is the JavaThread object.<br>
+ vmThread = (JavaObjectVMThread*)thread->vmThread;<br>
+ assert(vmThread && "Didn't fix the vmThread of a j3 thread");<br>
+ assert(vmThread->getVirtualTable());<br>
+ JavaObjectVMThread::setVmdata(vmThread, thread);<br>
+<br>
+ UserClass* vmthClass = (UserClass*)JavaObject::getClass(vmThread);<br>
+<br>
+ javaThread = thread->javaThread;<br>
+ assert(javaThread && "Didn't fix the javaThread of a j3 thread");<br>
+ // If the thread is not a daemon, it is added to the list of threads to<br>
+ // wait until exit.<br>
+ bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);<br>
+<br>
+ if (!isDaemon) {<br>
+ vm->threadSystem.enter();<br>
+ }<br>
+<br>
+ assert(vmThread->getVirtualTable());<br>
+ assert(javaThread->getVirtualTable());<br>
+ // Run the VMThread::run function<br>
+ vm->upcalls->runVMThread->invokeIntSpecial(vm, vmthClass, vmThread);<br>
+<br>
+ // Remove the thread from the list.<br>
+ if (!isDaemon) {<br>
+ vm->threadSystem.leave();<br>
+ }<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMThread_start(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* vmThread, sint64 stackSize) {<br>
+<br>
+ JavaObject* javaThread = 0;<br>
+ llvm_gcroot(vmThread, 0);<br>
+ llvm_gcroot(javaThread, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+<br>
+ // Classpath has set this field.<br>
+ javaThread = vm->upcalls->assocThread->getInstanceObjectField(vmThread);<br>
+ assert(javaThread && "VMThread with no Java equivalent");<br>
+<br>
+ JavaThread* th = new JavaThread(vm);<br>
+ if (!th) vm->outOfMemoryError();<br>
+ th->start((void (*)(mvm::Thread*))start);<br>
+ // Now that the thread has been created, initialise its object fields.<br>
+ th->initialise(javaThread, vmThread);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* vmthread) {<br>
+<br>
+ llvm_gcroot(vmthread, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JavaField* field = vm->upcalls->vmdataVMThread;<br>
+<br>
+ // It's possible that the thread to be interrupted has not finished<br>
+ // its initialization. Wait until the initialization is done.<br>
+ while (field->getInstanceObjectField(vmthread) == 0)<br>
+ mvm::Thread::yield();<br>
+<br>
+ JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);<br>
+ th->lockingThread.interruptFlag = 1;<br>
+ mvm::FatLock* lock = th->lockingThread.waitsOn;<br>
+<br>
+ // If the thread is blocked on a wait. We also verify nextWaiting in case<br>
+ // the thread has been notified.<br>
+ if (lock && th->lockingThread.nextWaiting) {<br>
+ th->lockingThread.state = mvm::LockingThread::StateInterrupted;<br>
+<br>
+ // Make sure the thread is waiting.<br>
+ uint32 locked = 0;<br>
+ while (true) {<br>
+ locked = (lock->tryAcquire() == 0);<br>
+ if (locked || (lock->getOwner() != th && lock->getOwner() != 0))<br>
+ break;<br>
+ else mvm::Thread::yield();<br>
+ }<br>
+<br>
+ // Interrupt the thread.<br>
+ th->lockingThread.varcond.signal();<br>
+<br>
+ // Release the lock if we acquired it.<br>
+ if (locked) lock->release(lock->getAssociatedObject(), vm->lockSystem);<br>
+ }<br>
+<br>
+ // Here we could also raise a signal for interrupting I/O<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+// Never throws.<br>
+// Never calls Java code.<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ JavaThread* th = JavaThread::get();<br>
+ uint32 interrupt = th->lockingThread.interruptFlag;<br>
+ th->lockingThread.interruptFlag = 0;<br>
+ return (jboolean)interrupt;<br>
+}<br>
+<br>
+// Never throws.<br>
+// Never calls Java code.<br>
+JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* vmthread) {<br>
+<br>
+ llvm_gcroot(vmthread, 0);<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JavaField* field = vm->upcalls->vmdataVMThread;<br>
+ JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);<br>
+ return (jboolean)th->lockingThread.interruptFlag;<br>
+}<br>
+<br>
+// Never throws.<br>
+// Never calls Java code.<br>
+JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* vmthread, jint prio) {<br>
+ // Currently not implemented<br>
+ llvm_gcroot(vmthread, 0);<br>
+}<br>
+<br>
+// Never throws.<br>
+// Never calls Java code.<br>
+JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* vmthread, JavaObject* exc) {<br>
+ // Currently not implemented<br>
+ llvm_gcroot(vmthread, 0);<br>
+ llvm_gcroot(exc, 0);<br>
+}<br>
+<br>
+// Never throws.<br>
+// Never calls Java code.<br>
+JNIEXPORT void JNICALL Java_java_lang_VMThread_yield(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+) {<br>
+ mvm::Thread::yield();<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc<br>
b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc<br>
new file mode 100644<br>
index 0000000..ee5c1ca<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/ClasspathVMThrowable.inc<br>
@@ -0,0 +1,183 @@<br>
+//===- ClasspathVMClassLoader.cpp - GNU classpath<br>
java/lang/VMClassLoader -===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "types.h"<br>
+<br>
+#include "Classpath.h"<br>
+#include "JavaAccess.h"<br>
+#include "JavaArray.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaConstantPool.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaString.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+#include "Reader.h"<br>
+<br>
+using namespace j3;<br>
+<br>
+extern "C" {<br>
+<br>
+JavaObject* internalFillInStackTrace(JavaObject* throwable) {<br>
+<br>
+ JavaObject* vmThrowable = 0;<br>
+ ArrayPtr* result = 0;<br>
+ llvm_gcroot(throwable, 0);<br>
+ llvm_gcroot(vmThrowable, 0);<br>
+ llvm_gcroot(result, 0);<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ Jnjvm* vm = th->getJVM();<br>
+<br>
+ uint32 length = th->getFrameContextLength();<br>
+<br>
+ if (sizeof(void*) == 4) {<br>
+ ClassArray* cl = vm->upcalls->ArrayOfInt;<br>
+ result = (ArrayPtr*) cl->doNew(length, vm);<br>
+ } else {<br>
+ ClassArray* cl = vm->upcalls->ArrayOfLong;<br>
+ result = (ArrayPtr*) cl->doNew(length, vm);<br>
+ }<br>
+<br>
+ // Don't call th->getFrameContext because it is not GC-safe.<br>
+ mvm::StackWalker Walker(th);<br>
+ uint32_t i = 0;<br>
+<br>
+ while (intptr_t ip = *Walker) {<br>
+ ArrayPtr::setElement(result, ip, i);<br>
+ ++i;<br>
+ ++Walker;<br>
+ }<br>
+<br>
+ // Set the tempory data in the new VMThrowable object.<br>
+ vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);<br>
+ vm->upcalls->vmDataVMThrowable->setInstanceObjectField(vmThrowable, result);<br>
+ return vmThrowable;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_fillInStackTrace(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+jclass clazz,<br>
+#endif<br>
+JavaObject* throwable) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+ llvm_gcroot(throwable, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ res = internalFillInStackTrace(throwable);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+<br>
+JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {<br>
+<br>
+ JavaString* methodName = 0;<br>
+ JavaString* className = 0;<br>
+ JavaString* sourceName = 0;<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(methodName, 0);<br>
+ llvm_gcroot(className, 0);<br>
+ llvm_gcroot(sourceName, 0);<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JavaMethod* meth = (JavaMethod*)FI->Metadata;<br>
+ methodName = vm->internalUTF8ToStr(meth->name);<br>
+ Class* cl = meth->classDef;<br>
+ className = JavaString::internalToJava(cl->name, vm);<br>
+<br>
+ Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);<br>
+<br>
+ // We don't have the bytes if the class was vmjc'ed.<br>
+ if (sourceAtt && cl->getBytes()) {<br>
+ Reader reader(sourceAtt, cl->bytes);<br>
+ uint16 index = reader.readU2();<br>
+ sourceName = vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));<br>
+ }<br>
+<br>
+ bool native = isNative(meth->access);<br>
+ uint16 lineNumber = meth->lookupLineNumber(FI);<br>
+<br>
+ UserClass* newS = vm->upcalls->newStackTraceElement;<br>
+ res = newS->doNew(vm);<br>
+ vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,<br>
+ &sourceName,<br>
+ lineNumber,<br>
+ &className,<br>
+ &methodName, native);<br>
+ return res;<br>
+}<br>
+<br>
+JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_getStackTrace(<br>
+#ifdef NATIVE_JNI<br>
+JNIEnv *env,<br>
+#endif<br>
+JavaObject* vmthrow, JavaObject* throwable) {<br>
+<br>
+ ArrayObject* result = NULL;<br>
+ JavaObject* stack = NULL;<br>
+ llvm_gcroot(vmthrow, 0);<br>
+ llvm_gcroot(throwable, 0);<br>
+ llvm_gcroot(result, 0);<br>
+ llvm_gcroot(stack, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ JavaField* field = vm->upcalls->vmDataVMThrowable;<br>
+ stack = field->getInstanceObjectField(vmthrow);<br>
+<br>
+ // remove the VMThrowable.fillInStackTrace method and the last method<br>
+ // on the stack.<br>
+ sint32 index = 2;;<br>
+ while (index != JavaArray::getSize(stack)) {<br>
+ mvm::FrameInfo* FI =<br>
vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));<br>
+ if (FI->Metadata == NULL) ++index;<br>
+ else {<br>
+ JavaMethod* meth = (JavaMethod*)FI->Metadata;<br>
+ assert(meth && "Wrong stack trace");<br>
+ if (meth->classDef->isAssignableFrom(vm->upcalls->newThrowable)) {<br>
+ ++index;<br>
+ } else break;<br>
+ }<br>
+ }<br>
+<br>
+ sint32 size = 0;<br>
+ sint32 cur = index;<br>
+ while (cur < JavaArray::getSize(stack)) {<br>
+ mvm::FrameInfo* FI =<br>
vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));<br>
+ ++cur;<br>
+ if (FI->Metadata != NULL) ++size;<br>
+ }<br>
+<br>
+ result = (ArrayObject*)<br>
+ vm->upcalls->stackTraceArray->doNew(size, vm);<br>
+<br>
+ cur = 0;<br>
+ for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {<br>
+ mvm::FrameInfo* FI =<br>
vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));<br>
+ if (FI->Metadata != NULL) {<br>
+ ArrayObject::setElement(result, consStackElement(FI,<br>
ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);<br>
+ cur++;<br>
+ }<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return result;<br>
+}<br>
+<br>
+}<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp<br>
b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp<br>
new file mode 100644<br>
index 0000000..986664c<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.cpp<br>
@@ -0,0 +1,1076 @@<br>
+//===-------- JavaUpcalls.cpp - Upcalls to Java entities<br>
------------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#include "ClasspathReflect.h"<br>
+#include "JavaAccess.h"<br>
+#include "JavaClass.h"<br>
+#include "JavaObject.h"<br>
+#include "JavaString.h"<br>
+#include "JavaThread.h"<br>
+#include "JavaUpcalls.h"<br>
+#include "Jnjvm.h"<br>
+#include "ReferenceQueue.h"<br>
+<br>
+#define COMPILE_METHODS(cl) \<br>
+ for (CommonClass::method_iterator i = cl->virtualMethods.begin(), \<br>
+ e = cl->virtualMethods.end(); i!= e; ++i) { \<br>
+ i->second->compiledPtr(); \<br>
+ } \<br>
+ \<br>
+ for (CommonClass::method_iterator i = cl->staticMethods.begin(), \<br>
+ e = cl->staticMethods.end(); i!= e; ++i) { \<br>
+ i->second->compiledPtr(); \<br>
+ }<br>
+<br>
+<br>
+using namespace j3;<br>
+<br>
+Class* Classpath::newThread;<br>
+Class* Classpath::newVMThread;<br>
+JavaField* Classpath::assocThread;<br>
+JavaField* Classpath::vmdataVMThread;<br>
+JavaMethod* Classpath::finaliseCreateInitialThread;<br>
+JavaMethod* Classpath::initVMThread;<br>
+JavaMethod* Classpath::initThread;<br>
+JavaMethod* Classpath::groupAddThread;<br>
+JavaField* Classpath::threadName;<br>
+JavaField* Classpath::groupName;<br>
+JavaMethod* Classpath::initGroup;<br>
+JavaField* Classpath::priority;<br>
+JavaField* Classpath::daemon;<br>
+JavaField* Classpath::group;<br>
+JavaField* Classpath::running;<br>
+Class* Classpath::threadGroup;<br>
+JavaField* Classpath::rootGroup;<br>
+JavaField* Classpath::vmThread;<br>
+JavaMethod* Classpath::getUncaughtExceptionHandler;<br>
+JavaMethod* Classpath::uncaughtException;<br>
+Class* Classpath::inheritableThreadLocal;<br>
+<br>
+JavaMethod* Classpath::runVMThread;<br>
+JavaMethod* Classpath::setContextClassLoader;<br>
+JavaMethod* Classpath::getSystemClassLoader;<br>
+Class* Classpath::newString;<br>
+Class* Classpath::newClass;<br>
+Class* Classpath::newThrowable;<br>
+Class* Classpath::newException;<br>
+JavaMethod* Classpath::initClass;<br>
+JavaMethod* Classpath::initClassWithProtectionDomain;<br>
+JavaField* Classpath::vmdataClass;<br>
+JavaMethod* Classpath::setProperty;<br>
+JavaMethod* Classpath::initString;<br>
+JavaMethod* Classpath::getCallingClassLoader;<br>
+JavaMethod* Classpath::initConstructor;<br>
+Class* Classpath::newConstructor;<br>
+ClassArray* Classpath::constructorArrayClass;<br>
+ClassArray* Classpath::constructorArrayAnnotation;<br>
+JavaField* Classpath::constructorSlot;<br>
+JavaMethod* Classpath::initMethod;<br>
+JavaMethod* Classpath::initField;<br>
+Class* Classpath::newField;<br>
+Class* Classpath::newMethod;<br>
+ClassArray* Classpath::methodArrayClass;<br>
+ClassArray* Classpath::fieldArrayClass;<br>
+JavaField* Classpath::methodSlot;<br>
+JavaField* Classpath::fieldSlot;<br>
+ClassArray* Classpath::classArrayClass;<br>
+JavaMethod* Classpath::loadInClassLoader;<br>
+JavaMethod* Classpath::initVMThrowable;<br>
+JavaField* Classpath::vmDataVMThrowable;<br>
+Class* Classpath::newVMThrowable;<br>
+JavaField* Classpath::bufferAddress;<br>
+JavaField* Classpath::dataPointer32;<br>
+JavaField* Classpath::dataPointer64;<br>
+Class* Classpath::newPointer32;<br>
+Class* Classpath::newPointer64;<br>
+Class* Classpath::newDirectByteBuffer;<br>
+JavaField* Classpath::vmdataClassLoader;<br>
+JavaMethod* Classpath::InitDirectByteBuffer;<br>
+Class* Classpath::newClassLoader;<br>
+<br>
+<br>
+JavaField* Classpath::boolValue;<br>
+JavaField* Classpath::byteValue;<br>
+JavaField* Classpath::shortValue;<br>
+JavaField* Classpath::charValue;<br>
+JavaField* Classpath::intValue;<br>
+JavaField* Classpath::longValue;<br>
+JavaField* Classpath::floatValue;<br>
+JavaField* Classpath::doubleValue;<br>
+<br>
+Class* Classpath::newStackTraceElement;<br>
+ClassArray* Classpath::stackTraceArray;<br>
+JavaMethod* Classpath::initStackTraceElement;<br>
+<br>
+Class* Classpath::voidClass;<br>
+Class* Classpath::boolClass;<br>
+Class* Classpath::byteClass;<br>
+Class* Classpath::shortClass;<br>
+Class* Classpath::charClass;<br>
+Class* Classpath::intClass;<br>
+Class* Classpath::floatClass;<br>
+Class* Classpath::doubleClass;<br>
+Class* Classpath::longClass;<br>
+<br>
+Class* Classpath::vmStackWalker;<br>
+<br>
+Class* Classpath::InvocationTargetException;<br>
+Class* Classpath::ArrayStoreException;<br>
+Class* Classpath::ClassCastException;<br>
+Class* Classpath::IllegalMonitorStateException;<br>
+Class* Classpath::IllegalArgumentException;<br>
+Class* Classpath::InterruptedException;<br>
+Class* Classpath::IndexOutOfBoundsException;<br>
+Class* Classpath::ArrayIndexOutOfBoundsException;<br>
+Class* Classpath::NegativeArraySizeException;<br>
+Class* Classpath::NullPointerException;<br>
+Class* Classpath::SecurityException;<br>
+Class* Classpath::ClassFormatError;<br>
+Class* Classpath::ClassCircularityError;<br>
+Class* Classpath::NoClassDefFoundError;<br>
+Class* Classpath::UnsupportedClassVersionError;<br>
+Class* Classpath::NoSuchFieldError;<br>
+Class* Classpath::NoSuchMethodError;<br>
+Class* Classpath::InstantiationError;<br>
+Class* Classpath::InstantiationException;<br>
+Class* Classpath::IllegalAccessError;<br>
+Class* Classpath::IllegalAccessException;<br>
+Class* Classpath::VerifyError;<br>
+Class* Classpath::ExceptionInInitializerError;<br>
+Class* Classpath::LinkageError;<br>
+Class* Classpath::AbstractMethodError;<br>
+Class* Classpath::UnsatisfiedLinkError;<br>
+Class* Classpath::InternalError;<br>
+Class* Classpath::OutOfMemoryError;<br>
+Class* Classpath::StackOverflowError;<br>
+Class* Classpath::UnknownError;<br>
+Class* Classpath::ClassNotFoundException;<br>
+Class* Classpath::ArithmeticException;<br>
+<br>
+JavaMethod* Classpath::InitInvocationTargetException;<br>
+JavaMethod* Classpath::InitArrayStoreException;<br>
+JavaMethod* Classpath::InitClassCastException;<br>
+JavaMethod* Classpath::InitIllegalMonitorStateException;<br>
+JavaMethod* Classpath::InitIllegalArgumentException;<br>
+JavaMethod* Classpath::InitInterruptedException;<br>
+JavaMethod* Classpath::InitIndexOutOfBoundsException;<br>
+JavaMethod* Classpath::InitArrayIndexOutOfBoundsException;<br>
+JavaMethod* Classpath::InitNegativeArraySizeException;<br>
+JavaMethod* Classpath::InitNullPointerException;<br>
+JavaMethod* Classpath::InitSecurityException;<br>
+JavaMethod* Classpath::InitClassFormatError;<br>
+JavaMethod* Classpath::InitClassCircularityError;<br>
+JavaMethod* Classpath::InitNoClassDefFoundError;<br>
+JavaMethod* Classpath::InitUnsupportedClassVersionError;<br>
+JavaMethod* Classpath::InitNoSuchFieldError;<br>
+JavaMethod* Classpath::InitNoSuchMethodError;<br>
+JavaMethod* Classpath::InitInstantiationError;<br>
+JavaMethod* Classpath::InitInstantiationException;<br>
+JavaMethod* Classpath::InitIllegalAccessError;<br>
+JavaMethod* Classpath::InitIllegalAccessException;<br>
+JavaMethod* Classpath::InitVerifyError;<br>
+JavaMethod* Classpath::InitExceptionInInitializerError;<br>
+JavaMethod* Classpath::InitLinkageError;<br>
+JavaMethod* Classpath::InitAbstractMethodError;<br>
+JavaMethod* Classpath::InitUnsatisfiedLinkError;<br>
+JavaMethod* Classpath::InitInternalError;<br>
+JavaMethod* Classpath::InitOutOfMemoryError;<br>
+JavaMethod* Classpath::InitStackOverflowError;<br>
+JavaMethod* Classpath::InitUnknownError;<br>
+JavaMethod* Classpath::InitClassNotFoundException;<br>
+JavaMethod* Classpath::InitArithmeticException;<br>
+JavaMethod* Classpath::InitObject;<br>
+JavaMethod* Classpath::FinalizeObject;<br>
+JavaMethod* Classpath::IntToString;<br>
+<br>
+JavaMethod* Classpath::SystemArraycopy;<br>
+JavaMethod* Classpath::VMSystemArraycopy;<br>
+Class* Classpath::SystemClass;<br>
+Class* Classpath::EnumClass;<br>
+<br>
+JavaMethod* Classpath::ErrorWithExcpNoClassDefFoundError;<br>
+JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;<br>
+JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;<br>
+<br>
+ClassArray* Classpath::ArrayOfByte;<br>
+ClassArray* Classpath::ArrayOfChar;<br>
+ClassArray* Classpath::ArrayOfString;<br>
+ClassArray* Classpath::ArrayOfInt;<br>
+ClassArray* Classpath::ArrayOfShort;<br>
+ClassArray* Classpath::ArrayOfBool;<br>
+ClassArray* Classpath::ArrayOfLong;<br>
+ClassArray* Classpath::ArrayOfFloat;<br>
+ClassArray* Classpath::ArrayOfDouble;<br>
+ClassArray* Classpath::ArrayOfObject;<br>
+<br>
+ClassPrimitive* Classpath::OfByte;<br>
+ClassPrimitive* Classpath::OfChar;<br>
+ClassPrimitive* Classpath::OfInt;<br>
+ClassPrimitive* Classpath::OfShort;<br>
+ClassPrimitive* Classpath::OfBool;<br>
+ClassPrimitive* Classpath::OfLong;<br>
+ClassPrimitive* Classpath::OfFloat;<br>
+ClassPrimitive* Classpath::OfDouble;<br>
+ClassPrimitive* Classpath::OfVoid;<br>
+<br>
+Class* Classpath::OfObject;<br>
+<br>
+JavaField* Classpath::methodClass;<br>
+JavaField* Classpath::fieldClass;<br>
+JavaField* Classpath::constructorClass;<br>
+<br>
+JavaMethod* Classpath::EnqueueReference;<br>
+Class* Classpath::newReference;<br>
+<br>
+void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,<br>
+ const char* thName, JavaObject* Group) {<br>
+ JavaObjectVMThread* vmth = NULL;<br>
+ JavaObject* th = NULL;<br>
+ JavaObject* name = NULL;<br>
+ llvm_gcroot(Group, 0);<br>
+ llvm_gcroot(vmth, 0);<br>
+ llvm_gcroot(th, 0);<br>
+ llvm_gcroot(name, 0);<br>
+<br>
+ th = newThread->doNew(vm);<br>
+ myth->javaThread = th;<br>
+ vmth = (JavaObjectVMThread*)newVMThread->doNew(vm);<br>
+ name = vm->asciizToStr(thName);<br>
+<br>
+ initThread->invokeIntSpecial(vm, newThread, th, &vmth, &name, 1, 0);<br>
+ vmThread->setInstanceObjectField(th, vmth);<br>
+ assocThread->setInstanceObjectField(vmth, th);<br>
+ running->setInstanceInt8Field(vmth, (uint32)1);<br>
+ JavaObjectVMThread::setVmdata(vmth, myth);<br>
+<br>
+ group->setInstanceObjectField(th, Group);<br>
+ groupAddThread->invokeIntSpecial(vm, threadGroup, Group, &th);<br>
+<br>
+ finaliseCreateInitialThread->invokeIntStatic(vm,<br>
inheritableThreadLocal, &th);<br>
+}<br>
+<br>
+void Classpath::InitializeThreading(Jnjvm* vm) {<br>
+<br>
+ JavaObject* RG = 0;<br>
+ JavaObject* SystemGroup = 0;<br>
+ JavaObject* systemName = 0;<br>
+ llvm_gcroot(RG, 0);<br>
+ llvm_gcroot(SystemGroup, 0);<br>
+ llvm_gcroot(systemName, 0);<br>
+<br>
+ // Resolve and initialize classes first.<br>
+ newThread->resolveClass();<br>
+ newThread->initialiseClass(vm);<br>
+<br>
+ newVMThread->resolveClass();<br>
+ newVMThread->initialiseClass(vm);<br>
+<br>
+ threadGroup->resolveClass();<br>
+ threadGroup->initialiseClass(vm);<br>
+<br>
+ // Create the main thread<br>
+ RG = rootGroup->getStaticObjectField();<br>
+ assert(RG && "No root group");<br>
+ assert(vm->getMainThread() && "VM did not set its main thread");<br>
+ CreateJavaThread(vm, (JavaThread*)vm->getMainThread(), "main", RG);<br>
+<br>
+ // Create the "system" group.<br>
+ SystemGroup = threadGroup->doNew(vm);<br>
+ initGroup->invokeIntSpecial(vm, threadGroup, SystemGroup);<br>
+ systemName = vm->asciizToStr("system");<br>
+ groupName->setInstanceObjectField(SystemGroup, systemName);<br>
+<br>
+ // Create the finalizer thread.<br>
+ assert(vm->getFinalizerThread() && "VM did not set its finalizer thread");<br>
+ CreateJavaThread(vm, vm->getFinalizerThread(), "Finalizer", SystemGroup);<br>
+<br>
+ // Create the enqueue thread.<br>
+ assert(vm->getReferenceThread() && "VM did not set its enqueue thread");<br>
+ CreateJavaThread(vm, vm->getReferenceThread(), "Reference", SystemGroup);<br>
+}<br>
+<br>
+extern "C" void<br>
Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2(<br>
+ JavaObjectReference* reference, JavaObject* referent) {<br>
+ llvm_gcroot(reference, 0);<br>
+ llvm_gcroot(referent, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObjectReference::init(reference, referent, 0);<br>
+ JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+}<br>
+<br>
+extern "C" void<br>
Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(<br>
+ JavaObjectReference* reference,<br>
+ JavaObject* referent,<br>
+ JavaObject* queue) {<br>
+ llvm_gcroot(reference, 0);<br>
+ llvm_gcroot(referent, 0);<br>
+ llvm_gcroot(queue, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObjectReference::init(reference, referent, queue);<br>
+ JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+}<br>
+<br>
+extern "C" void<br>
Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2(<br>
+ JavaObjectReference* reference, JavaObject* referent) {<br>
+ llvm_gcroot(reference, 0);<br>
+ llvm_gcroot(referent, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObjectReference::init(reference, referent, 0);<br>
+ JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+}<br>
+<br>
+extern "C" void<br>
Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(<br>
+ JavaObjectReference* reference,<br>
+ JavaObject* referent,<br>
+ JavaObject* queue) {<br>
+ llvm_gcroot(reference, 0);<br>
+ llvm_gcroot(referent, 0);<br>
+ llvm_gcroot(queue, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObjectReference::init(reference, referent, queue);<br>
+ JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+}<br>
+<br>
+extern "C" void<br>
Java_java_lang_ref_PhantomReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(<br>
+ JavaObjectReference* reference,<br>
+ JavaObject* referent,<br>
+ JavaObject* queue) {<br>
+ llvm_gcroot(reference, 0);<br>
+ llvm_gcroot(referent, 0);<br>
+ llvm_gcroot(queue, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaObjectReference::init(reference, referent, queue);<br>
+ JavaThread::get()->getJVM()->getReferenceThread()->addPhantomReference(reference);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+}<br>
+<br>
+extern "C" JavaString* Java_java_lang_VMString_intern__Ljava_lang_String_2(<br>
+ JavaString* obj) {<br>
+ const ArrayUInt16* array = 0;<br>
+ JavaString* res = 0;<br>
+ llvm_gcroot(obj, 0);<br>
+ llvm_gcroot(array, 0);<br>
+ llvm_gcroot(res, 0);<br>
+ // If the string is already interned, just return.<br>
+ if (obj->getVirtualTable() == JavaString::internStringVT) return obj;<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ array = JavaString::strToArray(obj, vm);<br>
+ res = vm->constructString(array);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+extern "C" uint8 Java_java_lang_Class_isArray__(JavaObjectClass* klass) {<br>
+ llvm_gcroot(klass, 0);<br>
+ UserCommonClass* cl = 0;<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ cl = JavaObjectClass::getClass(klass);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return (uint8)cl->isArray();<br>
+}<br>
+<br>
+extern "C" JavaObject* Java_gnu_classpath_VMStackWalker_getCallingClass__() {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ UserClass* cl = th->getCallingClassLevel(2);<br>
+ if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+extern "C" JavaObject*<br>
Java_gnu_classpath_VMStackWalker_getCallingClassLoader__() {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ UserClass* cl = th->getCallingClassLevel(2);<br>
+ res = cl->classLoader->getJavaClassLoader();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+extern "C" JavaObject*<br>
Java_gnu_classpath_VMStackWalker_firstNonNullClassLoader__() {<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ res = th->getNonNullClassLoader();<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+extern "C" JavaObject*<br>
Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {<br>
+<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ JavaThread* th = JavaThread::get();<br>
+ Jnjvm* vm = th->getJVM();<br>
+ UserClass* cl = th->getCallingClassLevel(index);<br>
+ if (cl) res = cl->getClassDelegatee(vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+extern "C" JavaObject*<br>
Java_java_lang_reflect_AccessibleObject_getAnnotation__Ljava_lang_Class_2(<br>
+ JavaObject* obj) {<br>
+ llvm_gcroot(obj, 0);<br>
+ return 0;<br>
+}<br>
+<br>
+extern "C" JavaObject*<br>
Java_java_lang_reflect_AccessibleObject_getDeclaredAnnotations__() {<br>
+ JavaObject* res = 0;<br>
+ llvm_gcroot(res, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ UserClassArray* array = vm->upcalls->constructorArrayAnnotation;<br>
+ res = array->doNew(0, vm);<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return res;<br>
+}<br>
+<br>
+extern "C" void nativeJavaObjectClassTracer(<br>
+ JavaObjectClass* obj, word_t closure) {<br>
+ JavaObjectClass::staticTracer(obj, closure);<br>
+}<br>
+<br>
+extern "C" void nativeJavaObjectFieldTracer(<br>
+ JavaObjectField* obj, word_t closure) {<br>
+ JavaObjectField::staticTracer(obj, closure);<br>
+}<br>
+<br>
+extern "C" void nativeJavaObjectMethodTracer(<br>
+ JavaObjectMethod* obj, word_t closure) {<br>
+ JavaObjectMethod::staticTracer(obj, closure);<br>
+}<br>
+<br>
+extern "C" void nativeJavaObjectConstructorTracer(<br>
+ JavaObjectConstructor* obj, word_t closure) {<br>
+ JavaObjectConstructor::staticTracer(obj, closure);<br>
+}<br>
+<br>
+extern "C" void nativeJavaObjectVMThreadTracer(<br>
+ JavaObjectVMThread* obj, word_t closure) {<br>
+ JavaObjectVMThread::staticTracer(obj, closure);<br>
+}<br>
+<br>
+extern "C" JavaString*<br>
Java_java_lang_VMSystem_getenv__Ljava_lang_String_2(JavaString* str) {<br>
+ JavaString* ret = 0;<br>
+ llvm_gcroot(str, 0);<br>
+ llvm_gcroot(ret, 0);<br>
+<br>
+ BEGIN_NATIVE_EXCEPTION(0)<br>
+<br>
+ mvm::ThreadAllocator allocator;<br>
+ char* buf = JavaString::strToAsciiz(str, &allocator);<br>
+ char* res = getenv(buf);<br>
+ if (res) {<br>
+ Jnjvm* vm = JavaThread::get()->getJVM();<br>
+ ret = vm->asciizToStr(res);<br>
+ }<br>
+<br>
+ END_NATIVE_EXCEPTION<br>
+<br>
+ return ret;<br>
+}<br>
+<br>
+void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {<br>
+<br>
+ newClassLoader =<br>
+ UPCALL_CLASS(loader, "java/lang/ClassLoader");<br>
+<br>
+ getSystemClassLoader =<br>
+ UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader",<br>
+ "()Ljava/lang/ClassLoader;", ACC_STATIC);<br>
+<br>
+ setContextClassLoader =<br>
+ UPCALL_METHOD(loader, "java/lang/Thread", "setContextClassLoader",<br>
+ "(Ljava/lang/ClassLoader;)V", ACC_VIRTUAL);<br>
+<br>
+ newString =<br>
+ UPCALL_CLASS(loader, "java/lang/String");<br>
+<br>
+ newClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Class");<br>
+<br>
+ newThrowable =<br>
+ UPCALL_CLASS(loader, "java/lang/Throwable");<br>
+<br>
+ newException =<br>
+ UPCALL_CLASS(loader, "java/lang/Exception");<br>
+<br>
+ newPointer32 =<br>
+ UPCALL_CLASS(loader, "gnu/classpath/Pointer32");<br>
+<br>
+ newPointer64 =<br>
+ UPCALL_CLASS(loader, "gnu/classpath/Pointer64");<br>
+<br>
+ newDirectByteBuffer =<br>
+ UPCALL_CLASS(loader, "java/nio/DirectByteBufferImpl$ReadWrite");<br>
+<br>
+ InitDirectByteBuffer =<br>
+ UPCALL_METHOD(loader, "java/nio/DirectByteBufferImpl$ReadWrite", "<init>",<br>
+ "(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ initClass =<br>
+ UPCALL_METHOD(loader, "java/lang/Class", "<init>", "(Ljava/lang/Object;)V",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ initClassWithProtectionDomain =<br>
+ UPCALL_METHOD(loader, "java/lang/Class", "<init>",<br>
+ "(Ljava/lang/Object;Ljava/security/ProtectionDomain;)V",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ vmdataClass =<br>
+ UPCALL_FIELD(loader, "java/lang/Class", "vmdata", "Ljava/lang/Object;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ setProperty =<br>
+ UPCALL_METHOD(loader, "java/util/Properties", "setProperty",<br>
+ "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ initString =<br>
+ UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V",<br>
ACC_VIRTUAL);<br>
+<br>
+ initConstructor =<br>
+ UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",<br>
+ "(Ljava/lang/Class;I)V", ACC_VIRTUAL);<br>
+<br>
+ newConstructor =<br>
+ UPCALL_CLASS(loader, "java/lang/reflect/Constructor");<br>
+<br>
+ constructorArrayClass =<br>
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);<br>
+<br>
+ constructorArrayAnnotation =<br>
+ UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);<br>
+<br>
+ constructorSlot =<br>
+ UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot",<br>
"I", ACC_VIRTUAL);<br>
+<br>
+ initMethod =<br>
+ UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",<br>
+ "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);<br>
+<br>
+ newMethod =<br>
+ UPCALL_CLASS(loader, "java/lang/reflect/Method");<br>
+<br>
+ methodArrayClass =<br>
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);<br>
+<br>
+ methodSlot =<br>
+ UPCALL_FIELD(loader, "java/lang/reflect/Method", "slot", "I", ACC_VIRTUAL);<br>
+<br>
+ initField =<br>
+ UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",<br>
+ "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);<br>
+<br>
+ newField =<br>
+ UPCALL_CLASS(loader, "java/lang/reflect/Field");<br>
+<br>
+ fieldArrayClass =<br>
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);<br>
+<br>
+ fieldSlot =<br>
+ UPCALL_FIELD(loader, "java/lang/reflect/Field", "slot", "I", ACC_VIRTUAL);<br>
+<br>
+<br>
+ classArrayClass =<br>
+ UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);<br>
+<br>
+ newVMThrowable =<br>
+ UPCALL_CLASS(loader, "java/lang/VMThrowable");<br>
+<br>
+ initVMThrowable =<br>
+ UPCALL_METHOD(loader, "java/lang/VMThrowable", "<init>", "()V",<br>
ACC_VIRTUAL);<br>
+<br>
+ vmDataVMThrowable =<br>
+ UPCALL_FIELD(loader, "java/lang/VMThrowable", "vmdata",<br>
"Ljava/lang/Object;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ bufferAddress =<br>
+ UPCALL_FIELD(loader, "java/nio/Buffer", "address",<br>
"Lgnu/classpath/Pointer;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ dataPointer32 =<br>
+ UPCALL_FIELD(loader, "gnu/classpath/Pointer32", "data", "I", ACC_VIRTUAL);<br>
+<br>
+ dataPointer64 =<br>
+ UPCALL_FIELD(loader, "gnu/classpath/Pointer64", "data", "J", ACC_VIRTUAL);<br>
+<br>
+ vmdataClassLoader =<br>
+ UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",<br>
"Ljava/lang/Object;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ newStackTraceElement =<br>
+ UPCALL_CLASS(loader, "java/lang/StackTraceElement");<br>
+<br>
+ stackTraceArray =<br>
+ UPCALL_ARRAY_CLASS(loader, "java/lang/StackTraceElement", 1);<br>
+<br>
+ initStackTraceElement =<br>
+ UPCALL_METHOD(loader, "java/lang/StackTraceElement", "<init>",<br>
+<br>
"(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Z)V",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ boolValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);<br>
+<br>
+ byteValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Byte", "value", "B", ACC_VIRTUAL);<br>
+<br>
+ shortValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Short", "value", "S", ACC_VIRTUAL);<br>
+<br>
+ charValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Character", "value", "C", ACC_VIRTUAL);<br>
+<br>
+ intValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Integer", "value", "I", ACC_VIRTUAL);<br>
+<br>
+ longValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Long", "value", "J", ACC_VIRTUAL);<br>
+<br>
+ floatValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Float", "value", "F", ACC_VIRTUAL);<br>
+<br>
+ doubleValue =<br>
+ UPCALL_FIELD(loader, "java/lang/Double", "value", "D", ACC_VIRTUAL);<br>
+<br>
+ Classpath::voidClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Void");<br>
+<br>
+ Classpath::boolClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Boolean");<br>
+<br>
+ Classpath::byteClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Byte");<br>
+<br>
+ Classpath::shortClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Short");<br>
+<br>
+ Classpath::charClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Character");<br>
+<br>
+ Classpath::intClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Integer");<br>
+<br>
+ Classpath::floatClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Float");<br>
+<br>
+ Classpath::doubleClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Double");<br>
+<br>
+ Classpath::longClass =<br>
+ UPCALL_CLASS(loader, "java/lang/Long");<br>
+<br>
+ Classpath::OfObject =<br>
+ UPCALL_CLASS(loader, "java/lang/Object");<br>
+<br>
+ vmStackWalker =<br>
+ UPCALL_CLASS(loader, "gnu/classpath/VMStackWalker");<br>
+<br>
+ loadInClassLoader =<br>
+ UPCALL_METHOD(loader, "java/lang/ClassLoader", "loadClass",<br>
+ "(Ljava/lang/String;)Ljava/lang/Class;", ACC_VIRTUAL);<br>
+<br>
+ JavaMethod* internString =<br>
+ UPCALL_METHOD(loader, "java/lang/VMString", "intern",<br>
+ "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);<br>
+ internString->setNative();<br>
+<br>
+ JavaMethod* isArray =<br>
+ UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL);<br>
+ isArray->setNative();<br>
+<br>
+ // Make sure classes the JIT optimizes on are loaded.<br>
+ UPCALL_CLASS(loader, "java/lang/VMFloat");<br>
+ UPCALL_CLASS(loader, "java/lang/VMDouble");<br>
+<br>
+ UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ArrayStoreException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ClassCastException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, IllegalMonitorStateException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, IllegalArgumentException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, InterruptedException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, IndexOutOfBoundsException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ArrayIndexOutOfBoundsException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, NegativeArraySizeException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, NullPointerException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, SecurityException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ClassFormatError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ClassCircularityError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, NoClassDefFoundError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, UnsupportedClassVersionError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, NoSuchFieldError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, NoSuchMethodError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, InstantiationError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, InstantiationException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, IllegalAccessError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, IllegalAccessException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, VerifyError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ExceptionInInitializerError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, LinkageError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, AbstractMethodError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, UnsatisfiedLinkError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, InternalError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, OutOfMemoryError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, StackOverflowError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, UnknownError);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);<br>
+ UPCALL_CLASS_EXCEPTION(loader, ArithmeticException);<br>
+<br>
+ UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ClassCastException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, IllegalMonitorStateException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, IllegalArgumentException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, InterruptedException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, IndexOutOfBoundsException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ArrayIndexOutOfBoundsException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, NegativeArraySizeException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, NullPointerException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, SecurityException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ClassFormatError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ClassCircularityError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, NoClassDefFoundError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, UnsupportedClassVersionError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, NoSuchFieldError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, NoSuchMethodError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, InstantiationError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, InstantiationException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, IllegalAccessError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, IllegalAccessException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, VerifyError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ExceptionInInitializerError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, LinkageError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, AbstractMethodError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, UnsatisfiedLinkError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, InternalError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, OutOfMemoryError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, StackOverflowError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, UnknownError);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);<br>
+ UPCALL_METHOD_EXCEPTION(loader, ArithmeticException);<br>
+<br>
+ UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);<br>
+ UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);<br>
+ UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);<br>
+<br>
+ InitObject = UPCALL_METHOD(loader, "java/lang/Object", "<init>", "()V",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ FinalizeObject = UPCALL_METHOD(loader, "java/lang/Object", "finalize", "()V",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ IntToString = UPCALL_METHOD(loader, "java/lang/Integer", "toString",<br>
+ "(II)Ljava/lang/String;", ACC_STATIC);<br>
+<br>
+ SystemArraycopy = UPCALL_METHOD(loader, "java/lang/System", "arraycopy",<br>
+ "(Ljava/lang/Object;ILjava/lang/Object;II)V",<br>
+ ACC_STATIC);<br>
+<br>
+ VMSystemArraycopy = UPCALL_METHOD(loader, "java/lang/VMSystem", "arraycopy",<br>
+ "(Ljava/lang/Object;ILjava/lang/Object;II)V",<br>
+ ACC_STATIC);<br>
+<br>
+ SystemClass = UPCALL_CLASS(loader, "java/lang/System");<br>
+ EnumClass = UPCALL_CLASS(loader, "java/lang/Enum");<br>
+<br>
+ newThread =<br>
+ UPCALL_CLASS(loader, "java/lang/Thread");<br>
+<br>
+ newVMThread =<br>
+ UPCALL_CLASS(loader, "java/lang/VMThread");<br>
+<br>
+ assocThread =<br>
+ UPCALL_FIELD(loader, "java/lang/VMThread", "thread", "Ljava/lang/Thread;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ vmdataVMThread =<br>
+ UPCALL_FIELD(loader, "java/lang/VMThread", "vmdata", "Ljava/lang/Object;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ inheritableThreadLocal =<br>
+ UPCALL_CLASS(loader, "java/lang/InheritableThreadLocal");<br>
+<br>
+ finaliseCreateInitialThread =<br>
+ UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal", "newChildThread",<br>
+ "(Ljava/lang/Thread;)V", ACC_STATIC);<br>
+<br>
+ initThread =<br>
+ UPCALL_METHOD(loader, "java/lang/Thread", "<init>",<br>
+ "(Ljava/lang/VMThread;Ljava/lang/String;IZ)V", ACC_VIRTUAL);<br>
+<br>
+ initVMThread =<br>
+ UPCALL_METHOD(loader, "java/lang/VMThread", "<init>",<br>
+ "(Ljava/lang/Thread;)V", ACC_VIRTUAL);<br>
+<br>
+ runVMThread =<br>
+ UPCALL_METHOD(loader, "java/lang/VMThread", "run", "()V", ACC_VIRTUAL);<br>
+<br>
+<br>
+ groupAddThread =<br>
+ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread",<br>
+ "(Ljava/lang/Thread;)V", ACC_VIRTUAL);<br>
+<br>
+ initGroup =<br>
+ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "<init>",<br>
+ "()V", ACC_VIRTUAL);<br>
+<br>
+ groupName =<br>
+ UPCALL_FIELD(loader, "java/lang/ThreadGroup", "name", "Ljava/lang/String;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ threadName =<br>
+ UPCALL_FIELD(loader, "java/lang/Thread", "name", "Ljava/lang/String;",<br>
+ ACC_VIRTUAL);<br>
+<br>
+<br>
+ priority =<br>
+ UPCALL_FIELD(loader, "java/lang/Thread", "priority", "I", ACC_VIRTUAL);<br>
+<br>
+ daemon =<br>
+ UPCALL_FIELD(loader, "java/lang/Thread", "daemon", "Z", ACC_VIRTUAL);<br>
+<br>
+ group =<br>
+ UPCALL_FIELD(loader, "java/lang/Thread", "group",<br>
+ "Ljava/lang/ThreadGroup;", ACC_VIRTUAL);<br>
+<br>
+ running =<br>
+ UPCALL_FIELD(loader, "java/lang/VMThread", "running", "Z", ACC_VIRTUAL);<br>
+<br>
+ threadGroup =<br>
+ UPCALL_CLASS(loader, "java/lang/ThreadGroup");<br>
+<br>
+ rootGroup =<br>
+ UPCALL_FIELD(loader, "java/lang/ThreadGroup", "root",<br>
+ "Ljava/lang/ThreadGroup;", ACC_STATIC);<br>
+<br>
+ vmThread =<br>
+ UPCALL_FIELD(loader, "java/lang/Thread", "vmThread",<br>
+ "Ljava/lang/VMThread;", ACC_VIRTUAL);<br>
+<br>
+ getUncaughtExceptionHandler =<br>
+ UPCALL_METHOD(loader, "java/lang/Thread", "getUncaughtExceptionHandler",<br>
+ "()Ljava/lang/Thread$UncaughtExceptionHandler;",<br>
ACC_VIRTUAL);<br>
+<br>
+ uncaughtException =<br>
+ UPCALL_METHOD(loader, "java/lang/Thread$UncaughtExceptionHandler",<br>
+ "uncaughtException",<br>
+ "(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL);<br>
+<br>
+<br>
+ methodClass =<br>
+ UPCALL_FIELD(loader, "java/lang/reflect/Method", "declaringClass",<br>
+ "Ljava/lang/Class;", ACC_VIRTUAL);<br>
+<br>
+ fieldClass =<br>
+ UPCALL_FIELD(loader, "java/lang/reflect/Field", "declaringClass",<br>
+ "Ljava/lang/Class;", ACC_VIRTUAL);<br>
+<br>
+ constructorClass =<br>
+ UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "clazz",<br>
+ "Ljava/lang/Class;", ACC_VIRTUAL);<br>
+<br>
+ loader->loadName(loader->asciizConstructUTF8("java/lang/String"),<br>
+ true, false, NULL);<br>
+<br>
+ loader->loadName(loader->asciizConstructUTF8("java/lang/Object"),<br>
+ true, false, NULL);<br>
+<br>
+ // Don't compile methods here, we still don't know where to allocate Java<br>
+ // strings.<br>
+<br>
+ JavaMethod* getEnv =<br>
+ UPCALL_METHOD(loader, "java/lang/VMSystem", "getenv",<br>
+ "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);<br>
+ getEnv->setNative();<br>
+<br>
+ JavaMethod* getCallingClass =<br>
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass",<br>
+ "()Ljava/lang/Class;", ACC_STATIC);<br>
+ getCallingClass->setNative();<br>
+<br>
+ JavaMethod* getCallingClassLoader =<br>
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",<br>
"getCallingClassLoader",<br>
+ "()Ljava/lang/ClassLoader;", ACC_STATIC);<br>
+ getCallingClassLoader->setNative();<br>
+<br>
+ JavaMethod* firstNonNullClassLoader =<br>
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",<br>
"firstNonNullClassLoader",<br>
+ "()Ljava/lang/ClassLoader;", ACC_STATIC);<br>
+ firstNonNullClassLoader->setNative();<br>
+<br>
+ JavaMethod* getCallerClass =<br>
+ UPCALL_METHOD(loader, "sun/reflect/Reflection", "getCallerClass",<br>
+ "(I)Ljava/lang/Class;", ACC_STATIC);<br>
+ getCallerClass->setNative();<br>
+<br>
+ JavaMethod* postProperties =<br>
+ UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit",<br>
+ "(Ljava/util/Properties;)V", ACC_STATIC);<br>
+ postProperties->setNative();<br>
+<br>
+ // Also implement these twos, implementation in GNU Classpath<br>
0.97.2 is buggy.<br>
+ JavaMethod* getAnnotation =<br>
+ UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",<br>
"getAnnotation",<br>
+ "(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;",<br>
+ ACC_VIRTUAL);<br>
+ getAnnotation->setNative();<br>
+<br>
+ JavaMethod* getAnnotations =<br>
+ UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",<br>
+ "getDeclaredAnnotations",<br>
+ "()[Ljava/lang/annotation/Annotation;",<br>
+ ACC_VIRTUAL);<br>
+ getAnnotations->setNative();<br>
+<br>
+ JavaMethod* getBootPackages =<br>
+ UPCALL_METHOD(loader, "java/lang/VMClassLoader", "getBootPackages",<br>
+ "()[Ljava/lang/String;", ACC_STATIC);<br>
+ getBootPackages->setNative();<br>
+<br>
+ //===----------------------------------------------------------------------===//<br>
+ //<br>
+ // To make classes non GC-allocated, we have to bypass the tracer<br>
functions of<br>
+ // java.lang.Class, java.lang.reflect.Field, java.lang.reflect.Method and<br>
+ // java.lang.reflect.constructor. The new tracer functions trace<br>
the classloader<br>
+ // instead of the class/field/method.<br>
+ //<br>
+ //===----------------------------------------------------------------------===//<br>
+<br>
+ newClass->getVirtualVT()->setNativeTracer(<br>
+ (word_t)nativeJavaObjectClassTracer,<br>
+ "nativeJavaObjectClassTracer");<br>
+<br>
+ newConstructor->getVirtualVT()->setNativeTracer(<br>
+ (word_t)nativeJavaObjectConstructorTracer,<br>
+ "nativeJavaObjectConstructorTracer");<br>
+<br>
+ newMethod->getVirtualVT()->setNativeTracer(<br>
+ (word_t)nativeJavaObjectMethodTracer,<br>
+ "nativeJavaObjectMethodTracer");<br>
+<br>
+ newField->getVirtualVT()->setNativeTracer(<br>
+ (word_t)nativeJavaObjectFieldTracer,<br>
+ "nativeJavaObjectFieldTracer");<br>
+<br>
+ newVMThread->getVirtualVT()->setNativeTracer(<br>
+ (word_t)nativeJavaObjectVMThreadTracer,<br>
+ "nativeJavaObjectVMThreadTracer");<br>
+<br>
+ newReference = UPCALL_CLASS(loader, "java/lang/ref/Reference");<br>
+<br>
+ EnqueueReference =<br>
+ UPCALL_METHOD(loader, "java/lang/ref/Reference", "enqueue", "()Z",<br>
+ ACC_VIRTUAL);<br>
+<br>
+ JavaMethod* initWeakReference =<br>
+ UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",<br>
+ "(Ljava/lang/Object;)V",<br>
+ ACC_VIRTUAL);<br>
+ initWeakReference->setNative();<br>
+<br>
+ initWeakReference =<br>
+ UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",<br>
+ "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",<br>
+ ACC_VIRTUAL);<br>
+ initWeakReference->setNative();<br>
+<br>
+ JavaMethod* initSoftReference =<br>
+ UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",<br>
+ "(Ljava/lang/Object;)V",<br>
+ ACC_VIRTUAL);<br>
+ initSoftReference->setNative();<br>
+<br>
+ initSoftReference =<br>
+ UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",<br>
+ "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",<br>
+ ACC_VIRTUAL);<br>
+ initSoftReference->setNative();<br>
+<br>
+ JavaMethod* initPhantomReference =<br>
+ UPCALL_METHOD(loader, "java/lang/ref/PhantomReference", "<init>",<br>
+ "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",<br>
+ ACC_VIRTUAL);<br>
+ initPhantomReference->setNative();<br>
+}<br>
+<br>
+#include "ClasspathConstructor.inc"<br>
+#include "Classpath.inc"<br>
+#include "ClasspathField.inc"<br>
+#include "ClasspathMethod.inc"<br>
+#include "ClasspathVMClass.inc"<br>
+#include "ClasspathVMClassLoader.inc"<br>
+#include "ClasspathVMObject.inc"<br>
+#include "ClasspathVMRuntime.inc"<br>
+#include "ClasspathVMStackWalker.inc"<br>
+#include "ClasspathVMSystem.inc"<br>
+#include "ClasspathVMSystemProperties.inc"<br>
+#include "ClasspathVMThread.inc"<br>
+#include "ClasspathVMThrowable.inc"<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h<br>
b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h<br>
new file mode 100644<br>
index 0000000..ae5eb63<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/JavaUpcalls.h<br>
@@ -0,0 +1,283 @@<br>
+//===---------- JavaUpcalls.h - Upcalls to Java entities<br>
------------------===//<br>
+//<br>
+// The VMKit project<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#ifndef JNJVM_JAVA_UPCALLS_H<br>
+#define JNJVM_JAVA_UPCALLS_H<br>
+<br>
+#include "mvm/Allocator.h"<br>
+<br>
+#include "JnjvmConfig.h"<br>
+<br>
+#define UPCALL_CLASS(vm, name)<br>
\<br>
+ vm->loadName(vm->asciizConstructUTF8(name), true, false, NULL)<br>
+<br>
+#define UPCALL_PRIMITIVE_CLASS(loader, name, nb)<br>
\<br>
+ new(loader->allocator, "Primitive class")<br>
\<br>
+ UserClassPrimitive(loader,<br>
loader->asciizConstructUTF8(name), nb) \<br>
+<br>
+#define UPCALL_FIELD(vm, cl, name, type, acc)<br>
\<br>
+ UPCALL_CLASS(vm,<br>
cl)->lookupFieldDontThrow(vm->asciizConstructUTF8(name), \<br>
+<br>
vm->asciizConstructUTF8(type), \<br>
+ isStatic(acc), false, 0)<br>
+<br>
+#define UPCALL_METHOD(vm, cl, name, type, acc)<br>
\<br>
+ UPCALL_CLASS(vm,<br>
cl)->lookupMethodDontThrow(vm->asciizConstructUTF8(name), \<br>
+<br>
vm->asciizConstructUTF8(type), \<br>
+ isStatic(acc), false, 0)<br>
+<br>
+#define UPCALL_ARRAY_CLASS(loader, name, depth)<br>
\<br>
+ loader->constructArray(<br>
\<br>
+ loader->constructArrayName(depth, loader->asciizConstructUTF8(name)))<br>
+<br>
+#define UPCALL_CLASS_EXCEPTION(loader, name)<br>
\<br>
+ name = UPCALL_CLASS(loader, "java/lang/"#name)<br>
+<br>
+#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name)<br>
\<br>
+ name = UPCALL_CLASS(loader, "java/lang/reflect/"#name)<br>
+<br>
+#define UPCALL_METHOD_EXCEPTION(loader, name) \<br>
+ Init##name =<br>
name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \<br>
+<br>
loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \<br>
+ false, false, 0);<br>
+<br>
+#define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \<br>
+ ErrorWithExcp##name =<br>
name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \<br>
+<br>
loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \<br>
+ false, false, 0);<br>
+<br>
+namespace j3 {<br>
+<br>
+class Jnjvm;<br>
+class JavaField;<br>
+class JavaMethod;<br>
+class JavaObject;<br>
+class JavaThread;<br>
+class Class;<br>
+class ClassArray;<br>
+class JnjvmClassLoader;<br>
+<br>
+class Classpath : public mvm::PermanentObject {<br>
+public:<br>
+ ISOLATE_STATIC UserClass* newClassLoader;<br>
+ ISOLATE_STATIC JavaMethod* getSystemClassLoader;<br>
+ ISOLATE_STATIC JavaMethod* setContextClassLoader;<br>
+ ISOLATE_STATIC UserClass* newString;<br>
+ ISOLATE_STATIC UserClass* newClass;<br>
+ ISOLATE_STATIC UserClass* newThrowable;<br>
+ ISOLATE_STATIC UserClass* newException;<br>
+ ISOLATE_STATIC JavaMethod* initClass;<br>
+ ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain;<br>
+ ISOLATE_STATIC JavaField* vmdataClass;<br>
+ ISOLATE_STATIC JavaMethod* setProperty;<br>
+ ISOLATE_STATIC JavaMethod* initString;<br>
+ ISOLATE_STATIC JavaMethod* getCallingClassLoader;<br>
+ ISOLATE_STATIC JavaMethod* initConstructor;<br>
+ ISOLATE_STATIC UserClassArray* constructorArrayClass;<br>
+ ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;<br>
+ ISOLATE_STATIC UserClass* newConstructor;<br>
+ ISOLATE_STATIC JavaField* constructorSlot;<br>
+ ISOLATE_STATIC JavaMethod* initMethod;<br>
+ ISOLATE_STATIC JavaMethod* initField;<br>
+ ISOLATE_STATIC UserClassArray* methodArrayClass;<br>
+ ISOLATE_STATIC UserClassArray* fieldArrayClass;<br>
+ ISOLATE_STATIC UserClass* newMethod;<br>
+ ISOLATE_STATIC UserClass* newField;<br>
+ ISOLATE_STATIC JavaField* methodSlot;<br>
+ ISOLATE_STATIC JavaField* fieldSlot;<br>
+ ISOLATE_STATIC UserClassArray* classArrayClass;<br>
+ ISOLATE_STATIC JavaMethod* loadInClassLoader;<br>
+ ISOLATE_STATIC JavaMethod* initVMThrowable;<br>
+ ISOLATE_STATIC JavaField* vmDataVMThrowable;<br>
+ ISOLATE_STATIC UserClass* newVMThrowable;<br>
+ ISOLATE_STATIC JavaField* bufferAddress;<br>
+ ISOLATE_STATIC JavaField* dataPointer32;<br>
+ ISOLATE_STATIC JavaField* dataPointer64;<br>
+ ISOLATE_STATIC UserClass* newPointer32;<br>
+ ISOLATE_STATIC UserClass* newPointer64;<br>
+ ISOLATE_STATIC UserClass* newDirectByteBuffer;<br>
+ ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;<br>
+ ISOLATE_STATIC JavaField* vmdataClassLoader;<br>
+ ISOLATE_STATIC UserClass* enumClass;<br>
+<br>
+ ISOLATE_STATIC JavaField* boolValue;<br>
+ ISOLATE_STATIC JavaField* byteValue;<br>
+ ISOLATE_STATIC JavaField* shortValue;<br>
+ ISOLATE_STATIC JavaField* charValue;<br>
+ ISOLATE_STATIC JavaField* intValue;<br>
+ ISOLATE_STATIC JavaField* longValue;<br>
+ ISOLATE_STATIC JavaField* floatValue;<br>
+ ISOLATE_STATIC JavaField* doubleValue;<br>
+<br>
+ ISOLATE_STATIC UserClass* newStackTraceElement;<br>
+ ISOLATE_STATIC UserClassArray* stackTraceArray;<br>
+ ISOLATE_STATIC JavaMethod* initStackTraceElement;<br>
+<br>
+ ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader);<br>
+<br>
+ ISOLATE_STATIC UserClass* voidClass;<br>
+ ISOLATE_STATIC UserClass* boolClass;<br>
+ ISOLATE_STATIC UserClass* byteClass;<br>
+ ISOLATE_STATIC UserClass* shortClass;<br>
+ ISOLATE_STATIC UserClass* charClass;<br>
+ ISOLATE_STATIC UserClass* intClass;<br>
+ ISOLATE_STATIC UserClass* floatClass;<br>
+ ISOLATE_STATIC UserClass* doubleClass;<br>
+ ISOLATE_STATIC UserClass* longClass;<br>
+<br>
+ ISOLATE_STATIC UserClass* vmStackWalker;<br>
+<br>
+ ISOLATE_STATIC UserClass* newThread;<br>
+ ISOLATE_STATIC UserClass* newVMThread;<br>
+ ISOLATE_STATIC JavaField* assocThread;<br>
+ ISOLATE_STATIC JavaField* vmdataVMThread;<br>
+ ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread;<br>
+ ISOLATE_STATIC JavaMethod* initThread;<br>
+ ISOLATE_STATIC JavaMethod* initVMThread;<br>
+ ISOLATE_STATIC JavaMethod* runVMThread;<br>
+ ISOLATE_STATIC JavaMethod* groupAddThread;<br>
+ ISOLATE_STATIC JavaField* threadName;<br>
+ ISOLATE_STATIC JavaField* groupName;<br>
+ ISOLATE_STATIC JavaMethod* initGroup;<br>
+ ISOLATE_STATIC JavaField* priority;<br>
+ ISOLATE_STATIC JavaField* daemon;<br>
+ ISOLATE_STATIC JavaField* group;<br>
+ ISOLATE_STATIC JavaField* running;<br>
+ ISOLATE_STATIC UserClass* threadGroup;<br>
+ ISOLATE_STATIC JavaField* rootGroup;<br>
+ ISOLATE_STATIC JavaField* vmThread;<br>
+ ISOLATE_STATIC JavaMethod* getUncaughtExceptionHandler;<br>
+ ISOLATE_STATIC JavaMethod* uncaughtException;<br>
+ ISOLATE_STATIC UserClass* inheritableThreadLocal;<br>
+<br>
+<br>
+ ISOLATE_STATIC UserClass* InvocationTargetException;<br>
+ ISOLATE_STATIC UserClass* ArrayStoreException;<br>
+ ISOLATE_STATIC UserClass* ClassCastException;<br>
+ ISOLATE_STATIC UserClass* IllegalMonitorStateException;<br>
+ ISOLATE_STATIC UserClass* IllegalArgumentException;<br>
+ ISOLATE_STATIC UserClass* InterruptedException;<br>
+ ISOLATE_STATIC UserClass* IndexOutOfBoundsException;<br>
+ ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException;<br>
+ ISOLATE_STATIC UserClass* NegativeArraySizeException;<br>
+ ISOLATE_STATIC UserClass* NullPointerException;<br>
+ ISOLATE_STATIC UserClass* SecurityException;<br>
+ ISOLATE_STATIC UserClass* ClassFormatError;<br>
+ ISOLATE_STATIC UserClass* ClassCircularityError;<br>
+ ISOLATE_STATIC UserClass* NoClassDefFoundError;<br>
+ ISOLATE_STATIC UserClass* UnsupportedClassVersionError;<br>
+ ISOLATE_STATIC UserClass* NoSuchFieldError;<br>
+ ISOLATE_STATIC UserClass* NoSuchMethodError;<br>
+ ISOLATE_STATIC UserClass* InstantiationError;<br>
+ ISOLATE_STATIC UserClass* InstantiationException;<br>
+ ISOLATE_STATIC UserClass* IllegalAccessError;<br>
+ ISOLATE_STATIC UserClass* IllegalAccessException;<br>
+ ISOLATE_STATIC UserClass* VerifyError;<br>
+ ISOLATE_STATIC UserClass* ExceptionInInitializerError;<br>
+ ISOLATE_STATIC UserClass* LinkageError;<br>
+ ISOLATE_STATIC UserClass* AbstractMethodError;<br>
+ ISOLATE_STATIC UserClass* UnsatisfiedLinkError;<br>
+ ISOLATE_STATIC UserClass* InternalError;<br>
+ ISOLATE_STATIC UserClass* OutOfMemoryError;<br>
+ ISOLATE_STATIC UserClass* StackOverflowError;<br>
+ ISOLATE_STATIC UserClass* UnknownError;<br>
+ ISOLATE_STATIC UserClass* ClassNotFoundException;<br>
+ ISOLATE_STATIC UserClass* ArithmeticException;<br>
+<br>
+ ISOLATE_STATIC JavaMethod* InitInvocationTargetException;<br>
+ ISOLATE_STATIC JavaMethod* InitArrayStoreException;<br>
+ ISOLATE_STATIC JavaMethod* InitClassCastException;<br>
+ ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException;<br>
+ ISOLATE_STATIC JavaMethod* InitIllegalArgumentException;<br>
+ ISOLATE_STATIC JavaMethod* InitInterruptedException;<br>
+ ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException;<br>
+ ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException;<br>
+ ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException;<br>
+ ISOLATE_STATIC JavaMethod* InitNullPointerException;<br>
+ ISOLATE_STATIC JavaMethod* InitSecurityException;<br>
+ ISOLATE_STATIC JavaMethod* InitClassFormatError;<br>
+ ISOLATE_STATIC JavaMethod* InitClassCircularityError;<br>
+ ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError;<br>
+ ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError;<br>
+ ISOLATE_STATIC JavaMethod* InitNoSuchFieldError;<br>
+ ISOLATE_STATIC JavaMethod* InitNoSuchMethodError;<br>
+ ISOLATE_STATIC JavaMethod* InitInstantiationError;<br>
+ ISOLATE_STATIC JavaMethod* InitInstantiationException;<br>
+ ISOLATE_STATIC JavaMethod* InitIllegalAccessError;<br>
+ ISOLATE_STATIC JavaMethod* InitIllegalAccessException;<br>
+ ISOLATE_STATIC JavaMethod* InitVerifyError;<br>
+ ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError;<br>
+ ISOLATE_STATIC JavaMethod* InitLinkageError;<br>
+ ISOLATE_STATIC JavaMethod* InitAbstractMethodError;<br>
+ ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError;<br>
+ ISOLATE_STATIC JavaMethod* InitInternalError;<br>
+ ISOLATE_STATIC JavaMethod* InitOutOfMemoryError;<br>
+ ISOLATE_STATIC JavaMethod* InitStackOverflowError;<br>
+ ISOLATE_STATIC JavaMethod* InitUnknownError;<br>
+ ISOLATE_STATIC JavaMethod* InitClassNotFoundException;<br>
+ ISOLATE_STATIC JavaMethod* InitArithmeticException;<br>
+<br>
+ ISOLATE_STATIC JavaMethod* SystemArraycopy;<br>
+ ISOLATE_STATIC JavaMethod* VMSystemArraycopy;<br>
+ ISOLATE_STATIC Class* SystemClass;<br>
+<br>
+ ISOLATE_STATIC JavaMethod* IntToString;<br>
+<br>
+ ISOLATE_STATIC JavaMethod* InitObject;<br>
+ ISOLATE_STATIC JavaMethod* FinalizeObject;<br>
+<br>
+ ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError;<br>
+ ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError;<br>
+ ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException;<br>
+<br>
+<br>
+<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfByte;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfChar;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfInt;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfShort;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfBool;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfLong;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfFloat;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfDouble;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfObject;<br>
+ ISOLATE_STATIC UserClassArray* ArrayOfString;<br>
+<br>
+ ISOLATE_STATIC UserClassPrimitive* OfByte;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfChar;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfInt;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfShort;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfBool;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfLong;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfFloat;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfDouble;<br>
+ ISOLATE_STATIC UserClassPrimitive* OfVoid;<br>
+<br>
+ ISOLATE_STATIC UserClass* OfObject;<br>
+<br>
+ ISOLATE_STATIC JavaField* methodClass;<br>
+ ISOLATE_STATIC JavaField* fieldClass;<br>
+ ISOLATE_STATIC JavaField* constructorClass;<br>
+<br>
+ ISOLATE_STATIC JavaMethod* EnqueueReference;<br>
+ ISOLATE_STATIC Class* newReference;<br>
+<br>
+ ISOLATE_STATIC UserClass* EnumClass;<br>
+<br>
+private:<br>
+ ISOLATE_STATIC void CreateJavaThread(Jnjvm* vm, JavaThread* myth,<br>
+ const char* name, JavaObject* Group);<br>
+<br>
+public:<br>
+ ISOLATE_STATIC void InitializeThreading(Jnjvm* vm);<br>
+};<br>
+<br>
+<br>
+} // end namespace j3<br>
+<br>
+#endif<br>
diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile<br>
b/lib/J3/ClassLib/GNUClasspath/Makefile<br>
new file mode 100644<br>
index 0000000..bc695df<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/GNUClasspath/Makefile<br>
@@ -0,0 +1,23 @@<br>
+##===- lib/J3/ClassLib/GNUClasspath/Makefile ---------------*-<br>
Makefile -*-===##<br>
+#<br>
+# The vmkit project<br>
+#<br>
+# This file is distributed under the University of Illinois Open Source<br>
+# License. See LICENSE.TXT for details.<br>
+#<br>
+##===----------------------------------------------------------------------===##<br>
+LEVEL = ../../../..<br>
+<br>
+<br>
+EXTRA_DIST = ClasspathConstructor.inc ClasspathField.inc<br>
Classpath.inc ClasspathMethod.inc \<br>
+ ClasspathVMClass.inc ClasspathVMClassLoader.inc ClasspathVMObject.inc \<br>
+ ClasspathVMRuntime.inc ClasspathVMStackWalker.inc ClasspathVMSystem.inc \<br>
+ ClasspathVMSystemProperties.inc ClasspathVMThread.inc<br>
ClasspathVMThrowable.inc<br>
+<br>
+include $(LEVEL)/Makefile.config<br>
+<br>
+MODULE_WITH_GC = Classpath<br>
+<br>
+include $(LEVEL)/Makefile.common<br>
+<br>
+CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/J3/VMCore<br>
-I$(PROJ_SRC_ROOT)/include/j3 -I..<br>
diff --git a/lib/J3/ClassLib/Makefile b/lib/J3/ClassLib/Makefile<br>
new file mode 100644<br>
index 0000000..3ecee91<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/Makefile<br>
@@ -0,0 +1,15 @@<br>
+##===- lib/J3/ClassLib/Makefile ----------------------------*-<br>
Makefile -*-===##<br>
+#<br>
+# The vmkit project<br>
+#<br>
+# This file is distributed under the University of Illinois Open Source<br>
+# License. See LICENSE.TXT for details.<br>
+#<br>
+##===----------------------------------------------------------------------===##<br>
+LEVEL = ../../..<br>
+<br>
+include $(LEVEL)/Makefile.config<br>
+<br>
+DIRS = $(CLASSPATH_DIR)<br>
+<br>
+include $(LEVEL)/Makefile.common<br>
diff --git a/lib/J3/ClassLib/OpenJDK/Makefile b/lib/J3/ClassLib/OpenJDK/Makefile<br>
new file mode 100644<br>
index 0000000..4a97d96<br>
--- /dev/null<br>
+++ b/lib/J3/ClassLib/OpenJDK/Makefile<br>
@@ -0,0 +1,19 @@<br>
+##===- lib/J3/ClassLib/OpenJDK/Makefile --------------------*-<br>
Makefile -*-===##<br>
+#<br>
+# The vmkit project<br>
+#<br>
+# This file is distributed under the University of Illinois Open Source<br>
+# License. See LICENSE.TXT for details.<br>
+#<br>
+##===----------------------------------------------------------------------===##<br>
+LEVEL = ../../../..<br>
+<br>
+EXTRA_DIST =<br>
+<br>
+include $(LEVEL)/Makefile.config<br>
+<br>
+MODULE_WITH_GC = Classpath<br>
+<br>
+include $(LEVEL)/Makefile.common<br>
+<br>
+CXX.Flags += -I$(PROJ_SRC_ROOT)/lib/J3/VMCore<br>
-I$(PROJ_SRC_ROOT)/include/j3 -I..<br>
diff --git a/lib/J3/Classpath/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a> b/lib/J3/Classpath/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a><br>
deleted file mode 100644<br>
index 107510d..0000000<br>
--- a/lib/J3/Classpath/<a href="http://Classpath.h.in" target="_blank">Classpath.h.in</a><br>
+++ /dev/null<br>
@@ -1,19 +0,0 @@<br>
-//===-------- Classpath.h - Configuration for classpath<br>
-------------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-<br>
-#define GNUClasspathLibs "@classpathlibs@";<br>
-#define GNUClasspathGlibj "@classpathglibj@";<br>
-#define GNUClasspathVersion "@classpathversion@";<br>
-<br>
-#ifdef NATIVE_JNI<br>
-#define JNIEXPORT<br>
-#else<br>
-#include <jni.h><br>
-#endif<br>
diff --git a/lib/J3/Classpath/Classpath.inc b/lib/J3/Classpath/Classpath.inc<br>
deleted file mode 100644<br>
index 792b606..0000000<br>
--- a/lib/J3/Classpath/Classpath.inc<br>
+++ /dev/null<br>
@@ -1,392 +0,0 @@<br>
-//===-------- Classpath.cpp - Configuration for classpath<br>
-------------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-<br>
-<br>
-#include "Classpath.h"<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-// Define hasClassInitializer because of a buggy implementation in Classpath.<br>
-JNIEXPORT bool JNICALL Java_java_io_VMObjectStreamClass_hasClassInitializer(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- llvm_gcroot(Cl, 0);<br>
- bool res = false;<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(Cl);<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, true);<br>
-<br>
- if (cl->isClass() &&<br>
- cl->asClass()->lookupMethodDontThrow(vm->bootstrapLoader->clinitName,<br>
- vm->bootstrapLoader->clinitType,<br>
- true, false, 0))<br>
- res = true;<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-<br>
-// Redefine some VMObjectStreamClass functions because of a slow implementation<br>
-// in Classpath.<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setBooleanNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jboolean val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceInt8Field(obj, (uint8)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setByteNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jbyte val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceInt8Field(obj, (uint8)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setCharNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jchar val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceInt16Field((JavaObject*)obj, (uint16)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setShortNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jshort val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceInt16Field(obj, (sint16)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setIntNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jint val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceInt32Field(obj, (sint32)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setLongNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jlong val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceLongField(obj, (sint64)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setFloatNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jfloat val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceFloatField(obj, (float)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setDoubleNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jdouble val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_io_VMObjectStreamClass_setObjectNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(val, 0);<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(obj);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- field->setInstanceObjectField(obj, val);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_io_VMObjectInputStream_allocateObject(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* target, JavaObject* constr, JavaObjectConstructor* cons) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(target, 0);<br>
- llvm_gcroot(constr, 0);<br>
- llvm_gcroot(cons, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl =<br>
- (UserClass*)UserCommonClass::resolvedImplClass(vm, target, true);<br>
- res = cl->doNew(vm);<br>
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
- meth->invokeIntSpecial(vm, cl, res);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_VMArray_createObjectArray(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv * env,<br>
-jclass thisClass,<br>
-#endif<br>
-JavaObject* arrayType, jint arrayLength) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(arrayType, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* base =<br>
- UserCommonClass::resolvedImplClass(vm, arrayType, true);<br>
- JnjvmClassLoader* loader = base->classLoader;<br>
- const UTF8* name = base->getName();<br>
- // -1 because we're adding a new dimension in this method.<br>
- const int kLimit = 255 - 1;<br>
- const uint16* elements = name->elements;<br>
- if (name->size > kLimit && elements[kLimit] == '[') {<br>
- vm->illegalArgumentException("Too many dimensions for array");<br>
- }<br>
- const UTF8* arrayName = loader->constructArrayName(1, name);<br>
- UserClassArray* array = loader->constructArray(arrayName, base);<br>
- res = array->doNew(arrayLength, vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-<br>
-// Never throws.<br>
-JNIEXPORT<br>
-bool JNICALL Java_java_util_concurrent_atomic_AtomicLong_VMSupportsCS8(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- return false;<br>
-}<br>
-<br>
-// Never throws.<br>
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapLong(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* unsafe, JavaObject* obj, jlong offset, jlong expect,<br>
jlong update) {<br>
-<br>
- llvm_gcroot(unsafe, 0);<br>
- llvm_gcroot(obj, 0);<br>
- jlong *ptr;<br>
- jlong value;<br>
-<br>
- ptr = (jlong *) (((uint8 *) obj) + offset);<br>
-<br>
- value = *ptr;<br>
-<br>
- if (value == expect) {<br>
- *ptr = update;<br>
- return true;<br>
- } else {<br>
- return false;<br>
- }<br>
-<br>
-}<br>
-<br>
-// Never throws.<br>
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapInt(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* unsafe, JavaObject* obj, jlong offset, jint expect, jint update) {<br>
-<br>
- llvm_gcroot(unsafe, 0);<br>
- llvm_gcroot(obj, 0);<br>
- jint *ptr;<br>
-<br>
- ptr = (jint *) (((uint8 *) obj) + offset);<br>
-<br>
- return __sync_bool_compare_and_swap(ptr, expect, update);<br>
-}<br>
-<br>
-// Never throws.<br>
-JNIEXPORT bool JNICALL Java_sun_misc_Unsafe_compareAndSwapObject(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* expect,<br>
-JavaObject* update) {<br>
- llvm_gcroot(unsafe, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(expect, 0);<br>
- llvm_gcroot(update, 0);<br>
-<br>
- JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);<br>
-<br>
- return mvm::Collector::objectReferenceTryCASBarrier((gc*)obj,<br>
(gc**)ptr, (gc*)expect, (gc*)update);<br>
-}<br>
-<br>
-// Never throws.<br>
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_putObjectVolatile(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* unsafe, JavaObject* obj, jlong offset, JavaObject* value) {<br>
- llvm_gcroot(unsafe, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(value, 0);<br>
-<br>
- JavaObject** ptr = (JavaObject**) (((uint8 *) obj) + offset);<br>
- mvm::Collector::objectReferenceWriteBarrier((gc*)obj, (gc**)ptr, (gc*)value);<br>
-}<br>
-<br>
-// TODO: Add the Volatile variants<br>
-#define GET_PUT_OFFSET(Type,jtype,shorttype) \<br>
-JNIEXPORT jtype JNICALL Java_sun_misc_Unsafe_get ## Type ##<br>
__Ljava_lang_Object_2J( \<br>
-JavaObject* unsafe, JavaObject* base, jlong offset) { \<br>
- jtype res = 0; \<br>
- BEGIN_NATIVE_EXCEPTION(0) \<br>
- jtype* ptr = (jtype*) (((uint8 *) base) + offset); \<br>
- res = *ptr; \<br>
- END_NATIVE_EXCEPTION \<br>
- \<br>
- return res; \<br>
-} \<br>
- \<br>
-JNIEXPORT void JNICALL Java_sun_misc_Unsafe_put ## Type ##<br>
__Ljava_lang_Object_2J ## shorttype( \<br>
-JavaObject* unsafe, JavaObject* base, jlong offset, jtype val) { \<br>
- BEGIN_NATIVE_EXCEPTION(0) \<br>
- jtype* ptr = (jtype*) (((uint8 *) base) + offset); \<br>
- *ptr = val; \<br>
- END_NATIVE_EXCEPTION \<br>
-}<br>
-<br>
-GET_PUT_OFFSET(Boolean,jboolean,Z)<br>
-GET_PUT_OFFSET(Byte,jbyte,B)<br>
-GET_PUT_OFFSET(Char,jchar,C)<br>
-GET_PUT_OFFSET(Short,jshort,S)<br>
-GET_PUT_OFFSET(Int,jint,I)<br>
-GET_PUT_OFFSET(Long,jlong,J)<br>
-GET_PUT_OFFSET(Float,jfloat,F)<br>
-GET_PUT_OFFSET(Double,jdouble,D)<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathConstructor.inc<br>
b/lib/J3/Classpath/ClasspathConstructor.inc<br>
deleted file mode 100644<br>
index 90a315b..0000000<br>
--- a/lib/J3/Classpath/ClasspathConstructor.inc<br>
+++ /dev/null<br>
@@ -1,222 +0,0 @@<br>
-//===- ClasspathConstructor.cpp<br>
-------------------------------------------===//<br>
-//===----------- GNU classpath java/lang/reflect/Constructor<br>
--------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaTypes.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-#include "JnjvmClassLoader.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JNIEXPORT jobject JNICALL Java_java_lang_reflect_Constructor_getParameterTypes(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectConstructor* cons) {<br>
-<br>
- JavaObject* res = 0;<br>
-<br>
- llvm_gcroot(cons, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(cons);<br>
- UserClass* cl = JavaObjectConstructor::getClass(cons);<br>
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
- JnjvmClassLoader* loader = cl->classLoader;<br>
-<br>
- res = meth->getParameterTypes(loader);<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return (jobject)res;<br>
-}<br>
-<br>
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Constructor_getModifiersInternal(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectConstructor* cons) {<br>
-<br>
- llvm_gcroot(cons, 0);<br>
- jint res = 0;<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(cons);<br>
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
- res = meth->access;<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JavaObject* proceedConstructor(JavaObjectConstructor* cons,<br>
- ArrayObject* args,<br>
- JavaObject* Clazz, jint index)<br>
- __attribute__ ((noinline));<br>
-<br>
-JavaObject* proceedConstructor(JavaObjectConstructor* cons,<br>
- ArrayObject* args,<br>
- JavaObject* Clazz, jint index) {<br>
- JavaObject* res = 0;<br>
- JavaObject* excp = 0;<br>
-<br>
- llvm_gcroot(cons, 0);<br>
- llvm_gcroot(args, 0);<br>
- llvm_gcroot(Clazz, 0);<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(excp, 0);<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
- UserClass* cl = JavaObjectConstructor::getClass(cons);<br>
- sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;<br>
- Signdef* sign = meth->getSignature();<br>
- sint32 size = sign->nbArguments;<br>
-<br>
- if (isAbstract(cl->access)) vm->instantiationException(cl);<br>
-<br>
- mvm::ThreadAllocator allocator;<br>
- // Allocate a buffer to store the arguments.<br>
- jvalue* buf = size ?<br>
- (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;<br>
-<br>
- if (nbArgs == size) {<br>
- UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm,<br>
Clazz, false);<br>
- UserClass* cl = _cl->asClass();<br>
- if (cl) {<br>
- cl->initialiseClass(vm);<br>
- res = cl->doNew(vm);<br>
- JavaObject** ptr = (JavaObject**)ArrayObject::getElements(args);<br>
-<br>
- Typedef* const* arguments = sign->getArgumentsType();<br>
- // Store the arguments, unboxing primitives if necessary.<br>
- for (sint32 i = 0; i < size; ++i) {<br>
- JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);<br>
- if (!arguments[i]->isPrimitive()) {<br>
- buf[i].l = reinterpret_cast<jobject>(&ptr[i]);<br>
- }<br>
- }<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- TRY {<br>
- meth->invokeIntSpecialBuf(vm, cl, res, buf);<br>
- } CATCH {<br>
- excp = th->getJavaException();<br>
- } END_CATCH;<br>
- if (excp) {<br>
- if (JavaObject::getClass(excp)->isAssignableFrom(vm->upcalls->newException))<br>
{<br>
- th->clearException();<br>
- // If it's an exception, we encapsule it in an<br>
- // invocationTargetException<br>
- vm->invocationTargetException(excp);<br>
- } else {<br>
- // If it's an error, throw it again.<br>
- th->throwPendingException();<br>
- }<br>
- return NULL;<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("class is not a regular class");<br>
- return NULL;<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong number of arguments");<br>
- return NULL;<br>
- }<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL<br>
Java_java_lang_reflect_Constructor_constructNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectConstructor* cons, ArrayObject* args, JavaObject* Clazz,<br>
jint index) {<br>
-<br>
- JavaObject* res = 0;<br>
-<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(cons, 0);<br>
- llvm_gcroot(args, 0);<br>
- llvm_gcroot(Clazz, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- res = proceedConstructor(cons, args, Clazz, index);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT<br>
-ArrayObject* JNICALL Java_java_lang_reflect_Constructor_getExceptionTypes(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectConstructor* cons) {<br>
-<br>
- ArrayObject* res = 0;<br>
-<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(cons, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(cons);<br>
- UserClass* cl = JavaObjectConstructor::getClass(cons);<br>
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(cons);<br>
- JnjvmClassLoader* loader = cl->classLoader;<br>
-<br>
- res = (ArrayObject*)meth->getExceptionTypes(loader);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Constructor_getSignature(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectConstructor* Meth) {<br>
-<br>
- JavaObject* result = 0;<br>
-<br>
- llvm_gcroot(result, 0);<br>
- llvm_gcroot(Meth, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(Meth);<br>
- JavaMethod* meth = JavaObjectConstructor::getInternalMethod(Meth);<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- result = vm->internalUTF8ToStr(meth->type);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return result;<br>
-}<br>
-<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathField.inc<br>
b/lib/J3/Classpath/ClasspathField.inc<br>
deleted file mode 100644<br>
index 5082caa..0000000<br>
--- a/lib/J3/Classpath/ClasspathField.inc<br>
+++ /dev/null<br>
@@ -1,1171 +0,0 @@<br>
-//===- ClasspathVMField.cpp - GNU classpath java/lang/reflect/Field<br>
-------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "Classpath.h"<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaTypes.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-<br>
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getModifiersInternal(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field) {<br>
- jint res = 0;<br>
-<br>
- llvm_gcroot(Field, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- res = field->access;<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_getType(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field) {<br>
-<br>
- JavaObject* res = 0;<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- JnjvmClassLoader* loader = cl->classLoader;<br>
- UserCommonClass* fieldCl = field->getSignature()->assocClass(loader);<br>
- res = fieldCl->getClassDelegatee(vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Field_getInt(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jint res = 0;<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- const Typedef* type = field->getSignature();<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
-<br>
- if (prim->isInt()) {<br>
- if (stat) {<br>
- res = (sint32)field->getStaticInt32Field();<br>
- } else {<br>
- res = (sint32)field->getInstanceInt32Field(obj);<br>
- }<br>
- } else if (prim->isChar()) {<br>
- if (stat) {<br>
- res = (uint32)field->getStaticInt16Field();<br>
- } else {<br>
- res = (uint32)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isByte()) {<br>
- if (stat) {<br>
- res = (sint32)field->getStaticInt8Field();<br>
- } else {<br>
- res = (sint32)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else if (prim->isShort()) {<br>
- if (stat) {<br>
- res = (sint32)field->getStaticInt16Field();<br>
- } else {<br>
- res = (sint32)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-JNIEXPORT jlong JNICALL Java_java_lang_reflect_Field_getLong(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jlong res = 0;<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
-<br>
- if (prim->isInt()) {<br>
- if (stat) {<br>
- res = (sint64)field->getStaticInt32Field();<br>
- } else {<br>
- res = (sint64)field->getInstanceInt32Field(obj);<br>
- }<br>
- } else if (prim->isChar()) {<br>
- if (stat) {<br>
- res = (uint64)field->getStaticInt16Field();<br>
- } else {<br>
- res = (uint64)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isByte()) {<br>
- if (stat) {<br>
- res = (sint64)field->getStaticInt8Field();<br>
- } else {<br>
- res = (sint64)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else if (prim->isShort()) {<br>
- if (stat) {<br>
- res = (sint64)field->getStaticInt16Field();<br>
- } else {<br>
- res = (sint64)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- res = (sint64)field->getStaticLongField();<br>
- } else {<br>
- res = (sint64)field->getInstanceLongField(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_reflect_Field_getBoolean(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jboolean res = 0;<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isBool()) {<br>
- if (stat) {<br>
- res = (uint8)field->getStaticInt8Field();<br>
- } else {<br>
- res = (uint8)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-JNIEXPORT jfloat JNICALL Java_java_lang_reflect_Field_getFloat(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jfloat res = 0;<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isByte()) {<br>
- if (stat) {<br>
- res = (jfloat)field->getStaticInt8Field();<br>
- } else {<br>
- res = (jfloat)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else if (prim->isInt()) {<br>
- if (stat) {<br>
- res = (jfloat)field->getStaticInt32Field();<br>
- } else {<br>
- res = (jfloat)field->getInstanceInt32Field(obj);<br>
- }<br>
- } else if (prim->isShort()) {<br>
- if (stat) {<br>
- res = (jfloat)field->getStaticInt16Field();<br>
- } else {<br>
- res = (jfloat)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- res = (jfloat)field->getStaticLongField();<br>
- } else {<br>
- res = (jfloat)field->getInstanceLongField(obj);<br>
- }<br>
- } else if (prim->isChar()) {<br>
- // Cast to uint32 because char is unsigned.<br>
- if (stat) {<br>
- res = (jfloat)(uint32)field->getStaticInt16Field();<br>
- } else {<br>
- res = (jfloat)(uint32)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- res = (jfloat)field->getStaticFloatField();<br>
- } else {<br>
- res = (jfloat)field->getInstanceFloatField(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jbyte JNICALL Java_java_lang_reflect_Field_getByte(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jbyte res = 0;<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isByte()) {<br>
- if (stat) {<br>
- res = (sint8)field->getStaticInt8Field();<br>
- } else {<br>
- res = (sint8)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jchar JNICALL Java_java_lang_reflect_Field_getChar(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jchar res = 0;<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isChar()) {<br>
- if (stat) {<br>
- res = (uint16)field->getStaticInt16Field();<br>
- } else {<br>
- res = (uint16)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-JNIEXPORT jshort JNICALL Java_java_lang_reflect_Field_getShort(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
-<br>
- jshort res = 0;<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isShort()) {<br>
- if (stat) {<br>
- res = (sint16)field->getStaticInt16Field();<br>
- } else {<br>
- res = (sint16)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isByte()) {<br>
- if (stat) {<br>
- res = (sint16)field->getStaticInt8Field();<br>
- } else {<br>
- res = (sint16)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jdouble JNICALL Java_java_lang_reflect_Field_getDouble(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
- jdouble res = 0;<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isByte()) {<br>
- if (stat) {<br>
- res = (jdouble)(sint64)field->getStaticInt8Field();<br>
- } else {<br>
- res = (jdouble)(sint64)field->getInstanceInt8Field(obj);<br>
- }<br>
- } else if (prim->isInt()) {<br>
- if (stat) {<br>
- res = (jdouble)(sint64)field->getStaticInt32Field();<br>
- } else {<br>
- res = (jdouble)(sint64)field->getInstanceInt32Field(obj);<br>
- }<br>
- } else if (prim->isShort()) {<br>
- if (stat) {<br>
- res = (jdouble)(sint64)field->getStaticInt16Field();<br>
- } else {<br>
- res = (jdouble)(sint64)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- res = (jdouble)(sint64)field->getStaticLongField();<br>
- } else {<br>
- res = (jdouble)(sint64)field->getInstanceLongField(obj);<br>
- }<br>
- } else if (prim->isChar()) {<br>
- if (stat) {<br>
- res = (jdouble)(uint64)field->getStaticInt16Field();<br>
- } else {<br>
- res = (jdouble)(uint64)field->getInstanceInt16Field(obj);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- res = (jdouble)field->getStaticFloatField();<br>
- } else {<br>
- res = (jdouble)field->getInstanceFloatField(obj);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- res = (jdouble)field->getStaticDoubleField();<br>
- } else {<br>
- res = (jdouble)field->getInstanceDoubleField(obj);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Field_get(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj) {<br>
-<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isBool()) {<br>
- uint8 val = stat ? field->getStaticInt8Field() :<br>
- field->getInstanceInt8Field(obj);<br>
- res = vm->upcalls->boolClass->doNew(vm);<br>
- vm->upcalls->boolValue->setInstanceInt8Field(res, val);<br>
- } else if (prim->isByte()) {<br>
- sint8 val = stat ? field->getStaticInt8Field() :<br>
- field->getInstanceInt8Field(obj);<br>
- res = vm->upcalls->byteClass->doNew(vm);<br>
- vm->upcalls->byteValue->setInstanceInt8Field(res, val);<br>
- } else if (prim->isChar()) {<br>
- uint16 val = stat ? field->getStaticInt16Field() :<br>
- field->getInstanceInt16Field(obj);<br>
- res = vm->upcalls->charClass->doNew(vm);<br>
- vm->upcalls->charValue->setInstanceInt16Field(res, val);<br>
- } else if (prim->isShort()) {<br>
- sint16 val = stat ? field->getStaticInt16Field() :<br>
- field->getInstanceInt16Field(obj);<br>
- res = vm->upcalls->shortClass->doNew(vm);<br>
- vm->upcalls->shortValue->setInstanceInt16Field(res, val);<br>
- } else if (prim->isInt()) {<br>
- sint64 val = stat ? field->getStaticInt32Field() :<br>
- field->getInstanceInt32Field(obj);<br>
- res = vm->upcalls->intClass->doNew(vm);<br>
- vm->upcalls->intValue->setInstanceInt32Field(res, val);<br>
- } else if (prim->isLong()) {<br>
- sint64 val = stat ? field->getStaticLongField() :<br>
- field->getInstanceLongField(obj);<br>
- res = vm->upcalls->longClass->doNew(vm);<br>
- vm->upcalls->longValue->setInstanceLongField(res, val);<br>
- } else if (prim->isFloat()) {<br>
- float val = stat ? field->getStaticFloatField() :<br>
- field->getInstanceFloatField(obj);<br>
- res = vm->upcalls->floatClass->doNew(vm);<br>
- vm->upcalls->floatValue->setInstanceFloatField(res, val);<br>
- } else if (prim->isDouble()) {<br>
- double val = stat ? field->getStaticDoubleField() :<br>
- field->getInstanceDoubleField(obj);<br>
- res = vm->upcalls->doubleClass->doNew(vm);<br>
- vm->upcalls->doubleValue->setInstanceDoubleField(res, val);<br>
- }<br>
- } else {<br>
- if (stat) {<br>
- res = field->getStaticObjectField();<br>
- } else {<br>
- res = field->getInstanceObjectField(obj);<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_set(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, JavaObject* val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(val, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- jvalue buf;<br>
- bool stat = isStatic(field->access);<br>
-<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- JavaObject::decapsulePrimitive(val, vm, &buf, type);<br>
-<br>
-<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isBool()) {<br>
- if (stat) {<br>
- field->setStaticInt8Field(buf.z);<br>
- } else {<br>
- field->setInstanceInt8Field(obj, buf.z);<br>
- }<br>
- } else if (prim->isByte()) {<br>
- if (stat) {<br>
- field->setStaticInt8Field(buf.b);<br>
- } else {<br>
- field->setInstanceInt8Field(obj, buf.b);<br>
- }<br>
- } else if (prim->isChar()) {<br>
- if (stat) {<br>
- field->setStaticInt16Field(buf.c);<br>
- } else {<br>
- field->setInstanceInt16Field(obj, buf.c);<br>
- }<br>
- } else if (prim->isShort()) {<br>
- if (stat) {<br>
- field->setStaticInt16Field(buf.s);<br>
- } else {<br>
- field->setInstanceInt16Field(obj, buf.s);<br>
- }<br>
- } else if (prim->isInt()) {<br>
- if (stat) {<br>
- field->setStaticInt32Field(buf.i);<br>
- } else {<br>
- field->setInstanceInt32Field(obj, buf.i);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- field->setStaticLongField(buf.j);<br>
- } else {<br>
- field->setInstanceLongField(obj, buf.j);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField(buf.f);<br>
- } else {<br>
- field->setInstanceFloatField(obj, buf.f);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField(buf.d);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, buf.d);<br>
- }<br>
- }<br>
- } else {<br>
- if (stat) {<br>
- field->setStaticObjectField(val);<br>
- } else {<br>
- field->setInstanceObjectField(obj, val);<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setBoolean(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jboolean val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isBool()) {<br>
- if (stat) {<br>
- field->setStaticInt8Field((uint8)val);<br>
- } else {<br>
- field->setInstanceInt8Field(obj, (uint8)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setByte(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jbyte val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isByte()) {<br>
- if (stat) {<br>
- field->setStaticInt8Field((sint8)val);<br>
- } else {<br>
- field->setInstanceInt8Field(obj, (sint8)val);<br>
- }<br>
- } else if (prim->isShort()) {<br>
- if (stat) {<br>
- field->setStaticInt16Field((sint16)val);<br>
- } else {<br>
- field->setInstanceInt16Field(obj, (sint16)val);<br>
- }<br>
- } else if (prim->isInt()) {<br>
- if (stat) {<br>
- field->setStaticInt32Field((sint32)val);<br>
- } else {<br>
- field->setInstanceInt32Field(obj, (sint32)val);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- field->setStaticLongField((sint64)val);<br>
- } else {<br>
- field->setInstanceLongField(obj, (sint64)val);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField((float)val);<br>
- } else {<br>
- field->setInstanceFloatField(obj, (float)val);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setChar(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jchar val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isChar()) {<br>
- if (stat) {<br>
- field->setStaticInt16Field((uint16)val);<br>
- } else {<br>
- field->setInstanceInt16Field(obj, (uint16)val);<br>
- }<br>
- } else if (prim->isInt()) {<br>
- if (stat) {<br>
- field->setStaticInt32Field((uint32)val);<br>
- } else {<br>
- field->setInstanceInt32Field(obj, (uint32)val);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- field->setStaticLongField((uint64)val);<br>
- } else {<br>
- field->setInstanceLongField(obj, (uint64)val);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField((float)(uint32)val);<br>
- } else {<br>
- field->setInstanceFloatField(obj, (float)(uint32)val);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)(uint64)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)(uint64)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setShort(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jshort val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isShort()) {<br>
- if (stat) {<br>
- field->setStaticInt16Field((sint16)val);<br>
- } else {<br>
- field->setInstanceInt16Field(obj, (sint16)val);<br>
- }<br>
- } else if (prim->isInt()) {<br>
- if (stat) {<br>
- field->setStaticInt32Field((sint32)val);<br>
- } else {<br>
- field->setInstanceInt32Field(obj, (sint32)val);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- field->setStaticLongField((sint64)val);<br>
- } else {<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField((float)val);<br>
- } else {<br>
- field->setInstanceFloatField(obj, (float)val);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setInt(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jint val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isInt()) {<br>
- if (stat) {<br>
- field->setStaticInt32Field((sint32)val);<br>
- } else {<br>
- field->setInstanceInt32Field(obj, (sint32)val);<br>
- }<br>
- } else if (prim->isLong()) {<br>
- if (stat) {<br>
- field->setStaticLongField((sint64)val);<br>
- } else {<br>
- field->setInstanceLongField(obj, (sint64)val);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField((float)val);<br>
- } else {<br>
- field->setInstanceFloatField(obj, (float)val);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setLong(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jlong val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isLong()) {<br>
- if (stat) {<br>
- field->setStaticLongField((sint64)val);<br>
- } else {<br>
- field->setInstanceLongField(obj, (sint64)val);<br>
- }<br>
- } else if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField((float)val);<br>
- } else {<br>
- field->setInstanceFloatField(obj, (float)val);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setFloat(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jfloat val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isFloat()) {<br>
- if (stat) {<br>
- field->setStaticFloatField((float)val);<br>
- } else {<br>
- field->setInstanceFloatField(obj, (float)val);<br>
- }<br>
- } else if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_reflect_Field_setDouble(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectField* Field, JavaObject* obj, jdouble val) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = JavaObjectField::getClass(Field);<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- bool stat = isStatic(field->access);<br>
-<br>
- if (stat) {<br>
- cl->initialiseClass(vm);<br>
- } else {<br>
- verifyNull(obj);<br>
- }<br>
-<br>
- const Typedef* type = field->getSignature();<br>
- if (type->isPrimitive()) {<br>
- const PrimitiveTypedef* prim = (const PrimitiveTypedef*)type;<br>
- if (prim->isDouble()) {<br>
- if (stat) {<br>
- field->setStaticDoubleField((double)val);<br>
- } else {<br>
- field->setInstanceDoubleField(obj, (double)val);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong type");<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-// Never throws.<br>
-JNIEXPORT jlong JNICALL Java_sun_misc_Unsafe_objectFieldOffset(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* Unsafe, JavaObjectField* Field) {<br>
-<br>
- llvm_gcroot(Field, 0);<br>
- llvm_gcroot(Unsafe, 0);<br>
-<br>
- JavaField* field = JavaObjectField::getInternalField(Field);<br>
- return (jlong)field->ptrOffset;<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathMethod.inc<br>
b/lib/J3/Classpath/ClasspathMethod.inc<br>
deleted file mode 100644<br>
index ee5792d..0000000<br>
--- a/lib/J3/Classpath/ClasspathMethod.inc<br>
+++ /dev/null<br>
@@ -1,304 +0,0 @@<br>
-//===- ClasspathMethod.cpp<br>
------------------------------------------------===//<br>
-//===------------- GNU classpath java/lang/reflect/Method<br>
-----------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaTypes.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-#include "JnjvmClassLoader.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JNIEXPORT jint JNICALL Java_java_lang_reflect_Method_getModifiersInternal(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectMethod* Meth) {<br>
-<br>
- jint res = 0;<br>
- llvm_gcroot(Meth, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
- res = meth->access;<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getReturnType(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectMethod* Meth) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(Meth, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- UserClass* cl = JavaObjectMethod::getClass(Meth);<br>
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
- JnjvmClassLoader* loader = cl->classLoader;<br>
- res = meth->getReturnType(loader);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getParameterTypes(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectMethod* Meth) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(Meth, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- UserClass* cl = JavaObjectMethod::getClass(Meth);<br>
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
- JnjvmClassLoader* loader = cl->classLoader;<br>
-<br>
- res = meth->getParameterTypes(loader);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,<br>
- ArrayObject* args, JavaObject* Cl, jint index)<br>
- __attribute__((noinline));<br>
-<br>
-JavaObject* proceedMethod(JavaObjectMethod* Meth, JavaObject* obj,<br>
- ArrayObject* args, JavaObject* Cl, jint index) {<br>
-<br>
- JavaObject* res = 0;<br>
- JavaObject* exc = 0;<br>
-<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Meth, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(args, 0);<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(exc, 0);<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
-<br>
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
-<br>
- sint32 nbArgs = args ? ArrayObject::getSize(args) : 0;<br>
- Signdef* sign = meth->getSignature();<br>
- sint32 size = sign->nbArguments;<br>
-<br>
- mvm::ThreadAllocator allocator;<br>
- jvalue* buf = size ?<br>
- (jvalue*)allocator.Allocate(size * sizeof(jvalue)) : NULL;<br>
-<br>
- if (nbArgs == size) {<br>
- UserCommonClass* _cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- UserClass* cl = (UserClass*)_cl;<br>
-<br>
- if (isVirtual(meth->access)) {<br>
- verifyNull(obj);<br>
- UserCommonClass* objCl = JavaObject::getClass(obj);<br>
- if (!(objCl->isAssignableFrom(cl))) {<br>
- vm->illegalArgumentException("<this> is not a valid type");<br>
- }<br>
-<br>
- if (isInterface(cl->access)) {<br>
- cl->initialiseClass(vm);<br>
- UserClass* methodCl = 0;<br>
- UserClass* lookup = objCl->isArray() ? objCl->super : objCl->asClass();<br>
- meth = lookup->lookupMethod(meth->name, meth->type, false, true,<br>
- &methodCl);<br>
- }<br>
- } else {<br>
- cl->initialiseClass(vm);<br>
- }<br>
-<br>
- JavaObject** ptr = ArrayObject::getElements(args);<br>
- Typedef* const* arguments = sign->getArgumentsType();<br>
- for (sint32 i = 0; i < size; ++i) {<br>
- JavaObject::decapsulePrimitive(ptr[i], vm, &buf[i], arguments[i]);<br>
- if (!arguments[i]->isPrimitive()) {<br>
- buf[i].l = reinterpret_cast<jobject>(&ptr[i]);<br>
- }<br>
- }<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
-<br>
-#define RUN_METH(TYPE, VAR)<br>
\<br>
- TRY {<br>
\<br>
- if (isVirtual(meth->access)) {<br>
\<br>
- if (isPublic(meth->access) && !isFinal(meth->access) &&<br>
\<br>
- !isFinal(meth->classDef->access)) {<br>
\<br>
- VAR = meth->invoke##TYPE##VirtualBuf(vm, cl, obj, buf);<br>
\<br>
- } else {<br>
\<br>
- VAR = meth->invoke##TYPE##SpecialBuf(vm, cl, obj, buf);<br>
\<br>
- }<br>
\<br>
- } else {<br>
\<br>
- VAR = meth->invoke##TYPE##StaticBuf(vm, cl, buf);<br>
\<br>
- }<br>
\<br>
- } CATCH {<br>
\<br>
- exc = th->getJavaException();<br>
\<br>
- } END_CATCH;<br>
\<br>
- if (exc) {<br>
\<br>
- th->clearException();<br>
\<br>
- th->getJVM()->invocationTargetException(exc);<br>
\<br>
- return NULL;<br>
\<br>
- }<br>
-<br>
- Typedef* retType = sign->getReturnType();<br>
- if (retType->isPrimitive()) {<br>
- PrimitiveTypedef* prim = (PrimitiveTypedef*)retType;<br>
- if (prim->isVoid()) {<br>
- res = 0;<br>
- uint32 val = 0;<br>
- RUN_METH(Int, val);<br>
- } else if (prim->isBool()) {<br>
- uint32 val = 0;<br>
- RUN_METH(Int, val);<br>
- res = vm->upcalls->boolClass->doNew(vm);<br>
- vm->upcalls->boolValue->setInstanceInt8Field(res, val);<br>
- } else if (prim->isByte()) {<br>
- uint32 val = 0;<br>
- RUN_METH(Int, val);<br>
- res = vm->upcalls->byteClass->doNew(vm);<br>
- vm->upcalls->byteValue->setInstanceInt8Field(res, val);<br>
- } else if (prim->isChar()) {<br>
- uint32 val = 0;<br>
- RUN_METH(Int, val);<br>
- res = vm->upcalls->charClass->doNew(vm);<br>
- vm->upcalls->charValue->setInstanceInt16Field(res, val);<br>
- } else if (prim->isShort()) {<br>
- uint32 val = 0;<br>
- RUN_METH(Int, val);<br>
- res = vm->upcalls->shortClass->doNew(vm);<br>
- vm->upcalls->shortValue->setInstanceInt16Field(res, val);<br>
- } else if (prim->isInt()) {<br>
- uint32 val = 0;<br>
- RUN_METH(Int, val);<br>
- res = vm->upcalls->intClass->doNew(vm);<br>
- vm->upcalls->intValue->setInstanceInt32Field(res, val);<br>
- } else if (prim->isLong()) {<br>
- sint64 val = 0;<br>
- RUN_METH(Long, val);<br>
- res = vm->upcalls->longClass->doNew(vm);<br>
- vm->upcalls->longValue->setInstanceLongField(res, val);<br>
- } else if (prim->isFloat()) {<br>
- float val = 0;<br>
- RUN_METH(Float, val);<br>
- res = vm->upcalls->floatClass->doNew(vm);<br>
- vm->upcalls->floatValue->setInstanceFloatField(res, val);<br>
- } else if (prim->isDouble()) {<br>
- double val = 0;<br>
- RUN_METH(Double, val);<br>
- res = vm->upcalls->doubleClass->doNew(vm);<br>
- vm->upcalls->doubleValue->setInstanceDoubleField(res, val);<br>
- }<br>
- } else {<br>
- RUN_METH(JavaObject, res);<br>
- }<br>
- } else {<br>
- vm->illegalArgumentException("wrong number of arguments");<br>
- return NULL;<br>
- }<br>
-<br>
- return res;<br>
-}<br>
-<br>
-#undef RUN_METH<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_invokeNative(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectMethod* Meth, JavaObject* obj, ArrayObject* args,<br>
JavaObject* Cl, jint index) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Meth, 0);<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(args, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- res = proceedMethod(Meth, obj, args, Cl, index);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT ArrayObject* JNICALL Java_java_lang_reflect_Method_getExceptionTypes(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectMethod* Meth) {<br>
-<br>
- ArrayObject* res = 0;<br>
- llvm_gcroot(Meth, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(Meth);<br>
- UserClass* cl = JavaObjectMethod::getClass(Meth);<br>
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
- JnjvmClassLoader* loader = cl->classLoader;<br>
- res = meth->getExceptionTypes(loader);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_reflect_Method_getSignature(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObjectMethod* Meth) {<br>
-<br>
- JavaObject* result = 0;<br>
- llvm_gcroot(Meth, 0);<br>
- llvm_gcroot(result, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(Meth);<br>
- JavaMethod* meth = JavaObjectMethod::getInternalMethod(Meth);<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- result = vm->internalUTF8ToStr(meth->type);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return result;<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathReflect.cpp<br>
b/lib/J3/Classpath/ClasspathReflect.cpp<br>
deleted file mode 100644<br>
index 90bd617..0000000<br>
--- a/lib/J3/Classpath/ClasspathReflect.cpp<br>
+++ /dev/null<br>
@@ -1,30 +0,0 @@<br>
-//===- ClasspathReflect.cpp - Internal representation of core system<br>
classes -//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-<br>
-namespace j3 {<br>
-<br>
-JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*<br>
self) {<br>
- llvm_gcroot(self, 0);<br>
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
- return &(cls->asClass()->virtualMethods[self->slot]);<br>
-}<br>
-<br>
-<br>
-JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {<br>
- llvm_gcroot(self, 0);<br>
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
- return &(cls->asClass()->virtualMethods[self->slot]);<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathReflect.h<br>
b/lib/J3/Classpath/ClasspathReflect.h<br>
deleted file mode 100644<br>
index d847b98..0000000<br>
--- a/lib/J3/Classpath/ClasspathReflect.h<br>
+++ /dev/null<br>
@@ -1,222 +0,0 @@<br>
-//===-- ClasspathReflect.h - Internal representation of core system<br>
classes --//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#ifndef JNJVM_CLASSPATH_REFLECT_H<br>
-#define JNJVM_CLASSPATH_REFLECT_H<br>
-<br>
-#include "MvmGC.h"<br>
-<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-<br>
-extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);<br>
-<br>
-namespace j3 {<br>
-<br>
-class JavaObjectClass : public JavaObject {<br>
-private:<br>
- JavaObject* signers;<br>
- JavaObject* pd;<br>
- UserCommonClass* vmdata;<br>
- JavaObject* constructor;<br>
-<br>
-public:<br>
-<br>
- static UserCommonClass* getClass(JavaObjectClass* cl) {<br>
- llvm_gcroot(cl, 0);<br>
- return cl->vmdata;<br>
- }<br>
-<br>
- static void setClass(JavaObjectClass* cl, UserCommonClass* vmdata) {<br>
- llvm_gcroot(cl, 0);<br>
- cl->vmdata = vmdata;<br>
- }<br>
-<br>
- static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {<br>
- llvm_gcroot(cl, 0);<br>
- llvm_gcroot(pd, 0);<br>
- mvm::Collector::objectReferenceWriteBarrier(<br>
- (gc*)cl, (gc**)&(cl->pd), (gc*)pd);<br>
- }<br>
-<br>
- static JavaObject* getProtectionDomain(JavaObjectClass* cl) {<br>
- llvm_gcroot(cl, 0);<br>
- return cl->pd;<br>
- }<br>
-<br>
- static void staticTracer(JavaObjectClass* obj, word_t closure) {<br>
- mvm::Collector::markAndTrace(obj, &obj->pd, closure);<br>
- mvm::Collector::markAndTrace(obj, &obj->signers, closure);<br>
- mvm::Collector::markAndTrace(obj, &obj->constructor, closure);<br>
- if (obj->vmdata) {<br>
- JavaObject** Obj = obj->vmdata->classLoader->getJavaClassLoaderPtr();<br>
- if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);<br>
- }<br>
- }<br>
-};<br>
-<br>
-class JavaObjectField : public JavaObject {<br>
-private:<br>
- uint8 flag;<br>
- JavaObjectClass* declaringClass;<br>
- JavaObject* name;<br>
- uint32 slot;<br>
-<br>
-public:<br>
-<br>
- static void staticTracer(JavaObjectField* obj, word_t closure) {<br>
- mvm::Collector::markAndTrace(obj, &obj->name, closure);<br>
- mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);<br>
- }<br>
-<br>
- static JavaField* getInternalField(JavaObjectField* self) {<br>
- llvm_gcroot(self, 0);<br>
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
- return &(cls->asClass()->virtualFields[self->slot]);<br>
- }<br>
-<br>
- static UserClass* getClass(JavaObjectField* self) {<br>
- llvm_gcroot(self, 0);<br>
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
- return cls->asClass();<br>
- }<br>
-<br>
-};<br>
-<br>
-class JavaObjectMethod : public JavaObject {<br>
-private:<br>
- uint8 flag;<br>
- JavaObjectClass* declaringClass;<br>
- JavaObject* name;<br>
- uint32 slot;<br>
-<br>
-public:<br>
-<br>
- static void staticTracer(JavaObjectMethod* obj, word_t closure) {<br>
- mvm::Collector::markAndTrace(obj, &obj->name, closure);<br>
- mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);<br>
- }<br>
-<br>
- static JavaMethod* getInternalMethod(JavaObjectMethod* self);<br>
-<br>
- static UserClass* getClass(JavaObjectMethod* self) {<br>
- llvm_gcroot(self, 0);<br>
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
- return cls->asClass();<br>
- }<br>
-<br>
-};<br>
-<br>
-class JavaObjectConstructor : public JavaObject {<br>
-private:<br>
- uint8 flag;<br>
- JavaObjectClass* declaringClass;<br>
- uint32 slot;<br>
-<br>
-public:<br>
- static void staticTracer(JavaObjectConstructor* obj, word_t closure) {<br>
- mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);<br>
- }<br>
-<br>
- static JavaMethod* getInternalMethod(JavaObjectConstructor* self);<br>
-<br>
- static UserClass* getClass(JavaObjectConstructor* self) {<br>
- llvm_gcroot(self, 0);<br>
- UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);<br>
- return cls->asClass();<br>
- }<br>
-<br>
-};<br>
-<br>
-class JavaObjectVMThread : public JavaObject {<br>
-private:<br>
- JavaObject* thread;<br>
- bool running;<br>
- JavaThread* vmdata;<br>
-<br>
-public:<br>
- static void staticTracer(JavaObjectVMThread* obj, word_t closure) {<br>
- mvm::Collector::markAndTrace(obj, &obj->thread, closure);<br>
- }<br>
-<br>
- static void setVmdata(JavaObjectVMThread* vmthread,<br>
- JavaThread* internal_thread) {<br>
- llvm_gcroot(vmthread, 0);<br>
- vmthread->vmdata = internal_thread;<br>
- }<br>
-<br>
-};<br>
-<br>
-<br>
-class JavaObjectThrowable : public JavaObject {<br>
-private:<br>
- JavaObject* detailedMessage;<br>
- JavaObject* cause;<br>
- JavaObject* stackTrace;<br>
- JavaObject* vmState;<br>
-<br>
-public:<br>
-<br>
- static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {<br>
- llvm_gcroot(self, 0);<br>
- llvm_gcroot(obj, 0);<br>
- mvm::Collector::objectReferenceWriteBarrier(<br>
- (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);<br>
- }<br>
-<br>
- static void fillInStackTrace(JavaObjectThrowable* self) {<br>
- JavaObject* stackTrace = NULL;<br>
- llvm_gcroot(self, 0);<br>
- llvm_gcroot(stackTrace, 0);<br>
-<br>
- stackTrace = internalFillInStackTrace(self);<br>
- mvm::Collector::objectReferenceWriteBarrier(<br>
- (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);<br>
-<br>
- mvm::Collector::objectReferenceWriteBarrier(<br>
- (gc*)self, (gc**)&(self->cause), (gc*)self);<br>
-<br>
- self->stackTrace = NULL;<br>
- }<br>
-};<br>
-<br>
-class JavaObjectReference : public JavaObject {<br>
-private:<br>
- JavaObject* referent;<br>
- JavaObject* queue;<br>
- JavaObject* nextOnQueue;<br>
-<br>
-public:<br>
- static void init(JavaObjectReference* self, JavaObject* r, JavaObject* q) {<br>
- llvm_gcroot(self, 0);<br>
- llvm_gcroot(r, 0);<br>
- llvm_gcroot(q, 0);<br>
- mvm::Collector::objectReferenceWriteBarrier(<br>
- (gc*)self, (gc**)&(self->referent), (gc*)r);<br>
- mvm::Collector::objectReferenceWriteBarrier(<br>
- (gc*)self, (gc**)&(self->queue), (gc*)q);<br>
- }<br>
-<br>
- static JavaObject** getReferentPtr(JavaObjectReference* self) {<br>
- llvm_gcroot(self, 0);<br>
- return &(self->referent);<br>
- }<br>
-<br>
- static void setReferent(JavaObjectReference* self, JavaObject* r) {<br>
- llvm_gcroot(self, 0);<br>
- llvm_gcroot(r, 0);<br>
- // No write barrier: this is only called by the GC.<br>
- self->referent = r;<br>
- }<br>
-};<br>
-<br>
-}<br>
-<br>
-#endif<br>
diff --git a/lib/J3/Classpath/ClasspathVMClass.inc<br>
b/lib/J3/Classpath/ClasspathVMClass.inc<br>
deleted file mode 100644<br>
index 616f1b4..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMClass.inc<br>
+++ /dev/null<br>
@@ -1,645 +0,0 @@<br>
-//===---- ClasspathVMClass.cpp - GNU classpath java/lang/VMClass<br>
----------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaAccess.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaString.h"<br>
-#include "JavaTypes.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-// Never throws<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isArray(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObjectClass* klass) {<br>
-<br>
- llvm_gcroot(klass, 0);<br>
-<br>
- UserCommonClass* cl = JavaObjectClass::getClass(klass);<br>
-<br>
- return cl->isArray();<br>
-<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_forName(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaString* str,<br>
-jboolean clinit,<br>
-JavaObject* loader) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(loader, 0);<br>
- llvm_gcroot(str, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(str);<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JnjvmClassLoader* JCL =<br>
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);<br>
- UserCommonClass* cl = JCL->loadClassFromJavaString(str, true, false);<br>
-<br>
- if (cl != NULL && !cl->isPrimitive()) {<br>
- if (clinit && cl->asClass()) {<br>
- cl->asClass()->initialiseClass(vm);<br>
- }<br>
- res = cl->getClassDelegatee(vm);<br>
- } else {<br>
- vm->classNotFoundException(str);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredConstructors(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl,<br>
-jboolean publicOnly) {<br>
-<br>
- ArrayObject* ret = 0;<br>
- JavaObject* tmp = 0;<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(ret, 0);<br>
- llvm_gcroot(tmp, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- if (cl->isArray() || cl->isInterface() || cl->isPrimitive()) {<br>
- ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(0, vm);<br>
- } else {<br>
- UserClass* realCl = cl->asClass();;<br>
- JnjvmClassLoader* classLoader = cl->classLoader;<br>
- uint32 size = 0;<br>
-<br>
- for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {<br>
- JavaMethod* meth = &realCl->virtualMethods[i];<br>
- bool pub = isPublic(meth->access);<br>
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&<br>
- (!publicOnly || pub)) {<br>
- ++size;<br>
- }<br>
- }<br>
-<br>
- ret = (ArrayObject*)vm->upcalls->constructorArrayClass->doNew(size, vm);<br>
-<br>
- sint32 index = 0;<br>
- for (uint32 i = 0; i < realCl->nbVirtualMethods; ++i) {<br>
- JavaMethod* meth = &realCl->virtualMethods[i];<br>
- bool pub = isPublic(meth->access);<br>
- if (meth->name->equals(classLoader->bootstrapLoader->initName) &&<br>
- (!publicOnly || pub)) {<br>
- UserClass* Cons = vm->upcalls->newConstructor;<br>
- tmp = Cons->doNew(vm);<br>
- vm->upcalls->initConstructor->invokeIntSpecial(vm, Cons, tmp, &Cl, i);<br>
- ArrayObject::setElement(ret, tmp, index);<br>
- index++;<br>
- }<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return ret;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredMethods(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl,<br>
-jboolean publicOnly) {<br>
-<br>
- ArrayObject* ret = 0;<br>
- JavaObject* tmp = 0;<br>
- JavaString* str = 0;<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(ret, 0);<br>
- llvm_gcroot(tmp, 0);<br>
- llvm_gcroot(str, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- Classpath* upcalls = vm->upcalls;<br>
-<br>
- if (cl->isArray() || cl->isPrimitive()) {<br>
- ret = (ArrayObject*)upcalls->methodArrayClass->doNew(0, vm);<br>
- } else {<br>
- UserClass* realCl = cl->asClass();<br>
- JnjvmClassLoader* classLoader = cl->classLoader;<br>
- uint32 size = 0;<br>
-<br>
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;<br>
- ++i) {<br>
- JavaMethod* meth = &realCl->virtualMethods[i];<br>
- bool pub = isPublic(meth->access);<br>
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&<br>
- !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&<br>
- (!publicOnly || pub)) {<br>
- ++size;<br>
- }<br>
- }<br>
-<br>
-<br>
- ret = (ArrayObject*)upcalls->methodArrayClass->doNew(size, vm);<br>
-<br>
- sint32 index = 0;<br>
- for (uint32 i = 0; i < realCl->nbVirtualMethods + realCl->nbStaticMethods;<br>
- ++i) {<br>
- JavaMethod* meth = &realCl->virtualMethods[i];<br>
- bool pub = isPublic(meth->access);<br>
- if (!(meth->name->equals(classLoader->bootstrapLoader->initName)) &&<br>
- !(meth->name->equals(classLoader->bootstrapLoader->clinitName)) &&<br>
- (!publicOnly || pub)) {<br>
- // TODO: check parameter types<br>
- UserClass* Meth = vm->upcalls->newMethod;<br>
- tmp = Meth->doNew(vm);<br>
- str = vm->internalUTF8ToStr(meth->name);<br>
- upcalls->initMethod->invokeIntSpecial(vm, Meth, tmp, &Cl, &str, i);<br>
- ArrayObject::setElement(ret, tmp, index);<br>
- index++;<br>
- }<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return ret;<br>
-}<br>
-<br>
-JNIEXPORT jint JNICALL Java_java_lang_VMClass_getModifiers(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl,<br>
-jboolean ignore) {<br>
-<br>
- jint res = 0;<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- res = cl->getAccess();<br>
-<br>
- if (isEnum(res) && cl->getSuper() != vm->upcalls->EnumClass) {<br>
- // javac may put that flag to inner classes of enum classes.<br>
- res &= ~ACC_ENUM;<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getName(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- JavaObject* result = 0;<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(result, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- const UTF8* iname = cl->getName();<br>
- result = JavaString::internalToJava(iname, vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return result;<br>
-}<br>
-<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isPrimitive(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- jboolean res = 0;<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- res = cl->isPrimitive();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isInterface(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- jboolean res = 0;<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- res = cl->isInterface();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getComponentType(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- if (cl->isArray()) {<br>
- UserCommonClass* bc = cl->asArrayClass()->baseClass();<br>
- res = bc->getClassDelegatee(vm);<br>
- } else {<br>
- res = 0;<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getClassLoader(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- res = cl->classLoader->getJavaClassLoader();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_VMClass_isAssignableFrom(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl1, JavaObject* Cl2) {<br>
-<br>
- jboolean res = 0;<br>
- llvm_gcroot(Cl1, 0);<br>
- llvm_gcroot(Cl2, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- if (!Cl2) vm->nullPointerException();<br>
-<br>
- UserCommonClass* cl1 = UserCommonClass::resolvedImplClass(vm, Cl1, false);<br>
- UserCommonClass* cl2 = UserCommonClass::resolvedImplClass(vm, Cl2, false);<br>
-<br>
- res = cl2->isAssignableFrom(cl1);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getSuperclass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- if (cl->isInterface()) res = 0;<br>
- else {<br>
- if (cl->getSuper()) res = cl->getSuper()->getClassDelegatee(vm);<br>
- else res = 0;<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT bool JNICALL Java_java_lang_VMClass_isInstance(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl, JavaObject* obj) {<br>
-<br>
- bool res = false;<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- res = JavaObject::instanceOf(obj, cl);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredFields(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl, jboolean publicOnly) {<br>
-<br>
- ArrayObject* ret = 0;<br>
- JavaObject* tmp = 0;<br>
- JavaString* name = 0;<br>
- llvm_gcroot(Cl, 0);<br>
- llvm_gcroot(ret, 0);<br>
- llvm_gcroot(tmp, 0);<br>
- llvm_gcroot(name, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- if (!cl->isClass()) {<br>
- ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(0, vm);<br>
- } else {<br>
- UserClass* realCl = cl->asClass();<br>
- uint32 size = 0;<br>
- for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;<br>
- ++i) {<br>
- JavaField* field = &realCl->virtualFields[i];<br>
- if (!publicOnly || isPublic(field->access)) {<br>
- ++size;<br>
- }<br>
- }<br>
-<br>
-<br>
- ret = (ArrayObject*)vm->upcalls->fieldArrayClass->doNew(size, vm);<br>
-<br>
- sint32 index = 0;<br>
- for (uint32 i = 0; i < realCl->nbVirtualFields + realCl->nbStaticFields;<br>
- ++i) {<br>
- JavaField* field = &realCl->virtualFields[i];<br>
- if (!publicOnly || isPublic(field->access)) {<br>
- // TODO: check parameter types<br>
- UserClass* Field = vm->upcalls->newField;<br>
- tmp = Field->doNew(vm);<br>
- name = vm->internalUTF8ToStr(field->name);<br>
- vm->upcalls->initField->invokeIntSpecial(vm, Field, tmp, &Cl,<br>
&name, i);<br>
- ArrayObject::setElement(ret, tmp, index);<br>
- index++;<br>
- }<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return ret;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getInterfaces(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- ArrayObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- res = (ArrayObject*)vm->upcalls->classArrayClass->doNew(cl->nbInterfaces,<br>
vm);<br>
-<br>
- for (uint16 i = 0; i < cl->nbInterfaces; ++i) {<br>
- UserClass* klass = cl->interfaces[i];<br>
- ArrayObject::setElement(res, klass->getClassDelegatee(vm), i);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaringClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
- JavaObject* res = 0;<br>
-<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();<br>
-<br>
- if (cl) {<br>
- cl->resolveInnerOuterClasses();<br>
- UserClass* outer = cl->getOuterClass();<br>
- if (outer) {<br>
- res = outer->getClassDelegatee(vm);<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClass_getDeclaredClasses(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl, bool publicOnly) {<br>
-<br>
- ArrayObject* result = 0;<br>
- llvm_gcroot(result, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();<br>
- if (cl) {<br>
- cl->resolveInnerOuterClasses();<br>
- UserClassArray* array = vm->upcalls->constructorArrayClass;<br>
-<br>
- uint16 sizeArray = 0;<br>
-<br>
- if (publicOnly) {<br>
- for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {<br>
- UserClass* klass = cl->innerClasses[i];<br>
- if (isPublic(klass->innerAccess)) ++sizeArray;<br>
- }<br>
- } else {<br>
- sizeArray = cl->nbInnerClasses;<br>
- }<br>
-<br>
- result = (ArrayObject*)array->doNew(sizeArray, vm);<br>
- int index = 0;<br>
- for (uint16 i = 0; i < cl->nbInnerClasses; ++i) {<br>
- UserClass* klass = cl->innerClasses[i];<br>
- if (!publicOnly || isPublic(klass->innerAccess))<br>
- ArrayObject::setElement(result, klass->getClassDelegatee(vm),<br>
index++);<br>
- }<br>
- assert(index == sizeArray);<br>
- }<br>
-<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return result;<br>
-<br>
-}<br>
-<br>
-// Only throws.<br>
-JNIEXPORT void JNICALL Java_java_lang_VMClass_throwException(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* throwable) {<br>
-<br>
- llvm_gcroot(throwable, 0);<br>
-<br>
- assert(throwable && "Using internal VM throw exception without exception");<br>
- JavaThread::get()->pendingException = (JavaObject*)throwable;<br>
-}<br>
-<br>
-JNIEXPORT ArrayObject* Java_java_lang_VMClass_getDeclaredAnnotations(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
- // TODO implement me<br>
-<br>
- ArrayObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClassArray* array = vm->upcalls->constructorArrayAnnotation;<br>
- res = (ArrayObject*)array->doNew(0, vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT jboolean Java_java_lang_VMClass_isAnonymousClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- jboolean res = false;<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false)->asClass();<br>
-<br>
- if (cl) res = cl->isAnonymous;<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMClassLoader.inc<br>
b/lib/J3/Classpath/ClasspathVMClassLoader.inc<br>
deleted file mode 100644<br>
index 55a76d0..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMClassLoader.inc<br>
+++ /dev/null<br>
@@ -1,380 +0,0 @@<br>
-//===- ClasspathVMClassLoader.cpp - GNU classpath<br>
java/lang/VMClassLoader -===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaString.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-#include "Reader.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_getPrimitiveClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-jchar byteId) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClassPrimitive* prim =<br>
- UserClassPrimitive::byteIdToPrimitive(byteId, vm->upcalls);<br>
-<br>
- if (!prim) {<br>
- fprintf(stderr, "unknown byte primitive %c", byteId);<br>
- abort();<br>
- }<br>
-<br>
- res = prim->getClassDelegatee(vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_findLoadedClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* loader,<br>
-JavaString* name) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(loader, 0);<br>
- llvm_gcroot(name, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JnjvmClassLoader* JCL =<br>
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);<br>
- UserCommonClass* cl = JCL->lookupClassFromJavaString(name);<br>
-<br>
- if (cl) res = cl->getClassDelegatee(vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
- return 0;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_loadClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaString* str,<br>
-jboolean doResolve) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(str, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
-<br>
- JnjvmClassLoader* JCL = vm->bootstrapLoader;<br>
- UserCommonClass* cl = JCL->loadClassFromJavaString(str, doResolve, false);<br>
-<br>
- if (cl != 0) res = cl->getClassDelegatee(vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMClassLoader_defineClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* loader,<br>
-JavaString* str,<br>
-ArrayUInt8* bytes,<br>
-jint off,<br>
-jint len,<br>
-JavaObject* pd) {<br>
-<br>
- JavaObject* res = 0;<br>
- JavaObject* excp = 0;<br>
- llvm_gcroot(loader, 0);<br>
- llvm_gcroot(str, 0);<br>
- llvm_gcroot(bytes, 0);<br>
- llvm_gcroot(pd, 0);<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(excp, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- // We need a name, which is unfortunately not required by the spec.<br>
- verifyNull(str);<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
-<br>
- JnjvmClassLoader* JCL =<br>
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject(loader, vm);<br>
-<br>
- int32_t size = JavaArray::getSize(bytes);<br>
- ClassBytes* classBytes = new (JCL->allocator, size) ClassBytes(size);<br>
- memcpy(classBytes->elements, JavaArray::getElements(bytes), size);<br>
-<br>
- // Before creating a class, do a check on the bytes.<br>
- Reader reader(classBytes);<br>
- uint32 magic = reader.readU4();<br>
- if (magic != Jnjvm::Magic) {<br>
- JavaThread::get()->getJVM()->classFormatError("bad magic number");<br>
- }<br>
-<br>
-<br>
- const UTF8* name = JavaString::javaToInternal(str, JCL->hashUTF8);<br>
- UserCommonClass* cl = JCL->lookupClass(name);<br>
-<br>
- if (!cl) {<br>
- UserClass* cl = JCL->constructClass(name, classBytes);<br>
- cl->resolveClass();<br>
-<br>
- res = cl->getClassDelegatee(vm, pd);<br>
- } else {<br>
- excp = vm->CreateLinkageError("duplicate class definition");<br>
- JavaThread::get()->throwException(excp);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMClassLoader_resolveClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- verifyNull(Cl);<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-#define NUM_BOOT_PACKAGES 168<br>
-<br>
-static const char* bootPackages[NUM_BOOT_PACKAGES] = {<br>
- "java.applet",<br>
- "java.awt",<br>
- "java.awt.color",<br>
- "java.awt.datatransfer",<br>
- "java.awt.dnd",<br>
- "java.awt.dnd.peer",<br>
- "java.awt.event",<br>
- "java.awt.font",<br>
- "java.awt.geom",<br>
- "<a href="http://java.awt.im" target="_blank">java.awt.im</a>",<br>
- "java.awt.im.spi",<br>
- "java.awt.image",<br>
- "java.awt.image.renderable",<br>
- "java.awt.peer",<br>
- "java.awt.print",<br>
- "java.beans",<br>
- "java.beans.beancontext",<br>
- "<a href="http://java.io" target="_blank">java.io</a>",<br>
- "java.lang",<br>
- "java.lang.annotation",<br>
- "java.lang.instrument",<br>
- "java.lang.management",<br>
- "java.lang.ref",<br>
- "java.lang.reflect",<br>
- "java.math",<br>
- "<a href="http://java.net" target="_blank">java.net</a>",<br>
- "java.nio",<br>
- "java.nio.channels",<br>
- "java.nio.channels.spi",<br>
- "java.nio.charset",<br>
- "java.nio.charset.spi",<br>
- "java.rmi",<br>
- "java.rmi.activation",<br>
- "java.rmi.dgc",<br>
- "java.rmi.registry",<br>
- "java.rmi.server",<br>
- "java.security",<br>
- "java.security.acl",<br>
- "java.security.cert",<br>
- "java.security.interfaces",<br>
- "java.security.spec",<br>
- "java.sql",<br>
- "java.text",<br>
- "java.util",<br>
- "java.util.concurrent",<br>
- "java.util.concurrent.atomic",<br>
- "java.util.concurrent.locks",<br>
- "java.util.jar",<br>
- "java.util.logging",<br>
- "java.util.prefs",<br>
- "java.util.regex",<br>
- "java.util.zip",<br>
- "javax.accessibility",<br>
- "javax.activity",<br>
- "javax.crypto",<br>
- "javax.crypto.interfaces",<br>
- "javax.crypto.spec",<br>
- "javax.imageio",<br>
- "javax.imageio.event",<br>
- "javax.imageio.metadata",<br>
- "javax.imageio.plugins.bmp",<br>
- "javax.imageio.plugins.jpeg",<br>
- "javax.imageio.spi",<br>
- "javax.imageio.stream",<br>
- "javax.management",<br>
- "javax.management.loading",<br>
- "javax.management.modelmbean",<br>
- "javax.management.monitor",<br>
- "javax.management.openmbean",<br>
- "javax.management.relation",<br>
- "javax.management.remote",<br>
- "javax.management.remote.rmi",<br>
- "javax.management.timer",<br>
- "javax.naming",<br>
- "javax.naming.directory",<br>
- "javax.naming.event",<br>
- "javax.naming.ldap",<br>
- "javax.naming.spi",<br>
- "<a href="http://javax.net" target="_blank">javax.net</a>",<br>
- "javax.net.ssl",<br>
- "javax.print",<br>
- "javax.print.attribute",<br>
- "javax.print.attribute.standard",<br>
- "javax.print.event",<br>
- "javax.rmi",<br>
- "javax.rmi.CORBA",<br>
- "javax.rmi.ssl",<br>
- "javax.security.auth",<br>
- "javax.security.auth.callback",<br>
- "javax.security.auth.kerberos",<br>
- "javax.security.auth.login",<br>
- "javax.security.auth.spi",<br>
- "javax.security.auth.x500",<br>
- "javax.security.cert",<br>
- "javax.security.sasl",<br>
- "javax.sound.midi",<br>
- "javax.sound.midi.spi",<br>
- "javax.sound.sampled",<br>
- "javax.sound.sampled.spi",<br>
- "javax.sql",<br>
- "javax.sql.rowset",<br>
- "javax.sql.rowset.serial",<br>
- "javax.sql.rowset.spi",<br>
- "javax.swing",<br>
- "javax.swing.border",<br>
- "javax.swing.colorchooser",<br>
- "javax.swing.event",<br>
- "javax.swing.filechooser",<br>
- "javax.swing.plaf",<br>
- "javax.swing.plaf.basic",<br>
- "javax.swing.plaf.metal",<br>
- "javax.swing.plaf.multi",<br>
- "javax.swing.plaf.synth",<br>
- "javax.swing.table",<br>
- "javax.swing.text",<br>
- "javax.swing.text.html",<br>
- "javax.swing.text.html.parser",<br>
- "javax.swing.text.rtf",<br>
- "javax.swing.tree",<br>
- "javax.swing.undo",<br>
- "javax.transaction",<br>
- "javax.transaction.xa",<br>
- "javax.xml",<br>
- "javax.xml.datatype",<br>
- "javax.xml.namespace",<br>
- "javax.xml.parsers",<br>
- "javax.xml.transform",<br>
- "javax.xml.transform.dom",<br>
- "javax.xml.transform.sax",<br>
- "javax.xml.transform.stream",<br>
- "javax.xml.validation",<br>
- "javax.xml.xpath",<br>
- "org.ietf.jgss",<br>
- "org.omg.CORBA",<br>
- "org.omg.CORBA_2_3",<br>
- "org.omg.CORBA_2_3.portable",<br>
- "org.omg.CORBA.DynAnyPackage",<br>
- "org.omg.CORBA.ORBPackage",<br>
- "org.omg.CORBA.portable",<br>
- "org.omg.CORBA.TypeCodePackage",<br>
- "org.omg.CosNaming",<br>
- "org.omg.CosNaming.NamingContextExtPackage",<br>
- "org.omg.CosNaming.NamingContextPackage",<br>
- "org.omg.Dynamic",<br>
- "org.omg.DynamicAny",<br>
- "org.omg.DynamicAny.DynAnyFactoryPackage",<br>
- "org.omg.DynamicAny.DynAnyPackage",<br>
- "org.omg.IOP",<br>
- "org.omg.IOP.CodecFactoryPackage",<br>
- "org.omg.IOP.CodecPackage",<br>
- "org.omg.Messaging",<br>
- "org.omg.PortableInterceptor",<br>
- "org.omg.PortableInterceptor.ORBInitInfoPackage",<br>
- "org.omg.PortableServer",<br>
- "org.omg.PortableServer.CurrentPackage",<br>
- "org.omg.PortableServer.POAManagerPackage",<br>
- "org.omg.PortableServer.POAPackage",<br>
- "org.omg.PortableServer.portable",<br>
- "org.omg.PortableServer.ServantLocatorPackage",<br>
- "org.omg.SendingContext",<br>
- "org.omg.stub.java.rmi",<br>
- "org.w3c.dom",<br>
- "org.w3c.dom.bootstrap",<br>
- "org.w3c.dom.events",<br>
- "<a href="http://org.w3c.dom.ls" target="_blank">org.w3c.dom.ls</a>",<br>
- "org.xml.sax",<br>
- "org.xml.sax.ext",<br>
- "org.xml.sax.helpers"<br>
-};<br>
-<br>
-extern "C" ArrayObject* Java_java_lang_VMClassLoader_getBootPackages__() {<br>
- ArrayObject* obj = 0;<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- obj = (ArrayObject*)vm->upcalls->ArrayOfString->doNew(NUM_BOOT_PACKAGES, vm);<br>
- for (uint32 i = 0; i < NUM_BOOT_PACKAGES; ++i) {<br>
- ArrayObject::setElement(obj, vm->asciizToStr(bootPackages[i]), i);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return obj;<br>
-}<br>
-<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMObject.inc<br>
b/lib/J3/Classpath/ClasspathVMObject.inc<br>
deleted file mode 100644<br>
index ab3f0c5..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMObject.inc<br>
+++ /dev/null<br>
@@ -1,170 +0,0 @@<br>
-//===------ ClasspathVMObject.cpp - GNU classpath java/lang/VMObject<br>
------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_clone(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* src) {<br>
-<br>
- JavaObject* res = NULL;<br>
- JavaObject* tmp = NULL;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(src, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- UserCommonClass* cl = JavaObject::getClass(src);<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- if (cl->isArray()) {<br>
- UserClassArray* array = cl->asArrayClass();<br>
- int length = JavaArray::getSize(src);<br>
- res = array->doNew(length, vm);<br>
- UserCommonClass* base = array->baseClass();<br>
- if (base->isPrimitive()) {<br>
- int size = length << base->asPrimitiveClass()->logSize;<br>
- memcpy((void*)((uintptr_t)res + sizeof(JavaObject) + sizeof(size_t)),<br>
- (void*)((uintptr_t)src + sizeof(JavaObject) + sizeof(size_t)),<br>
- size);<br>
- } else {<br>
- for (int i = 0; i < length; i++) {<br>
- tmp = ArrayObject::getElement((ArrayObject*)src, i);<br>
- ArrayObject::setElement((ArrayObject*)res, tmp, i);<br>
- }<br>
- }<br>
- } else {<br>
- assert(cl->isClass() && "Not a class!");<br>
- res = cl->asClass()->doNew(vm);<br>
- while (cl != NULL) {<br>
- for (uint32 i = 0; i < cl->asClass()->nbVirtualFields; ++i) {<br>
- JavaField& field = cl->asClass()->virtualFields[i];<br>
- if (field.isReference()) {<br>
- tmp = field.getInstanceObjectField(src);<br>
- JavaObject** ptr = field.getInstanceObjectFieldPtr(res);<br>
- mvm::Collector::objectReferenceWriteBarrier((gc*)res,<br>
(gc**)ptr, (gc*)tmp);<br>
- } else if (field.isLong()) {<br>
- field.setInstanceLongField(res, field.getInstanceLongField(src));<br>
- } else if (field.isDouble()) {<br>
- field.setInstanceDoubleField(res, field.getInstanceDoubleField(src));<br>
- } else if (field.isInt()) {<br>
- field.setInstanceInt32Field(res, field.getInstanceInt32Field(src));<br>
- } else if (field.isFloat()) {<br>
- field.setInstanceFloatField(res, field.getInstanceFloatField(src));<br>
- } else if (field.isShort() || field.isChar()) {<br>
- field.setInstanceInt16Field(res, field.getInstanceInt16Field(src));<br>
- } else if (field.isByte() || field.isBoolean()) {<br>
- field.setInstanceInt8Field(res, field.getInstanceInt8Field(src));<br>
- } else {<br>
- UNREACHABLE();<br>
- }<br>
- }<br>
- cl = cl->super;<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMObject_getClass(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* obj) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- res = JavaObject::getClass(obj)->getClassDelegatee(vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMObject_notifyAll(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* obj) {<br>
-<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObject::notifyAll(obj);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMObject_wait(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* obj, jlong ms, jint ns) {<br>
-<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- uint32 sec = (uint32) (ms / 1000);<br>
- uint32 usec = (ns / 1000) + 1000 * (ms % 1000);<br>
- if (ns && !usec) usec = 1;<br>
- if (sec || usec) {<br>
- struct timeval t;<br>
- t.tv_sec = sec;<br>
- t.tv_usec = usec;<br>
- JavaObject::timedWait(obj, t);<br>
- } else {<br>
- JavaObject::wait(obj);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMObject_notify(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* obj) {<br>
-<br>
- llvm_gcroot(obj, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObject::notify(obj);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMRuntime.inc<br>
b/lib/J3/Classpath/ClasspathVMRuntime.inc<br>
deleted file mode 100644<br>
index f79daee..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMRuntime.inc<br>
+++ /dev/null<br>
@@ -1,229 +0,0 @@<br>
-//===------ ClasspathVMRuntime.cpp - GNU classpath<br>
java/lang/VMRuntime ----===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-<br>
-#include "MvmGC.h"<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaString.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-#include <cstring><br>
-#include <unistd.h><br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMRuntime_mapLibraryName(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaString* strLib) {<br>
-<br>
- JavaObject* res = 0;<br>
- ArrayUInt16* array = 0;<br>
- const ArrayUInt16* utf8Lib = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(array, 0);<br>
- llvm_gcroot(utf8Lib, 0);<br>
- llvm_gcroot(strLib, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
-<br>
- utf8Lib = JavaString::getValue(strLib);<br>
- uint32 stLib = strLib->offset;<br>
- sint32 lgLib = strLib->count;<br>
- sint32 lgPre = vm->bootstrapLoader->prelib->size;<br>
- sint32 lgPost = vm->bootstrapLoader->postlib->size;<br>
-<br>
- uint32 size = (uint32)(lgPre + lgLib + lgPost);<br>
- array = (ArrayUInt16*)vm->upcalls->ArrayOfChar->doNew(size, vm);<br>
- uint16* elements = ArrayUInt16::getElements(array);<br>
-<br>
- memmove(elements, vm->bootstrapLoader->prelib->elements,<br>
- lgPre * sizeof(uint16));<br>
- memmove(&(elements[lgPre]), ArrayUInt16::getElements(utf8Lib) + stLib,<br>
- lgLib * sizeof(uint16));<br>
- memmove(&(elements[lgPre + lgLib]), vm->bootstrapLoader->postlib->elements,<br>
- lgPost * sizeof(uint16));<br>
-<br>
- res = vm->constructString(array);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-<br>
-}<br>
-<br>
-typedef int (*onLoad_t)(const void**, void*);<br>
-extern "C" void j3EndJNI(uint32** old);<br>
-extern "C" void j3StartJNI(uint32* num, uint32** old, mvm::KnownFrame* Frame);<br>
-<br>
-extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm)<br>
- __attribute__ ((noinline));<br>
-<br>
-extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm)<br>
- __attribute__ ((noinline));<br>
-<br>
-extern "C" int doCall(onLoad_t func, void* res, Jnjvm* vm) {<br>
- func(&vm->javavmEnv, res);<br>
- return 1;<br>
-}<br>
-<br>
-// Calls the JNI_OnLoad function of a dynamic library.<br>
-extern "C" void callOnLoad(void* res, JnjvmClassLoader* loader, Jnjvm* vm) {<br>
-<br>
- onLoad_t onLoad = (onLoad_t)loader->loadInLib("JNI_OnLoad", res);<br>
-<br>
- if (onLoad) {<br>
- uint32 num = 0;<br>
- uint32* old = 0;<br>
- mvm::KnownFrame Frame;<br>
-<br>
- j3StartJNI(&num, &old, &Frame);<br>
- doCall(onLoad, res, vm);<br>
- j3EndJNI(&old);<br>
- }<br>
-}<br>
-<br>
-// Never throws.<br>
-JNIEXPORT jint JNICALL Java_java_lang_VMRuntime_nativeLoad(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaString* str,<br>
-JavaObject* javaLoader) {<br>
-<br>
-<br>
- llvm_gcroot(str, 0);<br>
- llvm_gcroot(javaLoader, 0);<br>
-<br>
- void* res = 0;<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JnjvmClassLoader* loader =<br>
- JnjvmClassLoader::getJnjvmLoaderFromJavaObject(javaLoader, vm);<br>
-<br>
- mvm::ThreadAllocator allocator;<br>
- char* buf = JavaString::strToAsciiz(str, &allocator);<br>
-<br>
- res = loader->loadLib(buf);<br>
-<br>
- if (res) callOnLoad(res, loader, vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res != 0;<br>
-}<br>
-<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMRuntime_gc(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- mvm::Collector::collect();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalization(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- mvm::Collector::collect();<br>
- // Sleep a bit.<br>
- sleep(1);<br>
- return;<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizationForExit(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- return;<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMRuntime_runFinalizersOnExit(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-uint8 value<br>
-) {<br>
- return;<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMRuntime_exit(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-jint par1) {<br>
- mvm::System::Exit(par1);<br>
-}<br>
-<br>
-JNIEXPORT jlong Java_java_lang_VMRuntime_freeMemory(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- return (jlong)mvm::Collector::getFreeMemory();<br>
-}<br>
-<br>
-JNIEXPORT jlong Java_java_lang_VMRuntime_totalMemory(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- return (jlong)mvm::Collector::getTotalMemory();<br>
-}<br>
-<br>
-JNIEXPORT jlong Java_java_lang_VMRuntime_maxMemory(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- return (jlong)mvm::Collector::getMaxMemory();<br>
-}<br>
-<br>
-JNIEXPORT jint Java_java_lang_VMRuntime_availableProcessors(){<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
- return mvm::System::GetNumberOfProcessors();<br>
-}<br>
-}<br>
-<br>
diff --git a/lib/J3/Classpath/ClasspathVMStackWalker.inc<br>
b/lib/J3/Classpath/ClasspathVMStackWalker.inc<br>
deleted file mode 100644<br>
index b0c94e5..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMStackWalker.inc<br>
+++ /dev/null<br>
@@ -1,86 +0,0 @@<br>
-//===- ClasspathVMStackWalker.cpp<br>
-----------------------------------------===//<br>
-//===------------ GNU classpath gnu/classpath/VMStackWalker<br>
---------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_gnu_classpath_VMStackWalker_getClassContext(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
-<br>
- ArrayObject* result = NULL;<br>
- JavaObject* delegatee = NULL;<br>
- llvm_gcroot(result, 0);<br>
- llvm_gcroot(delegatee, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- Jnjvm* vm = th->getJVM();<br>
- uint32 length = th->getFrameContextLength();<br>
-<br>
- mvm::ThreadAllocator allocator;<br>
- uintptr_t* buffer = (uintptr_t*)allocator.Allocate(length *<br>
sizeof(uintptr_t));<br>
-<br>
- uint32 finalSize = th->getJavaFrameContext((void**)buffer);<br>
-<br>
- result = (ArrayObject*)<br>
- vm->upcalls->stackTraceArray->doNew(finalSize, vm);<br>
-<br>
- for (uint32 i = 0; i != finalSize; ++i) {<br>
- JavaMethod* meth = ((JavaMethod**)buffer)[i];<br>
- assert(meth && "Wrong stack trace");<br>
- delegatee = meth->classDef->getClassDelegatee(vm);;<br>
- ArrayObject::setElement(result, delegatee, i);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return result;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_gnu_classpath_VMStackWalker_getClassLoader(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* Cl) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(Cl, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserCommonClass* cl = UserCommonClass::resolvedImplClass(vm, Cl, false);<br>
- res = cl->classLoader->getJavaClassLoader();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMSystem.inc<br>
b/lib/J3/Classpath/ClasspathVMSystem.inc<br>
deleted file mode 100644<br>
index 20a558e..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMSystem.inc<br>
+++ /dev/null<br>
@@ -1,119 +0,0 @@<br>
-//===-- ClasspathVMSystem.cpp - GNU classpath java/lang/VMSystem<br>
----------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMSystem_arraycopy(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass _cl,<br>
-#endif<br>
-JavaObject* src,<br>
-jint sstart,<br>
-JavaObject* dst,<br>
-jint dstart,<br>
-jint len) {<br>
-<br>
- JavaObject* cur = 0;<br>
- llvm_gcroot(src, 0);<br>
- llvm_gcroot(dst, 0);<br>
- llvm_gcroot(cur, 0);<br>
- assert(src->getVirtualTable());<br>
- assert(dst->getVirtualTable());<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- Jnjvm *vm = th->getJVM();<br>
-<br>
- if (src == NULL || dst == NULL) {<br>
- th->pendingException = vm->CreateNullPointerException();<br>
- return;<br>
- }<br>
-<br>
- if (!(JavaObject::getClass(src)->isArray() &&<br>
- JavaObject::getClass(dst)->isArray())) {<br>
- th->pendingException = vm->CreateArrayStoreException(<br>
- (JavaVirtualTable*)dst->getVirtualTable());<br>
- return;<br>
- }<br>
-<br>
- UserClassArray* ts = (UserClassArray*)JavaObject::getClass(src);<br>
- UserClassArray* td = (UserClassArray*)JavaObject::getClass(dst);<br>
- UserCommonClass* dstType = td->baseClass();<br>
- UserCommonClass* srcType = ts->baseClass();<br>
-<br>
- sint32 srcSize = JavaArray::getSize(src);<br>
- sint32 dstSize = JavaArray::getSize(dst);<br>
-<br>
- if (len > srcSize) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(len);<br>
- } else if (len > dstSize) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(len);<br>
- } else if (len + sstart > srcSize) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(len + sstart);<br>
- } else if (len + dstart > dstSize) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(len + dstart);<br>
- } else if (dstart < 0) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(dstart);<br>
- } else if (sstart < 0) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(sstart);<br>
- } else if (len < 0) {<br>
- th->pendingException = vm->CreateIndexOutOfBoundsException(len);<br>
- } else if ((dstType->isPrimitive() || srcType->isPrimitive()) &&<br>
- srcType != dstType) {<br>
- th->pendingException = vm->CreateArrayStoreException(<br>
- (JavaVirtualTable*)dst->getVirtualTable());<br>
- }<br>
- if (th->pendingException != NULL) return;<br>
-<br>
- if (!(dstType->isPrimitive())) {<br>
- for (int i = 0; i < len; i++) {<br>
- cur = ArrayObject::getElement((ArrayObject*)src, i + sstart);<br>
- if (cur) {<br>
- if (!(JavaObject::getClass(cur)->isAssignableFrom(dstType))) {<br>
- th->pendingException = vm->CreateArrayStoreException(<br>
- (JavaVirtualTable*)dst->getVirtualTable());<br>
- break;<br>
- } else {<br>
- ArrayObject::setElement((ArrayObject*)dst, cur, i + dstart);<br>
- }<br>
- }<br>
- }<br>
- } else {<br>
- uint32 logSize = dstType->asPrimitiveClass()->logSize;<br>
- void* ptrDst = (void*)((int64_t)JavaArray::getElements(dst) +<br>
(dstart << logSize));<br>
- void* ptrSrc = (void*)((int64_t)JavaArray::getElements(src) +<br>
(sstart << logSize));<br>
- memmove(ptrDst, ptrSrc, len << logSize);<br>
- }<br>
-<br>
-}<br>
-<br>
-JNIEXPORT jint JNICALL Java_java_lang_VMSystem_identityHashCode(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* obj) {<br>
-<br>
- llvm_gcroot(obj, 0);<br>
- if (obj == NULL) return 0;<br>
- return JavaObject::hashCode(obj);<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMSystemProperties.inc<br>
b/lib/J3/Classpath/ClasspathVMSystemProperties.inc<br>
deleted file mode 100644<br>
index abd9195..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMSystemProperties.inc<br>
+++ /dev/null<br>
@@ -1,154 +0,0 @@<br>
-//===- ClasspathVMSystem/Properties.cpp<br>
-----------------------------------===//<br>
-//===--------------------- GNU classpath<br>
gnu/classpath/VMSystemProperties -===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include <sys/utsname.h><br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-void setProperty(Jnjvm* vm, JavaObject* prop, const char* key,<br>
- const char* val) {<br>
-<br>
- JavaString* Val = 0;<br>
- JavaString* Key = 0;<br>
- llvm_gcroot(prop, 0);<br>
- llvm_gcroot(Val, 0);<br>
- llvm_gcroot(Key, 0);<br>
-<br>
- Val = vm->asciizToStr(val);<br>
- Key = vm->asciizToStr(key);<br>
-<br>
- vm->upcalls->setProperty->invokeIntSpecial(<br>
- vm, (UserClass*)JavaObject::getClass(prop), prop, &Key, &Val);<br>
-}<br>
-<br>
-void setUnameProp(Jnjvm* vm, JavaObject* prop) {<br>
-<br>
- llvm_gcroot(prop, 0);<br>
-<br>
- struct utsname infos;<br>
- uname(&infos);<br>
- setProperty(vm, prop, "<a href="http://os.name" target="_blank">os.name</a>", infos.sysname);<br>
- setProperty(vm, prop, "os.arch", infos.machine);<br>
- setProperty(vm, prop, "os.version", infos.release);<br>
- if (!strcmp(infos.machine, "ppc")) {<br>
- setProperty(vm, prop, "gnu.cpu.endian","big");<br>
- } else {<br>
- setProperty(vm, prop, "gnu.cpu.endian","little");<br>
- }<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_gnu_classpath_VMSystemProperties_preInit(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* prop) {<br>
-<br>
- llvm_gcroot(prop, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- const char* tmp;<br>
- setProperty(vm, prop, "java.vm.specification.version", "1.0");<br>
- setProperty(vm, prop, "java.vm.specification.vendor",<br>
- "Sun Microsystems, Inc");<br>
- setProperty(vm, prop, "<a href="http://java.vm.specification.name" target="_blank">java.vm.specification.name</a>",<br>
- "Java Virtual Machine Specification");<br>
- setProperty(vm, prop, "java.specification.version", "1.5");<br>
- setProperty(vm, prop, "java.specification.vendor", "Sun Microsystems, Inc");<br>
- setProperty(vm, prop, "<a href="http://java.specification.name" target="_blank">java.specification.name</a>",<br>
- "Java Platform API Specification");<br>
- setProperty(vm, prop, "java.version", "1.5");<br>
- setProperty(vm, prop, "java.runtime.version", "1.5");<br>
- setProperty(vm, prop, "java.vendor", "The VMKit Project");<br>
- setProperty(vm, prop, "java.vendor.url", "<a href="http://vmkit.llvm.org" target="_blank">http://vmkit.llvm.org</a>");<br>
-<br>
- tmp = getenv("JAVA_HOME");<br>
- if (!tmp) tmp = "";<br>
- setProperty(vm, prop, "java.home", tmp);<br>
-<br>
- JnjvmBootstrapLoader* JCL = vm->bootstrapLoader;<br>
- setProperty(vm, prop, "java.class.version", "49.0");<br>
- setProperty(vm, prop, "java.class.path", vm->classpath);<br>
- setProperty(vm, prop, "java.boot.class.path", JCL->bootClasspathEnv);<br>
- setProperty(vm, prop, "sun.boot.class.path", JCL->bootClasspathEnv);<br>
- setProperty(vm, prop, "java.vm.version", "0.28");<br>
- setProperty(vm, prop, "java.vm.vendor", "The VMKit Project");<br>
- setProperty(vm, prop, "<a href="http://java.vm.name" target="_blank">java.vm.name</a>", "J3");<br>
- setProperty(vm, prop, "java.specification.version", "1.5");<br>
- setProperty(vm, prop, "java.io.tmpdir", "/tmp");<br>
-<br>
- tmp = getenv("JAVA_COMPILER");<br>
- if (!tmp) tmp = "gcj";<br>
- setProperty(vm, prop, "java.compiler", tmp);<br>
-<br>
- setProperty(vm, prop, "build.compiler", "gcj");<br>
- setProperty(vm, prop, "gcj.class.path", JCL->bootClasspathEnv);<br>
- setProperty(vm, prop, "gnu.classpath.boot.library.path",<br>
- JCL->libClasspathEnv);<br>
-<br>
- setUnameProp(vm, prop);<br>
-<br>
- setProperty(vm, prop, "file.separator", vm->dirSeparator);<br>
- setProperty(vm, prop, "path.separator", vm->envSeparator);<br>
- setProperty(vm, prop, "line.separator", "\n");<br>
-<br>
- tmp = getenv("USERNAME");<br>
- if (!tmp) tmp = getenv("LOGNAME");<br>
- if (!tmp) tmp = getenv("NAME");<br>
- if (!tmp) tmp = "";<br>
- setProperty(vm, prop, "<a href="http://user.name" target="_blank">user.name</a>", tmp);<br>
-<br>
- tmp = getenv("HOME");<br>
- if (!tmp) tmp = "";<br>
- setProperty(vm, prop, "user.home", tmp);<br>
-<br>
- tmp = getenv("PWD");<br>
- if (!tmp) tmp = "";<br>
- setProperty(vm, prop, "user.dir", tmp);<br>
-<br>
- // Disable this property. The Classpath iconv implementation is really<br>
- // not optimized (it over-abuses JNI calls).<br>
- //setProperty(vm, prop, "gnu.classpath.nio.charset.provider.iconv", "true");<br>
- setProperty(vm, prop, "file.encoding", "ISO8859_1");<br>
- setProperty(vm, prop, "gnu.java.util.zoneinfo.dir", "/usr/share/zoneinfo");<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-extern "C" void<br>
Java_gnu_classpath_VMSystemProperties_postInit__Ljava_util_Properties_2(JavaObject*<br>
prop) {<br>
-<br>
- llvm_gcroot(prop, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- for (std::vector<std::pair<char*, char*> >::iterator i =<br>
- vm->postProperties.begin(), e = vm->postProperties.end(); i!= e; i++) {<br>
- setProperty(vm, prop, i->first, i->second);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMThread.inc<br>
b/lib/J3/Classpath/ClasspathVMThread.inc<br>
deleted file mode 100644<br>
index e65e822..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMThread.inc<br>
+++ /dev/null<br>
@@ -1,217 +0,0 @@<br>
-//===- ClasspathVMThread.cpp - GNU classpath java/lang/VMThread<br>
-----------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-// Never throws.<br>
-// Never calls Java code.<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThread_currentThread(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz<br>
-#endif<br>
-) {<br>
- return JavaThread::get()->currentThread();<br>
-}<br>
-<br>
-void start(JavaThread* thread) {<br>
-<br>
- JavaObjectVMThread* vmThread = NULL;<br>
- JavaObject* javaThread = NULL;<br>
- llvm_gcroot(vmThread, 0);<br>
- llvm_gcroot(javaThread, 0);<br>
-<br>
- Jnjvm* vm = thread->getJVM();<br>
- // Wait some time to let the creator initialise these fields.<br>
- while ((thread->javaThread == NULL) || (thread->vmThread == NULL)) {<br>
- mvm::Thread::yield();<br>
- }<br>
-<br>
- // Ok, now that the thread is created we can set the the value of vmdata,<br>
- // which is the JavaThread object.<br>
- vmThread = (JavaObjectVMThread*)thread->vmThread;<br>
- assert(vmThread && "Didn't fix the vmThread of a j3 thread");<br>
- assert(vmThread->getVirtualTable());<br>
- JavaObjectVMThread::setVmdata(vmThread, thread);<br>
-<br>
- UserClass* vmthClass = (UserClass*)JavaObject::getClass(vmThread);<br>
-<br>
- javaThread = thread->javaThread;<br>
- assert(javaThread && "Didn't fix the javaThread of a j3 thread");<br>
- // If the thread is not a daemon, it is added to the list of threads to<br>
- // wait until exit.<br>
- bool isDaemon = vm->upcalls->daemon->getInstanceInt8Field(javaThread);<br>
-<br>
- if (!isDaemon) {<br>
- vm->threadSystem.enter();<br>
- }<br>
-<br>
- assert(vmThread->getVirtualTable());<br>
- assert(javaThread->getVirtualTable());<br>
- // Run the VMThread::run function<br>
- vm->upcalls->runVMThread->invokeIntSpecial(vm, vmthClass, vmThread);<br>
-<br>
- // Remove the thread from the list.<br>
- if (!isDaemon) {<br>
- vm->threadSystem.leave();<br>
- }<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMThread_start(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* vmThread, sint64 stackSize) {<br>
-<br>
- JavaObject* javaThread = 0;<br>
- llvm_gcroot(vmThread, 0);<br>
- llvm_gcroot(javaThread, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
-<br>
- // Classpath has set this field.<br>
- javaThread = vm->upcalls->assocThread->getInstanceObjectField(vmThread);<br>
- assert(javaThread && "VMThread with no Java equivalent");<br>
-<br>
- JavaThread* th = new JavaThread(vm);<br>
- if (!th) vm->outOfMemoryError();<br>
- th->start((void (*)(mvm::Thread*))start);<br>
- // Now that the thread has been created, initialise its object fields.<br>
- th->initialise(javaThread, vmThread);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-JNIEXPORT void JNICALL Java_java_lang_VMThread_interrupt(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* vmthread) {<br>
-<br>
- llvm_gcroot(vmthread, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JavaField* field = vm->upcalls->vmdataVMThread;<br>
-<br>
- // It's possible that the thread to be interrupted has not finished<br>
- // its initialization. Wait until the initialization is done.<br>
- while (field->getInstanceObjectField(vmthread) == 0)<br>
- mvm::Thread::yield();<br>
-<br>
- JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);<br>
- th->lockingThread.interruptFlag = 1;<br>
- mvm::FatLock* lock = th->lockingThread.waitsOn;<br>
-<br>
- // If the thread is blocked on a wait. We also verify nextWaiting in case<br>
- // the thread has been notified.<br>
- if (lock && th->lockingThread.nextWaiting) {<br>
- th->lockingThread.state = mvm::LockingThread::StateInterrupted;<br>
-<br>
- // Make sure the thread is waiting.<br>
- uint32 locked = 0;<br>
- while (true) {<br>
- locked = (lock->tryAcquire() == 0);<br>
- if (locked || (lock->getOwner() != th && lock->getOwner() != 0))<br>
- break;<br>
- else mvm::Thread::yield();<br>
- }<br>
-<br>
- // Interrupt the thread.<br>
- th->lockingThread.varcond.signal();<br>
-<br>
- // Release the lock if we acquired it.<br>
- if (locked) lock->release(lock->getAssociatedObject(), vm->lockSystem);<br>
- }<br>
-<br>
- // Here we could also raise a signal for interrupting I/O<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-// Never throws.<br>
-// Never calls Java code.<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_interrupted(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- JavaThread* th = JavaThread::get();<br>
- uint32 interrupt = th->lockingThread.interruptFlag;<br>
- th->lockingThread.interruptFlag = 0;<br>
- return (jboolean)interrupt;<br>
-}<br>
-<br>
-// Never throws.<br>
-// Never calls Java code.<br>
-JNIEXPORT jboolean JNICALL Java_java_lang_VMThread_isInterrupted(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* vmthread) {<br>
-<br>
- llvm_gcroot(vmthread, 0);<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JavaField* field = vm->upcalls->vmdataVMThread;<br>
- JavaThread* th = (JavaThread*)field->getInstanceObjectField(vmthread);<br>
- return (jboolean)th->lockingThread.interruptFlag;<br>
-}<br>
-<br>
-// Never throws.<br>
-// Never calls Java code.<br>
-JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeSetPriority(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* vmthread, jint prio) {<br>
- // Currently not implemented<br>
- llvm_gcroot(vmthread, 0);<br>
-}<br>
-<br>
-// Never throws.<br>
-// Never calls Java code.<br>
-JNIEXPORT void JNICALL Java_java_lang_VMThread_nativeStop(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* vmthread, JavaObject* exc) {<br>
- // Currently not implemented<br>
- llvm_gcroot(vmthread, 0);<br>
- llvm_gcroot(exc, 0);<br>
-}<br>
-<br>
-// Never throws.<br>
-// Never calls Java code.<br>
-JNIEXPORT void JNICALL Java_java_lang_VMThread_yield(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-) {<br>
- mvm::Thread::yield();<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/ClasspathVMThrowable.inc<br>
b/lib/J3/Classpath/ClasspathVMThrowable.inc<br>
deleted file mode 100644<br>
index 8579e9e..0000000<br>
--- a/lib/J3/Classpath/ClasspathVMThrowable.inc<br>
+++ /dev/null<br>
@@ -1,183 +0,0 @@<br>
-//===- ClasspathVMClassLoader.cpp - GNU classpath<br>
java/lang/VMClassLoader -===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "types.h"<br>
-<br>
-#include "Classpath.h"<br>
-#include "JavaAccess.h"<br>
-#include "JavaArray.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaConstantPool.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaString.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-#include "Reader.h"<br>
-<br>
-using namespace j3;<br>
-<br>
-extern "C" {<br>
-<br>
-JavaObject* internalFillInStackTrace(JavaObject* throwable) {<br>
-<br>
- JavaObject* vmThrowable = 0;<br>
- ArrayPtr* result = 0;<br>
- llvm_gcroot(throwable, 0);<br>
- llvm_gcroot(vmThrowable, 0);<br>
- llvm_gcroot(result, 0);<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- Jnjvm* vm = th->getJVM();<br>
-<br>
- uint32 length = th->getFrameContextLength();<br>
-<br>
- if (sizeof(void*) == 4) {<br>
- ClassArray* cl = vm->upcalls->ArrayOfInt;<br>
- result = (ArrayPtr*) cl->doNew(length, vm);<br>
- } else {<br>
- ClassArray* cl = vm->upcalls->ArrayOfLong;<br>
- result = (ArrayPtr*) cl->doNew(length, vm);<br>
- }<br>
-<br>
- // Don't call th->getFrameContext because it is not GC-safe.<br>
- mvm::StackWalker Walker(th);<br>
- uint32_t i = 0;<br>
-<br>
- while (intptr_t ip = *Walker) {<br>
- ArrayPtr::setElement(result, ip, i);<br>
- ++i;<br>
- ++Walker;<br>
- }<br>
-<br>
- // Set the tempory data in the new VMThrowable object.<br>
- vmThrowable = vm->upcalls->newVMThrowable->doNew(vm);<br>
- vm->upcalls->vmDataVMThrowable->setInstanceObjectField(vmThrowable, result);<br>
- return vmThrowable;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_fillInStackTrace(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-jclass clazz,<br>
-#endif<br>
-JavaObject* throwable) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
- llvm_gcroot(throwable, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- res = internalFillInStackTrace(throwable);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-<br>
-JavaObject* consStackElement(mvm::FrameInfo* FI, intptr_t ip) {<br>
-<br>
- JavaString* methodName = 0;<br>
- JavaString* className = 0;<br>
- JavaString* sourceName = 0;<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(methodName, 0);<br>
- llvm_gcroot(className, 0);<br>
- llvm_gcroot(sourceName, 0);<br>
- llvm_gcroot(res, 0);<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JavaMethod* meth = (JavaMethod*)FI->Metadata;<br>
- methodName = vm->internalUTF8ToStr(meth->name);<br>
- Class* cl = meth->classDef;<br>
- className = JavaString::internalToJava(cl->name, vm);<br>
-<br>
- Attribut* sourceAtt = cl->lookupAttribut(Attribut::sourceFileAttribut);<br>
-<br>
- // We don't have the bytes if the class was vmjc'ed.<br>
- if (sourceAtt && cl->getBytes()) {<br>
- Reader reader(sourceAtt, cl->bytes);<br>
- uint16 index = reader.readU2();<br>
- sourceName = vm->internalUTF8ToStr(cl->getConstantPool()->UTF8At(index));<br>
- }<br>
-<br>
- bool native = isNative(meth->access);<br>
- uint16 lineNumber = meth->lookupLineNumber(FI);<br>
-<br>
- UserClass* newS = vm->upcalls->newStackTraceElement;<br>
- res = newS->doNew(vm);<br>
- vm->upcalls->initStackTraceElement->invokeIntSpecial(vm, newS, res,<br>
- &sourceName,<br>
- lineNumber,<br>
- &className,<br>
- &methodName, native);<br>
- return res;<br>
-}<br>
-<br>
-JNIEXPORT JavaObject* JNICALL Java_java_lang_VMThrowable_getStackTrace(<br>
-#ifdef NATIVE_JNI<br>
-JNIEnv *env,<br>
-#endif<br>
-JavaObject* vmthrow, JavaObject* throwable) {<br>
-<br>
- ArrayObject* result = NULL;<br>
- JavaObject* stack = NULL;<br>
- llvm_gcroot(vmthrow, 0);<br>
- llvm_gcroot(throwable, 0);<br>
- llvm_gcroot(result, 0);<br>
- llvm_gcroot(stack, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- JavaField* field = vm->upcalls->vmDataVMThrowable;<br>
- stack = field->getInstanceObjectField(vmthrow);<br>
-<br>
- // remove the VMThrowable.fillInStackTrace method and the last method<br>
- // on the stack.<br>
- sint32 index = 2;;<br>
- while (index != JavaArray::getSize(stack)) {<br>
- mvm::FrameInfo* FI =<br>
vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, index));<br>
- if (FI->Metadata == NULL) ++index;<br>
- else {<br>
- JavaMethod* meth = (JavaMethod*)FI->Metadata;<br>
- assert(meth && "Wrong stack trace");<br>
- if (meth->classDef->isAssignableFrom(vm->upcalls->newThrowable)) {<br>
- ++index;<br>
- } else break;<br>
- }<br>
- }<br>
-<br>
- sint32 size = 0;<br>
- sint32 cur = index;<br>
- while (cur < JavaArray::getSize(stack)) {<br>
- mvm::FrameInfo* FI =<br>
vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, cur));<br>
- ++cur;<br>
- if (FI->Metadata != NULL) ++size;<br>
- }<br>
-<br>
- result = (ArrayObject*)<br>
- vm->upcalls->stackTraceArray->doNew(size, vm);<br>
-<br>
- cur = 0;<br>
- for (sint32 i = index; i < JavaArray::getSize(stack); ++i) {<br>
- mvm::FrameInfo* FI =<br>
vm->IPToFrameInfo(ArrayPtr::getElement((ArrayPtr*)stack, i));<br>
- if (FI->Metadata != NULL) {<br>
- ArrayObject::setElement(result, consStackElement(FI,<br>
ArrayPtr::getElement((ArrayPtr*)stack, i)), cur);<br>
- cur++;<br>
- }<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return result;<br>
-}<br>
-<br>
-}<br>
diff --git a/lib/J3/Classpath/JavaUpcalls.cpp b/lib/J3/Classpath/JavaUpcalls.cpp<br>
deleted file mode 100644<br>
index 3ebac59..0000000<br>
--- a/lib/J3/Classpath/JavaUpcalls.cpp<br>
+++ /dev/null<br>
@@ -1,1076 +0,0 @@<br>
-//===-------- JavaUpcalls.cpp - Upcalls to Java entities<br>
------------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#include "ClasspathReflect.h"<br>
-#include "JavaAccess.h"<br>
-#include "JavaClass.h"<br>
-#include "JavaObject.h"<br>
-#include "JavaString.h"<br>
-#include "JavaThread.h"<br>
-#include "JavaUpcalls.h"<br>
-#include "Jnjvm.h"<br>
-#include "ReferenceQueue.h"<br>
-<br>
-#define COMPILE_METHODS(cl) \<br>
- for (CommonClass::method_iterator i = cl->virtualMethods.begin(), \<br>
- e = cl->virtualMethods.end(); i!= e; ++i) { \<br>
- i->second->compiledPtr(); \<br>
- } \<br>
- \<br>
- for (CommonClass::method_iterator i = cl->staticMethods.begin(), \<br>
- e = cl->staticMethods.end(); i!= e; ++i) { \<br>
- i->second->compiledPtr(); \<br>
- }<br>
-<br>
-<br>
-using namespace j3;<br>
-<br>
-Class* Classpath::newThread;<br>
-Class* Classpath::newVMThread;<br>
-JavaField* Classpath::assocThread;<br>
-JavaField* Classpath::vmdataVMThread;<br>
-JavaMethod* Classpath::finaliseCreateInitialThread;<br>
-JavaMethod* Classpath::initVMThread;<br>
-JavaMethod* Classpath::initThread;<br>
-JavaMethod* Classpath::groupAddThread;<br>
-JavaField* Classpath::threadName;<br>
-JavaField* Classpath::groupName;<br>
-JavaMethod* Classpath::initGroup;<br>
-JavaField* Classpath::priority;<br>
-JavaField* Classpath::daemon;<br>
-JavaField* Classpath::group;<br>
-JavaField* Classpath::running;<br>
-Class* Classpath::threadGroup;<br>
-JavaField* Classpath::rootGroup;<br>
-JavaField* Classpath::vmThread;<br>
-JavaMethod* Classpath::getUncaughtExceptionHandler;<br>
-JavaMethod* Classpath::uncaughtException;<br>
-Class* Classpath::inheritableThreadLocal;<br>
-<br>
-JavaMethod* Classpath::runVMThread;<br>
-JavaMethod* Classpath::setContextClassLoader;<br>
-JavaMethod* Classpath::getSystemClassLoader;<br>
-Class* Classpath::newString;<br>
-Class* Classpath::newClass;<br>
-Class* Classpath::newThrowable;<br>
-Class* Classpath::newException;<br>
-JavaMethod* Classpath::initClass;<br>
-JavaMethod* Classpath::initClassWithProtectionDomain;<br>
-JavaField* Classpath::vmdataClass;<br>
-JavaMethod* Classpath::setProperty;<br>
-JavaMethod* Classpath::initString;<br>
-JavaMethod* Classpath::getCallingClassLoader;<br>
-JavaMethod* Classpath::initConstructor;<br>
-Class* Classpath::newConstructor;<br>
-ClassArray* Classpath::constructorArrayClass;<br>
-ClassArray* Classpath::constructorArrayAnnotation;<br>
-JavaField* Classpath::constructorSlot;<br>
-JavaMethod* Classpath::initMethod;<br>
-JavaMethod* Classpath::initField;<br>
-Class* Classpath::newField;<br>
-Class* Classpath::newMethod;<br>
-ClassArray* Classpath::methodArrayClass;<br>
-ClassArray* Classpath::fieldArrayClass;<br>
-JavaField* Classpath::methodSlot;<br>
-JavaField* Classpath::fieldSlot;<br>
-ClassArray* Classpath::classArrayClass;<br>
-JavaMethod* Classpath::loadInClassLoader;<br>
-JavaMethod* Classpath::initVMThrowable;<br>
-JavaField* Classpath::vmDataVMThrowable;<br>
-Class* Classpath::newVMThrowable;<br>
-JavaField* Classpath::bufferAddress;<br>
-JavaField* Classpath::dataPointer32;<br>
-JavaField* Classpath::dataPointer64;<br>
-Class* Classpath::newPointer32;<br>
-Class* Classpath::newPointer64;<br>
-Class* Classpath::newDirectByteBuffer;<br>
-JavaField* Classpath::vmdataClassLoader;<br>
-JavaMethod* Classpath::InitDirectByteBuffer;<br>
-Class* Classpath::newClassLoader;<br>
-<br>
-<br>
-JavaField* Classpath::boolValue;<br>
-JavaField* Classpath::byteValue;<br>
-JavaField* Classpath::shortValue;<br>
-JavaField* Classpath::charValue;<br>
-JavaField* Classpath::intValue;<br>
-JavaField* Classpath::longValue;<br>
-JavaField* Classpath::floatValue;<br>
-JavaField* Classpath::doubleValue;<br>
-<br>
-Class* Classpath::newStackTraceElement;<br>
-ClassArray* Classpath::stackTraceArray;<br>
-JavaMethod* Classpath::initStackTraceElement;<br>
-<br>
-Class* Classpath::voidClass;<br>
-Class* Classpath::boolClass;<br>
-Class* Classpath::byteClass;<br>
-Class* Classpath::shortClass;<br>
-Class* Classpath::charClass;<br>
-Class* Classpath::intClass;<br>
-Class* Classpath::floatClass;<br>
-Class* Classpath::doubleClass;<br>
-Class* Classpath::longClass;<br>
-<br>
-Class* Classpath::vmStackWalker;<br>
-<br>
-Class* Classpath::InvocationTargetException;<br>
-Class* Classpath::ArrayStoreException;<br>
-Class* Classpath::ClassCastException;<br>
-Class* Classpath::IllegalMonitorStateException;<br>
-Class* Classpath::IllegalArgumentException;<br>
-Class* Classpath::InterruptedException;<br>
-Class* Classpath::IndexOutOfBoundsException;<br>
-Class* Classpath::ArrayIndexOutOfBoundsException;<br>
-Class* Classpath::NegativeArraySizeException;<br>
-Class* Classpath::NullPointerException;<br>
-Class* Classpath::SecurityException;<br>
-Class* Classpath::ClassFormatError;<br>
-Class* Classpath::ClassCircularityError;<br>
-Class* Classpath::NoClassDefFoundError;<br>
-Class* Classpath::UnsupportedClassVersionError;<br>
-Class* Classpath::NoSuchFieldError;<br>
-Class* Classpath::NoSuchMethodError;<br>
-Class* Classpath::InstantiationError;<br>
-Class* Classpath::InstantiationException;<br>
-Class* Classpath::IllegalAccessError;<br>
-Class* Classpath::IllegalAccessException;<br>
-Class* Classpath::VerifyError;<br>
-Class* Classpath::ExceptionInInitializerError;<br>
-Class* Classpath::LinkageError;<br>
-Class* Classpath::AbstractMethodError;<br>
-Class* Classpath::UnsatisfiedLinkError;<br>
-Class* Classpath::InternalError;<br>
-Class* Classpath::OutOfMemoryError;<br>
-Class* Classpath::StackOverflowError;<br>
-Class* Classpath::UnknownError;<br>
-Class* Classpath::ClassNotFoundException;<br>
-Class* Classpath::ArithmeticException;<br>
-<br>
-JavaMethod* Classpath::InitInvocationTargetException;<br>
-JavaMethod* Classpath::InitArrayStoreException;<br>
-JavaMethod* Classpath::InitClassCastException;<br>
-JavaMethod* Classpath::InitIllegalMonitorStateException;<br>
-JavaMethod* Classpath::InitIllegalArgumentException;<br>
-JavaMethod* Classpath::InitInterruptedException;<br>
-JavaMethod* Classpath::InitIndexOutOfBoundsException;<br>
-JavaMethod* Classpath::InitArrayIndexOutOfBoundsException;<br>
-JavaMethod* Classpath::InitNegativeArraySizeException;<br>
-JavaMethod* Classpath::InitNullPointerException;<br>
-JavaMethod* Classpath::InitSecurityException;<br>
-JavaMethod* Classpath::InitClassFormatError;<br>
-JavaMethod* Classpath::InitClassCircularityError;<br>
-JavaMethod* Classpath::InitNoClassDefFoundError;<br>
-JavaMethod* Classpath::InitUnsupportedClassVersionError;<br>
-JavaMethod* Classpath::InitNoSuchFieldError;<br>
-JavaMethod* Classpath::InitNoSuchMethodError;<br>
-JavaMethod* Classpath::InitInstantiationError;<br>
-JavaMethod* Classpath::InitInstantiationException;<br>
-JavaMethod* Classpath::InitIllegalAccessError;<br>
-JavaMethod* Classpath::InitIllegalAccessException;<br>
-JavaMethod* Classpath::InitVerifyError;<br>
-JavaMethod* Classpath::InitExceptionInInitializerError;<br>
-JavaMethod* Classpath::InitLinkageError;<br>
-JavaMethod* Classpath::InitAbstractMethodError;<br>
-JavaMethod* Classpath::InitUnsatisfiedLinkError;<br>
-JavaMethod* Classpath::InitInternalError;<br>
-JavaMethod* Classpath::InitOutOfMemoryError;<br>
-JavaMethod* Classpath::InitStackOverflowError;<br>
-JavaMethod* Classpath::InitUnknownError;<br>
-JavaMethod* Classpath::InitClassNotFoundException;<br>
-JavaMethod* Classpath::InitArithmeticException;<br>
-JavaMethod* Classpath::InitObject;<br>
-JavaMethod* Classpath::FinalizeObject;<br>
-JavaMethod* Classpath::IntToString;<br>
-<br>
-JavaMethod* Classpath::SystemArraycopy;<br>
-JavaMethod* Classpath::VMSystemArraycopy;<br>
-Class* Classpath::SystemClass;<br>
-Class* Classpath::EnumClass;<br>
-<br>
-JavaMethod* Classpath::ErrorWithExcpNoClassDefFoundError;<br>
-JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;<br>
-JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;<br>
-<br>
-ClassArray* Classpath::ArrayOfByte;<br>
-ClassArray* Classpath::ArrayOfChar;<br>
-ClassArray* Classpath::ArrayOfString;<br>
-ClassArray* Classpath::ArrayOfInt;<br>
-ClassArray* Classpath::ArrayOfShort;<br>
-ClassArray* Classpath::ArrayOfBool;<br>
-ClassArray* Classpath::ArrayOfLong;<br>
-ClassArray* Classpath::ArrayOfFloat;<br>
-ClassArray* Classpath::ArrayOfDouble;<br>
-ClassArray* Classpath::ArrayOfObject;<br>
-<br>
-ClassPrimitive* Classpath::OfByte;<br>
-ClassPrimitive* Classpath::OfChar;<br>
-ClassPrimitive* Classpath::OfInt;<br>
-ClassPrimitive* Classpath::OfShort;<br>
-ClassPrimitive* Classpath::OfBool;<br>
-ClassPrimitive* Classpath::OfLong;<br>
-ClassPrimitive* Classpath::OfFloat;<br>
-ClassPrimitive* Classpath::OfDouble;<br>
-ClassPrimitive* Classpath::OfVoid;<br>
-<br>
-Class* Classpath::OfObject;<br>
-<br>
-JavaField* Classpath::methodClass;<br>
-JavaField* Classpath::fieldClass;<br>
-JavaField* Classpath::constructorClass;<br>
-<br>
-JavaMethod* Classpath::EnqueueReference;<br>
-Class* Classpath::newReference;<br>
-<br>
-void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,<br>
- const char* thName, JavaObject* Group) {<br>
- JavaObjectVMThread* vmth = NULL;<br>
- JavaObject* th = NULL;<br>
- JavaObject* name = NULL;<br>
- llvm_gcroot(Group, 0);<br>
- llvm_gcroot(vmth, 0);<br>
- llvm_gcroot(th, 0);<br>
- llvm_gcroot(name, 0);<br>
-<br>
- th = newThread->doNew(vm);<br>
- myth->javaThread = th;<br>
- vmth = (JavaObjectVMThread*)newVMThread->doNew(vm);<br>
- name = vm->asciizToStr(thName);<br>
-<br>
- initThread->invokeIntSpecial(vm, newThread, th, &vmth, &name, 1, 0);<br>
- vmThread->setInstanceObjectField(th, vmth);<br>
- assocThread->setInstanceObjectField(vmth, th);<br>
- running->setInstanceInt8Field(vmth, (uint32)1);<br>
- JavaObjectVMThread::setVmdata(vmth, myth);<br>
-<br>
- group->setInstanceObjectField(th, Group);<br>
- groupAddThread->invokeIntSpecial(vm, threadGroup, Group, &th);<br>
-<br>
- finaliseCreateInitialThread->invokeIntStatic(vm,<br>
inheritableThreadLocal, &th);<br>
-}<br>
-<br>
-void Classpath::InitializeThreading(Jnjvm* vm) {<br>
-<br>
- JavaObject* RG = 0;<br>
- JavaObject* SystemGroup = 0;<br>
- JavaObject* systemName = 0;<br>
- llvm_gcroot(RG, 0);<br>
- llvm_gcroot(SystemGroup, 0);<br>
- llvm_gcroot(systemName, 0);<br>
-<br>
- // Resolve and initialize classes first.<br>
- newThread->resolveClass();<br>
- newThread->initialiseClass(vm);<br>
-<br>
- newVMThread->resolveClass();<br>
- newVMThread->initialiseClass(vm);<br>
-<br>
- threadGroup->resolveClass();<br>
- threadGroup->initialiseClass(vm);<br>
-<br>
- // Create the main thread<br>
- RG = rootGroup->getStaticObjectField();<br>
- assert(RG && "No root group");<br>
- assert(vm->getMainThread() && "VM did not set its main thread");<br>
- CreateJavaThread(vm, (JavaThread*)vm->getMainThread(), "main", RG);<br>
-<br>
- // Create the "system" group.<br>
- SystemGroup = threadGroup->doNew(vm);<br>
- initGroup->invokeIntSpecial(vm, threadGroup, SystemGroup);<br>
- systemName = vm->asciizToStr("system");<br>
- groupName->setInstanceObjectField(SystemGroup, systemName);<br>
-<br>
- // Create the finalizer thread.<br>
- assert(vm->getFinalizerThread() && "VM did not set its finalizer thread");<br>
- CreateJavaThread(vm, vm->getFinalizerThread(), "Finalizer", SystemGroup);<br>
-<br>
- // Create the enqueue thread.<br>
- assert(vm->getReferenceThread() && "VM did not set its enqueue thread");<br>
- CreateJavaThread(vm, vm->getReferenceThread(), "Reference", SystemGroup);<br>
-}<br>
-<br>
-extern "C" void<br>
Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2(<br>
- JavaObjectReference* reference, JavaObject* referent) {<br>
- llvm_gcroot(reference, 0);<br>
- llvm_gcroot(referent, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObjectReference::init(reference, referent, 0);<br>
- JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
-}<br>
-<br>
-extern "C" void<br>
Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(<br>
- JavaObjectReference* reference,<br>
- JavaObject* referent,<br>
- JavaObject* queue) {<br>
- llvm_gcroot(reference, 0);<br>
- llvm_gcroot(referent, 0);<br>
- llvm_gcroot(queue, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObjectReference::init(reference, referent, queue);<br>
- JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
-}<br>
-<br>
-extern "C" void<br>
Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2(<br>
- JavaObjectReference* reference, JavaObject* referent) {<br>
- llvm_gcroot(reference, 0);<br>
- llvm_gcroot(referent, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObjectReference::init(reference, referent, 0);<br>
- JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
-}<br>
-<br>
-extern "C" void<br>
Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(<br>
- JavaObjectReference* reference,<br>
- JavaObject* referent,<br>
- JavaObject* queue) {<br>
- llvm_gcroot(reference, 0);<br>
- llvm_gcroot(referent, 0);<br>
- llvm_gcroot(queue, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObjectReference::init(reference, referent, queue);<br>
- JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
-}<br>
-<br>
-extern "C" void<br>
Java_java_lang_ref_PhantomReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(<br>
- JavaObjectReference* reference,<br>
- JavaObject* referent,<br>
- JavaObject* queue) {<br>
- llvm_gcroot(reference, 0);<br>
- llvm_gcroot(referent, 0);<br>
- llvm_gcroot(queue, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaObjectReference::init(reference, referent, queue);<br>
- JavaThread::get()->getJVM()->getReferenceThread()->addPhantomReference(reference);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-}<br>
-<br>
-extern "C" JavaString* Java_java_lang_VMString_intern__Ljava_lang_String_2(<br>
- JavaString* obj) {<br>
- const ArrayUInt16* array = 0;<br>
- JavaString* res = 0;<br>
- llvm_gcroot(obj, 0);<br>
- llvm_gcroot(array, 0);<br>
- llvm_gcroot(res, 0);<br>
- // If the string is already interned, just return.<br>
- if (obj->getVirtualTable() == JavaString::internStringVT) return obj;<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- array = JavaString::strToArray(obj, vm);<br>
- res = vm->constructString(array);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-extern "C" uint8 Java_java_lang_Class_isArray__(JavaObjectClass* klass) {<br>
- llvm_gcroot(klass, 0);<br>
- UserCommonClass* cl = 0;<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- cl = JavaObjectClass::getClass(klass);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return (uint8)cl->isArray();<br>
-}<br>
-<br>
-extern "C" JavaObject* Java_gnu_classpath_VMStackWalker_getCallingClass__() {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- UserClass* cl = th->getCallingClassLevel(2);<br>
- if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-extern "C" JavaObject*<br>
Java_gnu_classpath_VMStackWalker_getCallingClassLoader__() {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- UserClass* cl = th->getCallingClassLevel(2);<br>
- res = cl->classLoader->getJavaClassLoader();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-extern "C" JavaObject*<br>
Java_gnu_classpath_VMStackWalker_firstNonNullClassLoader__() {<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- res = th->getNonNullClassLoader();<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-extern "C" JavaObject*<br>
Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {<br>
-<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- JavaThread* th = JavaThread::get();<br>
- Jnjvm* vm = th->getJVM();<br>
- UserClass* cl = th->getCallingClassLevel(index);<br>
- if (cl) res = cl->getClassDelegatee(vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-extern "C" JavaObject*<br>
Java_java_lang_reflect_AccessibleObject_getAnnotation__Ljava_lang_Class_2(<br>
- JavaObject* obj) {<br>
- llvm_gcroot(obj, 0);<br>
- return 0;<br>
-}<br>
-<br>
-extern "C" JavaObject*<br>
Java_java_lang_reflect_AccessibleObject_getDeclaredAnnotations__() {<br>
- JavaObject* res = 0;<br>
- llvm_gcroot(res, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- UserClassArray* array = vm->upcalls->constructorArrayAnnotation;<br>
- res = array->doNew(0, vm);<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return res;<br>
-}<br>
-<br>
-extern "C" void nativeJavaObjectClassTracer(<br>
- JavaObjectClass* obj, word_t closure) {<br>
- JavaObjectClass::staticTracer(obj, closure);<br>
-}<br>
-<br>
-extern "C" void nativeJavaObjectFieldTracer(<br>
- JavaObjectField* obj, word_t closure) {<br>
- JavaObjectField::staticTracer(obj, closure);<br>
-}<br>
-<br>
-extern "C" void nativeJavaObjectMethodTracer(<br>
- JavaObjectMethod* obj, word_t closure) {<br>
- JavaObjectMethod::staticTracer(obj, closure);<br>
-}<br>
-<br>
-extern "C" void nativeJavaObjectConstructorTracer(<br>
- JavaObjectConstructor* obj, word_t closure) {<br>
- JavaObjectConstructor::staticTracer(obj, closure);<br>
-}<br>
-<br>
-extern "C" void nativeJavaObjectVMThreadTracer(<br>
- JavaObjectVMThread* obj, word_t closure) {<br>
- JavaObjectVMThread::staticTracer(obj, closure);<br>
-}<br>
-<br>
-extern "C" JavaString*<br>
Java_java_lang_VMSystem_getenv__Ljava_lang_String_2(JavaString* str) {<br>
- JavaString* ret = 0;<br>
- llvm_gcroot(str, 0);<br>
- llvm_gcroot(ret, 0);<br>
-<br>
- BEGIN_NATIVE_EXCEPTION(0)<br>
-<br>
- mvm::ThreadAllocator allocator;<br>
- char* buf = JavaString::strToAsciiz(str, &allocator);<br>
- char* res = getenv(buf);<br>
- if (res) {<br>
- Jnjvm* vm = JavaThread::get()->getJVM();<br>
- ret = vm->asciizToStr(res);<br>
- }<br>
-<br>
- END_NATIVE_EXCEPTION<br>
-<br>
- return ret;<br>
-}<br>
-<br>
-void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {<br>
-<br>
- newClassLoader =<br>
- UPCALL_CLASS(loader, "java/lang/ClassLoader");<br>
-<br>
- getSystemClassLoader =<br>
- UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader",<br>
- "()Ljava/lang/ClassLoader;", ACC_STATIC);<br>
-<br>
- setContextClassLoader =<br>
- UPCALL_METHOD(loader, "java/lang/Thread", "setContextClassLoader",<br>
- "(Ljava/lang/ClassLoader;)V", ACC_VIRTUAL);<br>
-<br>
- newString =<br>
- UPCALL_CLASS(loader, "java/lang/String");<br>
-<br>
- newClass =<br>
- UPCALL_CLASS(loader, "java/lang/Class");<br>
-<br>
- newThrowable =<br>
- UPCALL_CLASS(loader, "java/lang/Throwable");<br>
-<br>
- newException =<br>
- UPCALL_CLASS(loader, "java/lang/Exception");<br>
-<br>
- newPointer32 =<br>
- UPCALL_CLASS(loader, "gnu/classpath/Pointer32");<br>
-<br>
- newPointer64 =<br>
- UPCALL_CLASS(loader, "gnu/classpath/Pointer64");<br>
-<br>
- newDirectByteBuffer =<br>
- UPCALL_CLASS(loader, "java/nio/DirectByteBufferImpl$ReadWrite");<br>
-<br>
- InitDirectByteBuffer =<br>
- UPCALL_METHOD(loader, "java/nio/DirectByteBufferImpl$ReadWrite", "<init>",<br>
- "(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V",<br>
- ACC_VIRTUAL);<br>
-<br>
- initClass =<br>
- UPCALL_METHOD(loader, "java/lang/Class", "<init>", "(Ljava/lang/Object;)V",<br>
- ACC_VIRTUAL);<br>
-<br>
- initClassWithProtectionDomain =<br>
- UPCALL_METHOD(loader, "java/lang/Class", "<init>",<br>
- "(Ljava/lang/Object;Ljava/security/ProtectionDomain;)V",<br>
- ACC_VIRTUAL);<br>
-<br>
- vmdataClass =<br>
- UPCALL_FIELD(loader, "java/lang/Class", "vmdata", "Ljava/lang/Object;",<br>
- ACC_VIRTUAL);<br>
-<br>
- setProperty =<br>
- UPCALL_METHOD(loader, "java/util/Properties", "setProperty",<br>
- "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",<br>
- ACC_VIRTUAL);<br>
-<br>
- initString =<br>
- UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V",<br>
ACC_VIRTUAL);<br>
-<br>
- initConstructor =<br>
- UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",<br>
- "(Ljava/lang/Class;I)V", ACC_VIRTUAL);<br>
-<br>
- newConstructor =<br>
- UPCALL_CLASS(loader, "java/lang/reflect/Constructor");<br>
-<br>
- constructorArrayClass =<br>
- UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);<br>
-<br>
- constructorArrayAnnotation =<br>
- UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);<br>
-<br>
- constructorSlot =<br>
- UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot",<br>
"I", ACC_VIRTUAL);<br>
-<br>
- initMethod =<br>
- UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",<br>
- "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);<br>
-<br>
- newMethod =<br>
- UPCALL_CLASS(loader, "java/lang/reflect/Method");<br>
-<br>
- methodArrayClass =<br>
- UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);<br>
-<br>
- methodSlot =<br>
- UPCALL_FIELD(loader, "java/lang/reflect/Method", "slot", "I", ACC_VIRTUAL);<br>
-<br>
- initField =<br>
- UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",<br>
- "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);<br>
-<br>
- newField =<br>
- UPCALL_CLASS(loader, "java/lang/reflect/Field");<br>
-<br>
- fieldArrayClass =<br>
- UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);<br>
-<br>
- fieldSlot =<br>
- UPCALL_FIELD(loader, "java/lang/reflect/Field", "slot", "I", ACC_VIRTUAL);<br>
-<br>
-<br>
- classArrayClass =<br>
- UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);<br>
-<br>
- newVMThrowable =<br>
- UPCALL_CLASS(loader, "java/lang/VMThrowable");<br>
-<br>
- initVMThrowable =<br>
- UPCALL_METHOD(loader, "java/lang/VMThrowable", "<init>", "()V",<br>
ACC_VIRTUAL);<br>
-<br>
- vmDataVMThrowable =<br>
- UPCALL_FIELD(loader, "java/lang/VMThrowable", "vmdata",<br>
"Ljava/lang/Object;",<br>
- ACC_VIRTUAL);<br>
-<br>
- bufferAddress =<br>
- UPCALL_FIELD(loader, "java/nio/Buffer", "address",<br>
"Lgnu/classpath/Pointer;",<br>
- ACC_VIRTUAL);<br>
-<br>
- dataPointer32 =<br>
- UPCALL_FIELD(loader, "gnu/classpath/Pointer32", "data", "I", ACC_VIRTUAL);<br>
-<br>
- dataPointer64 =<br>
- UPCALL_FIELD(loader, "gnu/classpath/Pointer64", "data", "J", ACC_VIRTUAL);<br>
-<br>
- vmdataClassLoader =<br>
- UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",<br>
"Ljava/lang/Object;",<br>
- ACC_VIRTUAL);<br>
-<br>
- newStackTraceElement =<br>
- UPCALL_CLASS(loader, "java/lang/StackTraceElement");<br>
-<br>
- stackTraceArray =<br>
- UPCALL_ARRAY_CLASS(loader, "java/lang/StackTraceElement", 1);<br>
-<br>
- initStackTraceElement =<br>
- UPCALL_METHOD(loader, "java/lang/StackTraceElement", "<init>",<br>
-<br>
"(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Z)V",<br>
- ACC_VIRTUAL);<br>
-<br>
- boolValue =<br>
- UPCALL_FIELD(loader, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);<br>
-<br>
- byteValue =<br>
- UPCALL_FIELD(loader, "java/lang/Byte", "value", "B", ACC_VIRTUAL);<br>
-<br>
- shortValue =<br>
- UPCALL_FIELD(loader, "java/lang/Short", "value", "S", ACC_VIRTUAL);<br>
-<br>
- charValue =<br>
- UPCALL_FIELD(loader, "java/lang/Character", "value", "C", ACC_VIRTUAL);<br>
-<br>
- intValue =<br>
- UPCALL_FIELD(loader, "java/lang/Integer", "value", "I", ACC_VIRTUAL);<br>
-<br>
- longValue =<br>
- UPCALL_FIELD(loader, "java/lang/Long", "value", "J", ACC_VIRTUAL);<br>
-<br>
- floatValue =<br>
- UPCALL_FIELD(loader, "java/lang/Float", "value", "F", ACC_VIRTUAL);<br>
-<br>
- doubleValue =<br>
- UPCALL_FIELD(loader, "java/lang/Double", "value", "D", ACC_VIRTUAL);<br>
-<br>
- Classpath::voidClass =<br>
- UPCALL_CLASS(loader, "java/lang/Void");<br>
-<br>
- Classpath::boolClass =<br>
- UPCALL_CLASS(loader, "java/lang/Boolean");<br>
-<br>
- Classpath::byteClass =<br>
- UPCALL_CLASS(loader, "java/lang/Byte");<br>
-<br>
- Classpath::shortClass =<br>
- UPCALL_CLASS(loader, "java/lang/Short");<br>
-<br>
- Classpath::charClass =<br>
- UPCALL_CLASS(loader, "java/lang/Character");<br>
-<br>
- Classpath::intClass =<br>
- UPCALL_CLASS(loader, "java/lang/Integer");<br>
-<br>
- Classpath::floatClass =<br>
- UPCALL_CLASS(loader, "java/lang/Float");<br>
-<br>
- Classpath::doubleClass =<br>
- UPCALL_CLASS(loader, "java/lang/Double");<br>
-<br>
- Classpath::longClass =<br>
- UPCALL_CLASS(loader, "java/lang/Long");<br>
-<br>
- Classpath::OfObject =<br>
- UPCALL_CLASS(loader, "java/lang/Object");<br>
-<br>
- vmStackWalker =<br>
- UPCALL_CLASS(loader, "gnu/classpath/VMStackWalker");<br>
-<br>
- loadInClassLoader =<br>
- UPCALL_METHOD(loader, "java/lang/ClassLoader", "loadClass",<br>
- "(Ljava/lang/String;)Ljava/lang/Class;", ACC_VIRTUAL);<br>
-<br>
- JavaMethod* internString =<br>
- UPCALL_METHOD(loader, "java/lang/VMString", "intern",<br>
- "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);<br>
- internString->setNative();<br>
-<br>
- JavaMethod* isArray =<br>
- UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL);<br>
- isArray->setNative();<br>
-<br>
- // Make sure classes the JIT optimizes on are loaded.<br>
- UPCALL_CLASS(loader, "java/lang/VMFloat");<br>
- UPCALL_CLASS(loader, "java/lang/VMDouble");<br>
-<br>
- UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException);<br>
- UPCALL_CLASS_EXCEPTION(loader, ArrayStoreException);<br>
- UPCALL_CLASS_EXCEPTION(loader, ClassCastException);<br>
- UPCALL_CLASS_EXCEPTION(loader, IllegalMonitorStateException);<br>
- UPCALL_CLASS_EXCEPTION(loader, IllegalArgumentException);<br>
- UPCALL_CLASS_EXCEPTION(loader, InterruptedException);<br>
- UPCALL_CLASS_EXCEPTION(loader, IndexOutOfBoundsException);<br>
- UPCALL_CLASS_EXCEPTION(loader, ArrayIndexOutOfBoundsException);<br>
- UPCALL_CLASS_EXCEPTION(loader, NegativeArraySizeException);<br>
- UPCALL_CLASS_EXCEPTION(loader, NullPointerException);<br>
- UPCALL_CLASS_EXCEPTION(loader, SecurityException);<br>
- UPCALL_CLASS_EXCEPTION(loader, ClassFormatError);<br>
- UPCALL_CLASS_EXCEPTION(loader, ClassCircularityError);<br>
- UPCALL_CLASS_EXCEPTION(loader, NoClassDefFoundError);<br>
- UPCALL_CLASS_EXCEPTION(loader, UnsupportedClassVersionError);<br>
- UPCALL_CLASS_EXCEPTION(loader, NoSuchFieldError);<br>
- UPCALL_CLASS_EXCEPTION(loader, NoSuchMethodError);<br>
- UPCALL_CLASS_EXCEPTION(loader, InstantiationError);<br>
- UPCALL_CLASS_EXCEPTION(loader, InstantiationException);<br>
- UPCALL_CLASS_EXCEPTION(loader, IllegalAccessError);<br>
- UPCALL_CLASS_EXCEPTION(loader, IllegalAccessException);<br>
- UPCALL_CLASS_EXCEPTION(loader, VerifyError);<br>
- UPCALL_CLASS_EXCEPTION(loader, ExceptionInInitializerError);<br>
- UPCALL_CLASS_EXCEPTION(loader, LinkageError);<br>
- UPCALL_CLASS_EXCEPTION(loader, AbstractMethodError);<br>
- UPCALL_CLASS_EXCEPTION(loader, UnsatisfiedLinkError);<br>
- UPCALL_CLASS_EXCEPTION(loader, InternalError);<br>
- UPCALL_CLASS_EXCEPTION(loader, OutOfMemoryError);<br>
- UPCALL_CLASS_EXCEPTION(loader, StackOverflowError);<br>
- UPCALL_CLASS_EXCEPTION(loader, UnknownError);<br>
- UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);<br>
- UPCALL_CLASS_EXCEPTION(loader, ArithmeticException);<br>
-<br>
- UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);<br>
- UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);<br>
- UPCALL_METHOD_EXCEPTION(loader, ClassCastException);<br>
- UPCALL_METHOD_EXCEPTION(loader, IllegalMonitorStateException);<br>
- UPCALL_METHOD_EXCEPTION(loader, IllegalArgumentException);<br>
- UPCALL_METHOD_EXCEPTION(loader, InterruptedException);<br>
- UPCALL_METHOD_EXCEPTION(loader, IndexOutOfBoundsException);<br>
- UPCALL_METHOD_EXCEPTION(loader, ArrayIndexOutOfBoundsException);<br>
- UPCALL_METHOD_EXCEPTION(loader, NegativeArraySizeException);<br>
- UPCALL_METHOD_EXCEPTION(loader, NullPointerException);<br>
- UPCALL_METHOD_EXCEPTION(loader, SecurityException);<br>
- UPCALL_METHOD_EXCEPTION(loader, ClassFormatError);<br>
- UPCALL_METHOD_EXCEPTION(loader, ClassCircularityError);<br>
- UPCALL_METHOD_EXCEPTION(loader, NoClassDefFoundError);<br>
- UPCALL_METHOD_EXCEPTION(loader, UnsupportedClassVersionError);<br>
- UPCALL_METHOD_EXCEPTION(loader, NoSuchFieldError);<br>
- UPCALL_METHOD_EXCEPTION(loader, NoSuchMethodError);<br>
- UPCALL_METHOD_EXCEPTION(loader, InstantiationError);<br>
- UPCALL_METHOD_EXCEPTION(loader, InstantiationException);<br>
- UPCALL_METHOD_EXCEPTION(loader, IllegalAccessError);<br>
- UPCALL_METHOD_EXCEPTION(loader, IllegalAccessException);<br>
- UPCALL_METHOD_EXCEPTION(loader, VerifyError);<br>
- UPCALL_METHOD_EXCEPTION(loader, ExceptionInInitializerError);<br>
- UPCALL_METHOD_EXCEPTION(loader, LinkageError);<br>
- UPCALL_METHOD_EXCEPTION(loader, AbstractMethodError);<br>
- UPCALL_METHOD_EXCEPTION(loader, UnsatisfiedLinkError);<br>
- UPCALL_METHOD_EXCEPTION(loader, InternalError);<br>
- UPCALL_METHOD_EXCEPTION(loader, OutOfMemoryError);<br>
- UPCALL_METHOD_EXCEPTION(loader, StackOverflowError);<br>
- UPCALL_METHOD_EXCEPTION(loader, UnknownError);<br>
- UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);<br>
- UPCALL_METHOD_EXCEPTION(loader, ArithmeticException);<br>
-<br>
- UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);<br>
- UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);<br>
- UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);<br>
-<br>
- InitObject = UPCALL_METHOD(loader, "java/lang/Object", "<init>", "()V",<br>
- ACC_VIRTUAL);<br>
-<br>
- FinalizeObject = UPCALL_METHOD(loader, "java/lang/Object", "finalize", "()V",<br>
- ACC_VIRTUAL);<br>
-<br>
- IntToString = UPCALL_METHOD(loader, "java/lang/Integer", "toString",<br>
- "(II)Ljava/lang/String;", ACC_STATIC);<br>
-<br>
- SystemArraycopy = UPCALL_METHOD(loader, "java/lang/System", "arraycopy",<br>
- "(Ljava/lang/Object;ILjava/lang/Object;II)V",<br>
- ACC_STATIC);<br>
-<br>
- VMSystemArraycopy = UPCALL_METHOD(loader, "java/lang/VMSystem", "arraycopy",<br>
- "(Ljava/lang/Object;ILjava/lang/Object;II)V",<br>
- ACC_STATIC);<br>
-<br>
- SystemClass = UPCALL_CLASS(loader, "java/lang/System");<br>
- EnumClass = UPCALL_CLASS(loader, "java/lang/Enum");<br>
-<br>
- newThread =<br>
- UPCALL_CLASS(loader, "java/lang/Thread");<br>
-<br>
- newVMThread =<br>
- UPCALL_CLASS(loader, "java/lang/VMThread");<br>
-<br>
- assocThread =<br>
- UPCALL_FIELD(loader, "java/lang/VMThread", "thread", "Ljava/lang/Thread;",<br>
- ACC_VIRTUAL);<br>
-<br>
- vmdataVMThread =<br>
- UPCALL_FIELD(loader, "java/lang/VMThread", "vmdata", "Ljava/lang/Object;",<br>
- ACC_VIRTUAL);<br>
-<br>
- inheritableThreadLocal =<br>
- UPCALL_CLASS(loader, "java/lang/InheritableThreadLocal");<br>
-<br>
- finaliseCreateInitialThread =<br>
- UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal", "newChildThread",<br>
- "(Ljava/lang/Thread;)V", ACC_STATIC);<br>
-<br>
- initThread =<br>
- UPCALL_METHOD(loader, "java/lang/Thread", "<init>",<br>
- "(Ljava/lang/VMThread;Ljava/lang/String;IZ)V", ACC_VIRTUAL);<br>
-<br>
- initVMThread =<br>
- UPCALL_METHOD(loader, "java/lang/VMThread", "<init>",<br>
- "(Ljava/lang/Thread;)V", ACC_VIRTUAL);<br>
-<br>
- runVMThread =<br>
- UPCALL_METHOD(loader, "java/lang/VMThread", "run", "()V", ACC_VIRTUAL);<br>
-<br>
-<br>
- groupAddThread =<br>
- UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread",<br>
- "(Ljava/lang/Thread;)V", ACC_VIRTUAL);<br>
-<br>
- initGroup =<br>
- UPCALL_METHOD(loader, "java/lang/ThreadGroup", "<init>",<br>
- "()V", ACC_VIRTUAL);<br>
-<br>
- groupName =<br>
- UPCALL_FIELD(loader, "java/lang/ThreadGroup", "name", "Ljava/lang/String;",<br>
- ACC_VIRTUAL);<br>
-<br>
- threadName =<br>
- UPCALL_FIELD(loader, "java/lang/Thread", "name", "Ljava/lang/String;",<br>
- ACC_VIRTUAL);<br>
-<br>
-<br>
- priority =<br>
- UPCALL_FIELD(loader, "java/lang/Thread", "priority", "I", ACC_VIRTUAL);<br>
-<br>
- daemon =<br>
- UPCALL_FIELD(loader, "java/lang/Thread", "daemon", "Z", ACC_VIRTUAL);<br>
-<br>
- group =<br>
- UPCALL_FIELD(loader, "java/lang/Thread", "group",<br>
- "Ljava/lang/ThreadGroup;", ACC_VIRTUAL);<br>
-<br>
- running =<br>
- UPCALL_FIELD(loader, "java/lang/VMThread", "running", "Z", ACC_VIRTUAL);<br>
-<br>
- threadGroup =<br>
- UPCALL_CLASS(loader, "java/lang/ThreadGroup");<br>
-<br>
- rootGroup =<br>
- UPCALL_FIELD(loader, "java/lang/ThreadGroup", "root",<br>
- "Ljava/lang/ThreadGroup;", ACC_STATIC);<br>
-<br>
- vmThread =<br>
- UPCALL_FIELD(loader, "java/lang/Thread", "vmThread",<br>
- "Ljava/lang/VMThread;", ACC_VIRTUAL);<br>
-<br>
- getUncaughtExceptionHandler =<br>
- UPCALL_METHOD(loader, "java/lang/Thread", "getUncaughtExceptionHandler",<br>
- "()Ljava/lang/Thread$UncaughtExceptionHandler;",<br>
ACC_VIRTUAL);<br>
-<br>
- uncaughtException =<br>
- UPCALL_METHOD(loader, "java/lang/Thread$UncaughtExceptionHandler",<br>
- "uncaughtException",<br>
- "(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL);<br>
-<br>
-<br>
- methodClass =<br>
- UPCALL_FIELD(loader, "java/lang/reflect/Method", "declaringClass",<br>
- "Ljava/lang/Class;", ACC_VIRTUAL);<br>
-<br>
- fieldClass =<br>
- UPCALL_FIELD(loader, "java/lang/reflect/Field", "declaringClass",<br>
- "Ljava/lang/Class;", ACC_VIRTUAL);<br>
-<br>
- constructorClass =<br>
- UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "clazz",<br>
- "Ljava/lang/Class;", ACC_VIRTUAL);<br>
-<br>
- loader->loadName(loader->asciizConstructUTF8("java/lang/String"),<br>
- true, false, NULL);<br>
-<br>
- loader->loadName(loader->asciizConstructUTF8("java/lang/Object"),<br>
- true, false, NULL);<br>
-<br>
- // Don't compile methods here, we still don't know where to allocate Java<br>
- // strings.<br>
-<br>
- JavaMethod* getEnv =<br>
- UPCALL_METHOD(loader, "java/lang/VMSystem", "getenv",<br>
- "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);<br>
- getEnv->setNative();<br>
-<br>
- JavaMethod* getCallingClass =<br>
- UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass",<br>
- "()Ljava/lang/Class;", ACC_STATIC);<br>
- getCallingClass->setNative();<br>
-<br>
- JavaMethod* getCallingClassLoader =<br>
- UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",<br>
"getCallingClassLoader",<br>
- "()Ljava/lang/ClassLoader;", ACC_STATIC);<br>
- getCallingClassLoader->setNative();<br>
-<br>
- JavaMethod* firstNonNullClassLoader =<br>
- UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",<br>
"firstNonNullClassLoader",<br>
- "()Ljava/lang/ClassLoader;", ACC_STATIC);<br>
- firstNonNullClassLoader->setNative();<br>
-<br>
- JavaMethod* getCallerClass =<br>
- UPCALL_METHOD(loader, "sun/reflect/Reflection", "getCallerClass",<br>
- "(I)Ljava/lang/Class;", ACC_STATIC);<br>
- getCallerClass->setNative();<br>
-<br>
- JavaMethod* postProperties =<br>
- UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit",<br>
- "(Ljava/util/Properties;)V", ACC_STATIC);<br>
- postProperties->setNative();<br>
-<br>
- // Also implement these twos, implementation in GNU Classpath<br>
0.97.2 is buggy.<br>
- JavaMethod* getAnnotation =<br>
- UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",<br>
"getAnnotation",<br>
- "(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;",<br>
- ACC_VIRTUAL);<br>
- getAnnotation->setNative();<br>
-<br>
- JavaMethod* getAnnotations =<br>
- UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",<br>
- "getDeclaredAnnotations",<br>
- "()[Ljava/lang/annotation/Annotation;",<br>
- ACC_VIRTUAL);<br>
- getAnnotations->setNative();<br>
-<br>
- JavaMethod* getBootPackages =<br>
- UPCALL_METHOD(loader, "java/lang/VMClassLoader", "getBootPackages",<br>
- "()[Ljava/lang/String;", ACC_STATIC);<br>
- getBootPackages->setNative();<br>
-<br>
- //===----------------------------------------------------------------------===//<br>
- //<br>
- // To make classes non GC-allocated, we have to bypass the tracer<br>
functions of<br>
- // java.lang.Class, java.lang.reflect.Field, java.lang.reflect.Method and<br>
- // java.lang.reflect.constructor. The new tracer functions trace<br>
the classloader<br>
- // instead of the class/field/method.<br>
- //<br>
- //===----------------------------------------------------------------------===//<br>
-<br>
- newClass->getVirtualVT()->setNativeTracer(<br>
- (word_t)nativeJavaObjectClassTracer,<br>
- "nativeJavaObjectClassTracer");<br>
-<br>
- newConstructor->getVirtualVT()->setNativeTracer(<br>
- (word_t)nativeJavaObjectConstructorTracer,<br>
- "nativeJavaObjectConstructorTracer");<br>
-<br>
- newMethod->getVirtualVT()->setNativeTracer(<br>
- (word_t)nativeJavaObjectMethodTracer,<br>
- "nativeJavaObjectMethodTracer");<br>
-<br>
- newField->getVirtualVT()->setNativeTracer(<br>
- (word_t)nativeJavaObjectFieldTracer,<br>
- "nativeJavaObjectFieldTracer");<br>
-<br>
- newVMThread->getVirtualVT()->setNativeTracer(<br>
- (word_t)nativeJavaObjectVMThreadTracer,<br>
- "nativeJavaObjectVMThreadTracer");<br>
-<br>
- newReference = UPCALL_CLASS(loader, "java/lang/ref/Reference");<br>
-<br>
- EnqueueReference =<br>
- UPCALL_METHOD(loader, "java/lang/ref/Reference", "enqueue", "()Z",<br>
- ACC_VIRTUAL);<br>
-<br>
- JavaMethod* initWeakReference =<br>
- UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",<br>
- "(Ljava/lang/Object;)V",<br>
- ACC_VIRTUAL);<br>
- initWeakReference->setNative();<br>
-<br>
- initWeakReference =<br>
- UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",<br>
- "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",<br>
- ACC_VIRTUAL);<br>
- initWeakReference->setNative();<br>
-<br>
- JavaMethod* initSoftReference =<br>
- UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",<br>
- "(Ljava/lang/Object;)V",<br>
- ACC_VIRTUAL);<br>
- initSoftReference->setNative();<br>
-<br>
- initSoftReference =<br>
- UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",<br>
- "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",<br>
- ACC_VIRTUAL);<br>
- initSoftReference->setNative();<br>
-<br>
- JavaMethod* initPhantomReference =<br>
- UPCALL_METHOD(loader, "java/lang/ref/PhantomReference", "<init>",<br>
- "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",<br>
- ACC_VIRTUAL);<br>
- initPhantomReference->setNative();<br>
-}<br>
-<br>
-#include "ClasspathConstructor.inc"<br>
-#include "Classpath.inc"<br>
-#include "ClasspathField.inc"<br>
-#include "ClasspathMethod.inc"<br>
-#include "ClasspathVMClass.inc"<br>
-#include "ClasspathVMClassLoader.inc"<br>
-#include "ClasspathVMObject.inc"<br>
-#include "ClasspathVMRuntime.inc"<br>
-#include "ClasspathVMStackWalker.inc"<br>
-#include "ClasspathVMSystem.inc"<br>
-#include "ClasspathVMSystemProperties.inc"<br>
-#include "ClasspathVMThread.inc"<br>
-#include "ClasspathVMThrowable.inc"<br>
diff --git a/lib/J3/Classpath/JavaUpcalls.h b/lib/J3/Classpath/JavaUpcalls.h<br>
deleted file mode 100644<br>
index f30f3ac..0000000<br>
--- a/lib/J3/Classpath/JavaUpcalls.h<br>
+++ /dev/null<br>
@@ -1,283 +0,0 @@<br>
-//===---------- JavaUpcalls.h - Upcalls to Java entities<br>
------------------===//<br>
-//<br>
-// The VMKit project<br>
-//<br>
-// This file is distributed under the University of Illinois Open Source<br>
-// License. See LICENSE.TXT for details.<br>
-//<br>
-//===----------------------------------------------------------------------===//<br>
-<br>
-#ifndef JNJVM_JAVA_UPCALLS_H<br>
-#define JNJVM_JAVA_UPCALLS_H<br>
-<br>
-#include "mvm/Allocator.h"<br>
-<br>
-#include "JnjvmConfig.h"<br>
-<br>
-#define UPCALL_CLASS(vm, name)<br>
\<br>
- vm->loadName(vm->asciizConstructUTF8(name), true, false, NULL)<br>
-<br>
-#define UPCALL_PRIMITIVE_CLASS(loader, name, nb)<br>
\<br>
- new(loader->allocator, "Primitive class")<br>
\<br>
- UserClassPrimitive(loader,<br>
loader->asciizConstructUTF8(name), nb) \<br>
-<br>
-#define UPCALL_FIELD(vm, cl, name, type, acc)<br>
\<br>
- UPCALL_CLASS(vm,<br>
cl)->lookupFieldDontThrow(vm->asciizConstructUTF8(name), \<br>
-<br>
vm->asciizConstructUTF8(type), \<br>
- isStatic(acc), false, 0)<br>
-<br>
-#define UPCALL_METHOD(vm, cl, name, type, acc)<br>
\<br>
- UPCALL_CLASS(vm,<br>
cl)->lookupMethodDontThrow(vm->asciizConstructUTF8(name), \<br>
-<br>
vm->asciizConstructUTF8(type), \<br>
- isStatic(acc), false, 0)<br>
-<br>
-#define UPCALL_ARRAY_CLASS(loader, name, depth)<br>
\<br>
- loader->constructArray(<br>
\<br>
- loader->constructArrayName(depth,<br>
loader->asciizConstructUTF8(name)))<br>
-<br>
-#define UPCALL_CLASS_EXCEPTION(loader, name)<br>
\<br>
- name = UPCALL_CLASS(loader, "java/lang/"#name)<br>
-<br>
-#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name)<br>
\<br>
- name = UPCALL_CLASS(loader, "java/lang/reflect/"#name)<br>
-<br>
-#define UPCALL_METHOD_EXCEPTION(loader, name) \<br>
- Init##name =<br>
name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \<br>
-<br>
loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \<br>
- false, false, 0);<br>
-<br>
-#define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \<br>
- ErrorWithExcp##name =<br>
name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \<br>
-<br>
loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \<br>
- false, false, 0);<br>
-<br>
-namespace j3 {<br>
-<br>
-class Jnjvm;<br>
-class JavaField;<br>
-class JavaMethod;<br>
-class JavaObject;<br>
-class JavaThread;<br>
-class Class;<br>
-class ClassArray;<br>
-class JnjvmClassLoader;<br>
-<br>
-class Classpath : public mvm::PermanentObject {<br>
-public:<br>
- ISOLATE_STATIC UserClass* newClassLoader;<br>
- ISOLATE_STATIC JavaMethod* getSystemClassLoader;<br>
- ISOLATE_STATIC JavaMethod* setContextClassLoader;<br>
- ISOLATE_STATIC UserClass* newString;<br>
- ISOLATE_STATIC UserClass* newClass;<br>
- ISOLATE_STATIC UserClass* newThrowable;<br>
- ISOLATE_STATIC UserClass* newException;<br>
- ISOLATE_STATIC JavaMethod* initClass;<br>
- ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain;<br>
- ISOLATE_STATIC JavaField* vmdataClass;<br>
- ISOLATE_STATIC JavaMethod* setProperty;<br>
- ISOLATE_STATIC JavaMethod* initString;<br>
- ISOLATE_STATIC JavaMethod* getCallingClassLoader;<br>
- ISOLATE_STATIC JavaMethod* initConstructor;<br>
- ISOLATE_STATIC UserClassArray* constructorArrayClass;<br>
- ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;<br>
- ISOLATE_STATIC UserClass* newConstructor;<br>
- ISOLATE_STATIC JavaField* constructorSlot;<br>
- ISOLATE_STATIC JavaMethod* initMethod;<br>
- ISOLATE_STATIC JavaMethod* initField;<br>
- ISOLATE_STATIC UserClassArray* methodArrayClass;<br>
- ISOLATE_STATIC UserClassArray* fieldArrayClass;<br>
- ISOLATE_STATIC UserClass* newMethod;<br>
- ISOLATE_STATIC UserClass* newField;<br>
- ISOLATE_STATIC JavaField* methodSlot;<br>
- ISOLATE_STATIC JavaField* fieldSlot;<br>
- ISOLATE_STATIC UserClassArray* classArrayClass;<br>
- ISOLATE_STATIC JavaMethod* loadInClassLoader;<br>
- ISOLATE_STATIC JavaMethod* initVMThrowable;<br>
- ISOLATE_STATIC JavaField* vmDataVMThrowable;<br>
- ISOLATE_STATIC UserClass* newVMThrowable;<br>
- ISOLATE_STATIC JavaField* bufferAddress;<br>
- ISOLATE_STATIC JavaField* dataPointer32;<br>
- ISOLATE_STATIC JavaField* dataPointer64;<br>
- ISOLATE_STATIC UserClass* newPointer32;<br>
- ISOLATE_STATIC UserClass* newPointer64;<br>
- ISOLATE_STATIC UserClass* newDirectByteBuffer;<br>
- ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;<br>
- ISOLATE_STATIC JavaField* vmdataClassLoader;<br>
- ISOLATE_STATIC UserClass* enumClass;<br>
-<br>
- ISOLATE_STATIC JavaField* boolValue;<br>
- ISOLATE_STATIC JavaField* byteValue;<br>
- ISOLATE_STATIC JavaField* shortValue;<br>
- ISOLATE_STATIC JavaField* charValue;<br>
- ISOLATE_STATIC JavaField* intValue;<br>
- ISOLATE_STATIC JavaField* longValue;<br>
- ISOLATE_STATIC JavaField* floatValue;<br>
- ISOLATE_STATIC JavaField* doubleValue;<br>
-<br>
- ISOLATE_STATIC UserClass* newStackTraceElement;<br>
- ISOLATE_STATIC UserClassArray* stackTraceArray;<br>
- ISOLATE_STATIC JavaMethod* initStackTraceElement;<br>
-<br>
- ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader);<br>
-<br>
- ISOLATE_STATIC UserClass* voidClass;<br>
- ISOLATE_STATIC UserClass* boolClass;<br>
- ISOLATE_STATIC UserClass* byteClass;<br>
- ISOLATE_STATIC UserClass* shortClass;<br>
- ISOLATE_STATIC UserClass* charClass;<br>
- ISOLATE_STATIC UserClass* intClass;<br>
- ISOLATE_STATIC UserClass* floatClass;<br>
- ISOLATE_STATIC UserClass* doubleClass;<br>
- ISOLATE_STATIC UserClass* longClass;<br>
-<br>
- ISOLATE_STATIC UserClass* vmStackWalker;<br>
-<br>
- ISOLATE_STATIC UserClass* newThread;<br>
- ISOLATE_STATIC UserClass* newVMThread;<br>
- ISOLATE_STATIC JavaField* assocThread;<br>
- ISOLATE_STATIC JavaField* vmdataVMThread;<br>
- ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread;<br>
- ISOLATE_STATIC JavaMethod* initThread;<br>
- ISOLATE_STATIC JavaMethod* initVMThread;<br>
- ISOLATE_STATIC JavaMethod* runVMThread;<br>
- ISOLATE_STATIC JavaMethod* groupAddThread;<br>
- ISOLATE_STATIC JavaField* threadName;<br>
- ISOLATE_STATIC JavaField* groupName;<br>
- ISOLATE_STATIC JavaMethod* initGroup;<br>
- ISOLATE_STATIC JavaField* priority;<br>
- ISOLATE_STATIC JavaField* daemon;<br>
- ISOLATE_STATIC JavaField* group;<br>
- ISOLATE_STATIC JavaField* running;<br>
- ISOLATE_STATIC UserClass* threadGroup;<br>
- ISOLATE_STATIC JavaField* rootGroup;<br>
- ISOLATE_STATIC JavaField* vmThread;<br>
- ISOLATE_STATIC JavaMethod* getUncaughtExceptionHandler;<br>
- ISOLATE_STATIC JavaMethod* uncaughtException;<br>
- ISOLATE_STATIC UserClass* inheritableThreadLocal;<br>
-<br>
-<br>
- ISOLATE_STATIC UserClass* InvocationTargetException;<br>
- ISOLATE_STATIC UserClass* ArrayStoreException;<br>
- ISOLATE_STATIC UserClass* ClassCastException;<br>
- ISOLATE_STATIC UserClass* IllegalMonitorStateException;<br>
- ISOLATE_STATIC UserClass* IllegalArgumentException;<br>
- ISOLATE_STATIC UserClass* InterruptedException;<br>
- ISOLATE_STATIC UserClass* IndexOutOfBoundsException;<br>
- ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException;<br>
- ISOLATE_STATIC UserClass* NegativeArraySizeException;<br>
- ISOLATE_STATIC UserClass* NullPointerException;<br>
- ISOLATE_STATIC UserClass* SecurityException;<br>
- ISOLATE_STATIC UserClass* ClassFormatError;<br>
- ISOLATE_STATIC UserClass* ClassCircularityError;<br>
- ISOLATE_STATIC UserClass* NoClassDefFoundError;<br>
- ISOLATE_STATIC UserClass* UnsupportedClassVersionError;<br>
- ISOLATE_STATIC UserClass* NoSuchFieldError;<br>
- ISOLATE_STATIC UserClass* NoSuchMethodError;<br>
- ISOLATE_STATIC UserClass* InstantiationError;<br>
- ISOLATE_STATIC UserClass* InstantiationException;<br>
- ISOLATE_STATIC UserClass* IllegalAccessError;<br>
- ISOLATE_STATIC UserClass* IllegalAccessException;<br>
- ISOLATE_STATIC UserClass* VerifyError;<br>
- ISOLATE_STATIC UserClass* ExceptionInInitializerError;<br>
- ISOLATE_STATIC UserClass* LinkageError;<br>
- ISOLATE_STATIC UserClass* AbstractMethodError;<br>
- ISOLATE_STATIC UserClass* UnsatisfiedLinkError;<br>
- ISOLATE_STATIC UserClass* InternalError;<br>
- ISOLATE_STATIC UserClass* OutOfMemoryError;<br>
- ISOLATE_STATIC UserClass* StackOverflowError;<br>
- ISOLATE_STATIC UserClass* UnknownError;<br>
- ISOLATE_STATIC UserClass* ClassNotFoundException;<br>
- ISOLATE_STATIC UserClass* ArithmeticException;<br>
-<br>
- ISOLATE_STATIC JavaMethod* InitInvocationTargetException;<br>
- ISOLATE_STATIC JavaMethod* InitArrayStoreException;<br>
- ISOLATE_STATIC JavaMethod* InitClassCastException;<br>
- ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException;<br>
- ISOLATE_STATIC JavaMethod* InitIllegalArgumentException;<br>
- ISOLATE_STATIC JavaMethod* InitInterruptedException;<br>
- ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException;<br>
- ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException;<br>
- ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException;<br>
- ISOLATE_STATIC JavaMethod* InitNullPointerException;<br>
- ISOLATE_STATIC JavaMethod* InitSecurityException;<br>
- ISOLATE_STATIC JavaMethod* InitClassFormatError;<br>
- ISOLATE_STATIC JavaMethod* InitClassCircularityError;<br>
- ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError;<br>
- ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError;<br>
- ISOLATE_STATIC JavaMethod* InitNoSuchFieldError;<br>
- ISOLATE_STATIC JavaMethod* InitNoSuchMethodError;<br>
- ISOLATE_STATIC JavaMethod* InitInstantiationError;<br>
- ISOLATE_STATIC JavaMethod* InitInstantiationException;<br>
- ISOLATE_STATIC JavaMethod* InitIllegalAccessError;<br>
- ISOLATE_STATIC JavaMethod* InitIllegalAccessException;<br>
- ISOLATE_STATIC JavaMethod* InitVerifyError;<br>
- ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError;<br>
- ISOLATE_STATIC JavaMethod* InitLinkageError;<br>
- ISOLATE_STATIC JavaMethod* InitAbstractMethodError;<br>
- ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError;<br>
- ISOLATE_STATIC JavaMethod* InitInternalError;<br>
- ISOLATE_STATIC JavaMethod* InitOutOfMemoryError;<br>
- ISOLATE_STATIC JavaMethod* InitStackOverflowError;<br>
- ISOLATE_STATIC JavaMethod* InitUnknownError;<br>
- ISOLATE_STATIC JavaMethod* InitClassNotFoundException;<br>
- ISOLATE_STATIC JavaMethod* InitArithmeticException;<br>
-<br>
- ISOLATE_STATIC JavaMethod* SystemArraycopy;<br>
- ISOLATE_STATIC JavaMethod* VMSystemArraycopy;<br>
- ISOLATE_STATIC Class* SystemClass;<br>
-<br>
- ISOLATE_STATIC JavaMethod* IntToString;<br>
-<br>
- ISOLATE_STATIC JavaMethod* InitObject;<br>
- ISOLATE_STATIC JavaMethod* FinalizeObject;<br>
-<br>
- ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError;<br>
- ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError;<br>
- ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException;<br>
-<br>
-<br>
-<br>
- ISOLATE_STATIC UserClassArray* ArrayOfByte;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfChar;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfInt;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfShort;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfBool;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfLong;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfFloat;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfDouble;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfObject;<br>
- ISOLATE_STATIC UserClassArray* ArrayOfString;<br>
-<br>
- ISOLATE_STATIC UserClassPrimitive* OfByte;<br>
- ISOLATE_STATIC UserClassPrimitive* OfChar;<br>
- ISOLATE_STATIC UserClassPrimitive* OfInt;<br>
- ISOLATE_STATIC UserClassPrimitive* OfShort;<br>
- ISOLATE_STATIC UserClassPrimitive* OfBool;<br>
- ISOLATE_STATIC UserClassPrimitive* OfLong;<br>
- ISOLATE_STATIC UserClassPrimitive* OfFloat;<br>
- ISOLATE_STATIC UserClassPrimitive* OfDouble;<br>
- ISOLATE_STATIC UserClassPrimitive* OfVoid;<br>
-<br>
- ISOLATE_STATIC UserClass* OfObject;<br>
-<br>
- ISOLATE_STATIC JavaField* methodClass;<br>
- ISOLATE_STATIC JavaField* fieldClass;<br>
- ISOLATE_STATIC JavaField* constructorClass;<br>
-<br>
- ISOLATE_STATIC JavaMethod* EnqueueReference;<br>
- ISOLATE_STATIC Class* newReference;<br>
-<br>
- ISOLATE_STATIC UserClass* EnumClass;<br>
-<br>
-private:<br>
- ISOLATE_STATIC void CreateJavaThread(Jnjvm* vm, JavaThread* myth,<br>
- const char* name, JavaObject* Group);<br>
-<br>
-public:<br>
- ISOLATE_STATIC void InitializeThreading(Jnjvm* vm);<br>
-};<br>
-<br>
-<br>
-} // end namespace j3<br>
-<br>
-#endif<br>
diff --git a/lib/J3/Classpath/Makefile b/lib/J3/Classpath/Makefile<br>
deleted file mode 100644<br>
index e0d6799..0000000<br>
--- a/lib/J3/Classpath/Makefile<br>
+++ /dev/null<br>
@@ -1,23 +0,0 @@<br>
-##===- lib/JnJVM/Classpath/Makefile ------------------------*-<br>
Makefile -*-===##<br>
-#<br>
-# The vmkit project<br>
-#<br>
-# This file is distributed under the University of Illinois Open Source<br>
-# License. See LICENSE.TXT for details.<br>
-#<br>
-##===----------------------------------------------------------------------===##<br>
-LEVEL = ../../..<br>
-<br>
-<br>
-EXTRA_DIST = ClasspathConstructor.inc ClasspathField.inc<br>
Classpath.inc ClasspathMethod.inc \<br>
- ClasspathVMClass.inc ClasspathVMClassLoader.inc ClasspathVMObject.inc \<br>
- ClasspathVMRuntime.inc ClasspathVMStackWalker.inc ClasspathVMSystem.inc \<br>
- ClasspathVMSystemProperties.inc ClasspathVMThread.inc<br>
ClasspathVMThrowable.inc<br>
-<br>
-include $(LEVEL)/Makefile.config<br>
-<br>
-MODULE_WITH_GC = Classpath<br>
-<br>
-include $(LEVEL)/Makefile.common<br>
-<br>
-CXX.Flags += -I$(PROJ_SRC_DIR)/../VMCore -I$(PROJ_SRC_DIR)/../../../include/j3<br>
diff --git a/lib/J3/Compiler/Makefile b/lib/J3/Compiler/Makefile<br>
index 43cd44a..58bb2e1 100644<br>
--- a/lib/J3/Compiler/Makefile<br>
+++ b/lib/J3/Compiler/Makefile<br>
@@ -14,4 +14,4 @@ MODULE_WITH_GC = J3Compiler<br>
<br>
include $(LEVEL)/Makefile.common<br>
<br>
-CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime<br>
-I$(PROJ_SRC_DIR)/../Classpath -I$(PROJ_SRC_DIR)/../VMCore<br>
+CXX.Flags += -I$(PROJ_OBJ_DIR)/../LLVMRuntime<br>
-I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)<br>
-I$(PROJ_SRC_DIR)/../VMCore<br>
diff --git a/lib/J3/Makefile b/lib/J3/Makefile<br>
index 6f951d6..d6e81dc 100644<br>
--- a/lib/J3/Makefile<br>
+++ b/lib/J3/Makefile<br>
@@ -8,7 +8,7 @@<br>
##===----------------------------------------------------------------------===##<br>
LEVEL = ../..<br>
<br>
-DIRS = LLVMRuntime VMCore Classpath Compiler<br>
+DIRS = LLVMRuntime VMCore ClassLib Compiler<br>
<br>
include $(LEVEL)/Makefile.config<br>
include $(LEVEL)/Makefile.common<br>
diff --git a/lib/J3/VMCore/Makefile b/lib/J3/VMCore/Makefile<br>
index c539835..5e08bd2 100644<br>
--- a/lib/J3/VMCore/Makefile<br>
+++ b/lib/J3/VMCore/Makefile<br>
@@ -14,4 +14,4 @@ MODULE_WITH_GC = J3<br>
<br>
include $(LEVEL)/Makefile.common<br>
<br>
-CXX.Flags += -I$(PROJ_OBJ_DIR)/../Classpath<br>
-I$(PROJ_OBJ_DIR)/../LLVMRuntime -I$(PROJ_SRC_DIR)/../Classpath<br>
-I$(PROJ_SRC_DIR)/../../../include/j3<br>
+CXX.Flags += -I$(PROJ_OBJ_DIR)/../ClassLib/<br>
-I$(PROJ_OBJ_DIR)/../LLVMRuntime<br>
-I$(PROJ_SRC_DIR)/../ClassLib/$(CLASSPATH_DIR)<br>
-I$(PROJ_SRC_DIR)/../../../include/j3<br>
<font color="#888888">--<br>
1.7.5.<br>
_______________________________________________<br>
vmkit-commits mailing list<br>
<a href="mailto:vmkit-commits@cs.uiuc.edu">vmkit-commits@cs.uiuc.edu</a><br>
<a href="http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits" target="_blank">http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits</a><br>
</font></blockquote></div><br>