[vmkit-commits] [PATCH] Move shared Classpath code in ClassLib, copy unshared to OpenJDK/ for modification
Will Dietz
wdietz2 at illinois.edu
Tue Oct 25 14:31:52 PDT 2011
Inlined below, hopefully a good deal clearer.
I'm not sure why it's not showing up this way (and instead shows as
huge diff), but all the new files in OpenJDK are copies of the same
file from GNUClasspath.
"Fixes" for JavaUpcalls and ClasspathReflect coming--they're of course
wrong as-is in the OpenJDK version.
~Will
>From c34f617a97a90e5a1f3391f99035ef1c349ec19d Mon Sep 17 00:00:00 2001
From: Will Dietz <w at wdtz.org>
Date: Fri, 14 Oct 2011 03:28:58 -0500
Subject: [PATCH 3/3] Move Classpath common to shared, copy impl-specific
files to OpenJDK
These files need to now be updated for OpenJDK not Classpath.
---
lib/J3/ClassLib/{GNUClasspath => }/Classpath.inc | 0
.../{GNUClasspath => }/ClasspathConstructor.inc | 0
.../ClassLib/{GNUClasspath => }/ClasspathField.inc | 0
.../{GNUClasspath => }/ClasspathMethod.inc | 0
lib/J3/ClassLib/GNUClasspath/Makefile | 3 +-
lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp | 30 +
lib/J3/ClassLib/OpenJDK/ClasspathReflect.h | 222 ++++
lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp | 1067 ++++++++++++++++++++
lib/J3/ClassLib/OpenJDK/JavaUpcalls.h | 283 ++++++
9 files changed, 1604 insertions(+), 1 deletions(-)
rename lib/J3/ClassLib/{GNUClasspath => }/Classpath.inc (97%)
rename lib/J3/ClassLib/{GNUClasspath => }/ClasspathConstructor.inc (97%)
rename lib/J3/ClassLib/{GNUClasspath => }/ClasspathField.inc (99%)
rename lib/J3/ClassLib/{GNUClasspath => }/ClasspathMethod.inc (96%)
create mode 100644 lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
create mode 100644 lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
create mode 100644 lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
create mode 100644 lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
diff --git a/lib/J3/ClassLib/GNUClasspath/Classpath.inc
b/lib/J3/ClassLib/Classpath.inc
similarity index 97%
rename from lib/J3/ClassLib/GNUClasspath/Classpath.inc
rename to lib/J3/ClassLib/Classpath.inc
index 792b606..b33a5f6 100644
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc
b/lib/J3/ClassLib/ClasspathConstructor.inc
similarity index 97%
rename from lib/J3/ClassLib/GNUClasspath/ClasspathConstructor.inc
rename to lib/J3/ClassLib/ClasspathConstructor.inc
index 90a315b..8c506f4 100644
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathField.inc
b/lib/J3/ClassLib/ClasspathField.inc
similarity index 99%
rename from lib/J3/ClassLib/GNUClasspath/ClasspathField.inc
rename to lib/J3/ClassLib/ClasspathField.inc
index 5082caa..e56c82f 100644
diff --git a/lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc
b/lib/J3/ClassLib/ClasspathMethod.inc
similarity index 96%
rename from lib/J3/ClassLib/GNUClasspath/ClasspathMethod.inc
rename to lib/J3/ClassLib/ClasspathMethod.inc
index ee5792d..fcfea1c 100644
diff --git a/lib/J3/ClassLib/GNUClasspath/Makefile
b/lib/J3/ClassLib/GNUClasspath/Makefile
index 0f910b5..f7e83cc 100644
--- a/lib/J3/ClassLib/GNUClasspath/Makefile
+++ b/lib/J3/ClassLib/GNUClasspath/Makefile
@@ -20,4 +20,5 @@ MODULE_WITH_GC = Classpath
include $(LEVEL)/Makefile.common
-CXX.Flags += -I$(PROJ_SRC_DIR)/../../VMCore -I$(PROJ_SRC_ROOT)/include/j3 -I..
+CXX.Flags += -I$(PROJ_SRC_DIR)/../../VMCore -I$(PROJ_SRC_ROOT)/include/j3
+CXX.Flags += -I$(PROJ_SRC_DIR)/.. -I$(PROJ_OBJ_DIR)/..
diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
new file mode 100644
index 0000000..3d69fa4
--- /dev/null
+++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.cpp
@@ -0,0 +1,30 @@
+//===- ClasspathReflect.cpp - Internal representation of core system
classes -//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClasspathReflect.h"
+#include "JavaClass.h"
+#include "JavaObject.h"
+#include "JavaThread.h"
+
+namespace j3 {
+
+JavaMethod* JavaObjectConstructor::getInternalMethod(JavaObjectConstructor*
self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return &(cls->asClass()->virtualMethods[self->slot]);
+}
+
+
+JavaMethod* JavaObjectMethod::getInternalMethod(JavaObjectMethod* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return &(cls->asClass()->virtualMethods[self->slot]);
+}
+
+}
diff --git a/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
new file mode 100644
index 0000000..494e444
--- /dev/null
+++ b/lib/J3/ClassLib/OpenJDK/ClasspathReflect.h
@@ -0,0 +1,222 @@
+//===-- ClasspathReflect.h - Internal representation of core system
classes --//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef JNJVM_CLASSPATH_REFLECT_H
+#define JNJVM_CLASSPATH_REFLECT_H
+
+#include "MvmGC.h"
+
+#include "JavaClass.h"
+#include "JavaObject.h"
+#include "JavaThread.h"
+
+extern "C" j3::JavaObject* internalFillInStackTrace(j3::JavaObject*);
+
+namespace j3 {
+
+class JavaObjectClass : public JavaObject {
+private:
+ JavaObject* signers;
+ JavaObject* pd;
+ UserCommonClass* vmdata;
+ JavaObject* constructor;
+
+public:
+
+ static UserCommonClass* getClass(JavaObjectClass* cl) {
+ llvm_gcroot(cl, 0);
+ return cl->vmdata;
+ }
+
+ static void setClass(JavaObjectClass* cl, UserCommonClass* vmdata) {
+ llvm_gcroot(cl, 0);
+ cl->vmdata = vmdata;
+ }
+
+ static void setProtectionDomain(JavaObjectClass* cl, JavaObject* pd) {
+ llvm_gcroot(cl, 0);
+ llvm_gcroot(pd, 0);
+ mvm::Collector::objectReferenceWriteBarrier(
+ (gc*)cl, (gc**)&(cl->pd), (gc*)pd);
+ }
+
+ static JavaObject* getProtectionDomain(JavaObjectClass* cl) {
+ llvm_gcroot(cl, 0);
+ return cl->pd;
+ }
+
+ static void staticTracer(JavaObjectClass* obj, word_t closure) {
+ mvm::Collector::markAndTrace(obj, &obj->pd, closure);
+ mvm::Collector::markAndTrace(obj, &obj->signers, closure);
+ mvm::Collector::markAndTrace(obj, &obj->constructor, closure);
+ if (obj->vmdata) {
+ JavaObject** Obj = obj->vmdata->classLoader->getJavaClassLoaderPtr();
+ if (*Obj) mvm::Collector::markAndTraceRoot(Obj, closure);
+ }
+ }
+};
+
+class JavaObjectField : public JavaObject {
+private:
+ uint8 flag;
+ JavaObjectClass* declaringClass;
+ JavaObject* name;
+ uint32 slot;
+
+public:
+
+ static void staticTracer(JavaObjectField* obj, word_t closure) {
+ mvm::Collector::markAndTrace(obj, &obj->name, closure);
+ mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ }
+
+ static JavaField* getInternalField(JavaObjectField* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return &(cls->asClass()->virtualFields[self->slot]);
+ }
+
+ static UserClass* getClass(JavaObjectField* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return cls->asClass();
+ }
+
+};
+
+class JavaObjectMethod : public JavaObject {
+private:
+ uint8 flag;
+ JavaObjectClass* declaringClass;
+ JavaObject* name;
+ uint32 slot;
+
+public:
+
+ static void staticTracer(JavaObjectMethod* obj, word_t closure) {
+ mvm::Collector::markAndTrace(obj, &obj->name, closure);
+ mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ }
+
+ static JavaMethod* getInternalMethod(JavaObjectMethod* self);
+
+ static UserClass* getClass(JavaObjectMethod* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return cls->asClass();
+ }
+
+};
+
+class JavaObjectConstructor : public JavaObject {
+private:
+ uint8 flag;
+ JavaObjectClass* declaringClass;
+ uint32 slot;
+
+public:
+ static void staticTracer(JavaObjectConstructor* obj, word_t closure) {
+ mvm::Collector::markAndTrace(obj, &obj->declaringClass, closure);
+ }
+
+ static JavaMethod* getInternalMethod(JavaObjectConstructor* self);
+
+ static UserClass* getClass(JavaObjectConstructor* self) {
+ llvm_gcroot(self, 0);
+ UserCommonClass* cls = JavaObjectClass::getClass(self->declaringClass);
+ return cls->asClass();
+ }
+
+};
+
+class JavaObjectVMThread : public JavaObject {
+private:
+ JavaObject* thread;
+ bool running;
+ JavaThread* vmdata;
+
+public:
+ static void staticTracer(JavaObjectVMThread* obj, word_t closure) {
+ mvm::Collector::markAndTrace(obj, &obj->thread, closure);
+ }
+
+ static void setVmdata(JavaObjectVMThread* vmthread,
+ JavaThread* internal_thread) {
+ llvm_gcroot(vmthread, 0);
+ vmthread->vmdata = internal_thread;
+ }
+
+};
+
+
+class JavaObjectThrowable : public JavaObject {
+private:
+ JavaObject* detailedMessage;
+ JavaObject* cause;
+ JavaObject* stackTrace;
+ JavaObject* vmState;
+
+public:
+
+ static void setDetailedMessage(JavaObjectThrowable* self, JavaObject* obj) {
+ llvm_gcroot(self, 0);
+ llvm_gcroot(obj, 0);
+ mvm::Collector::objectReferenceWriteBarrier(
+ (gc*)self, (gc**)&(self->detailedMessage), (gc*)obj);
+ }
+
+ static void fillInStackTrace(JavaObjectThrowable* self) {
+ JavaObject* stackTrace = NULL;
+ llvm_gcroot(self, 0);
+ llvm_gcroot(stackTrace, 0);
+
+ stackTrace = internalFillInStackTrace(self);
+ mvm::Collector::objectReferenceWriteBarrier(
+ (gc*)self, (gc**)&(self->vmState), (gc*)stackTrace);
+
+ mvm::Collector::objectReferenceWriteBarrier(
+ (gc*)self, (gc**)&(self->cause), (gc*)self);
+
+ self->stackTrace = NULL;
+ }
+};
+
+class JavaObjectReference : public JavaObject {
+private:
+ JavaObject* referent;
+ JavaObject* queue;
+ JavaObject* nextOnQueue;
+
+public:
+ static void init(JavaObjectReference* self, JavaObject* r, JavaObject* q) {
+ llvm_gcroot(self, 0);
+ llvm_gcroot(r, 0);
+ llvm_gcroot(q, 0);
+ mvm::Collector::objectReferenceWriteBarrier(
+ (gc*)self, (gc**)&(self->referent), (gc*)r);
+ mvm::Collector::objectReferenceWriteBarrier(
+ (gc*)self, (gc**)&(self->queue), (gc*)q);
+ }
+
+ static JavaObject** getReferentPtr(JavaObjectReference* self) {
+ llvm_gcroot(self, 0);
+ return &(self->referent);
+ }
+
+ static void setReferent(JavaObjectReference* self, JavaObject* r) {
+ llvm_gcroot(self, 0);
+ llvm_gcroot(r, 0);
+ // No write barrier: this is only called by the GC.
+ self->referent = r;
+ }
+};
+
+}
+
+#endif
diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
new file mode 100644
index 0000000..11226b3
--- /dev/null
+++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.cpp
@@ -0,0 +1,1067 @@
+//===-------- JavaUpcalls.cpp - Upcalls to Java entities
------------------===//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ClasspathReflect.h"
+#include "JavaAccess.h"
+#include "JavaClass.h"
+#include "JavaObject.h"
+#include "JavaString.h"
+#include "JavaThread.h"
+#include "JavaUpcalls.h"
+#include "Jnjvm.h"
+#include "ReferenceQueue.h"
+
+#define COMPILE_METHODS(cl) \
+ for (CommonClass::method_iterator i = cl->virtualMethods.begin(), \
+ e = cl->virtualMethods.end(); i!= e; ++i) { \
+ i->second->compiledPtr(); \
+ } \
+ \
+ for (CommonClass::method_iterator i = cl->staticMethods.begin(), \
+ e = cl->staticMethods.end(); i!= e; ++i) { \
+ i->second->compiledPtr(); \
+ }
+
+
+using namespace j3;
+
+Class* Classpath::newThread;
+Class* Classpath::newVMThread;
+JavaField* Classpath::assocThread;
+JavaField* Classpath::vmdataVMThread;
+JavaMethod* Classpath::finaliseCreateInitialThread;
+JavaMethod* Classpath::initVMThread;
+JavaMethod* Classpath::initThread;
+JavaMethod* Classpath::groupAddThread;
+JavaField* Classpath::threadName;
+JavaField* Classpath::groupName;
+JavaMethod* Classpath::initGroup;
+JavaField* Classpath::priority;
+JavaField* Classpath::daemon;
+JavaField* Classpath::group;
+JavaField* Classpath::running;
+Class* Classpath::threadGroup;
+JavaField* Classpath::rootGroup;
+JavaField* Classpath::vmThread;
+JavaMethod* Classpath::getUncaughtExceptionHandler;
+JavaMethod* Classpath::uncaughtException;
+Class* Classpath::inheritableThreadLocal;
+
+JavaMethod* Classpath::runVMThread;
+JavaMethod* Classpath::setContextClassLoader;
+JavaMethod* Classpath::getSystemClassLoader;
+Class* Classpath::newString;
+Class* Classpath::newClass;
+Class* Classpath::newThrowable;
+Class* Classpath::newException;
+JavaMethod* Classpath::initClass;
+JavaMethod* Classpath::initClassWithProtectionDomain;
+JavaField* Classpath::vmdataClass;
+JavaMethod* Classpath::setProperty;
+JavaMethod* Classpath::initString;
+JavaMethod* Classpath::getCallingClassLoader;
+JavaMethod* Classpath::initConstructor;
+Class* Classpath::newConstructor;
+ClassArray* Classpath::constructorArrayClass;
+ClassArray* Classpath::constructorArrayAnnotation;
+JavaField* Classpath::constructorSlot;
+JavaMethod* Classpath::initMethod;
+JavaMethod* Classpath::initField;
+Class* Classpath::newField;
+Class* Classpath::newMethod;
+ClassArray* Classpath::methodArrayClass;
+ClassArray* Classpath::fieldArrayClass;
+JavaField* Classpath::methodSlot;
+JavaField* Classpath::fieldSlot;
+ClassArray* Classpath::classArrayClass;
+JavaMethod* Classpath::loadInClassLoader;
+JavaMethod* Classpath::initVMThrowable;
+JavaField* Classpath::vmDataVMThrowable;
+Class* Classpath::newVMThrowable;
+JavaField* Classpath::bufferAddress;
+JavaField* Classpath::dataPointer32;
+JavaField* Classpath::dataPointer64;
+Class* Classpath::newPointer32;
+Class* Classpath::newPointer64;
+Class* Classpath::newDirectByteBuffer;
+JavaField* Classpath::vmdataClassLoader;
+JavaMethod* Classpath::InitDirectByteBuffer;
+Class* Classpath::newClassLoader;
+
+
+JavaField* Classpath::boolValue;
+JavaField* Classpath::byteValue;
+JavaField* Classpath::shortValue;
+JavaField* Classpath::charValue;
+JavaField* Classpath::intValue;
+JavaField* Classpath::longValue;
+JavaField* Classpath::floatValue;
+JavaField* Classpath::doubleValue;
+
+Class* Classpath::newStackTraceElement;
+ClassArray* Classpath::stackTraceArray;
+JavaMethod* Classpath::initStackTraceElement;
+
+Class* Classpath::voidClass;
+Class* Classpath::boolClass;
+Class* Classpath::byteClass;
+Class* Classpath::shortClass;
+Class* Classpath::charClass;
+Class* Classpath::intClass;
+Class* Classpath::floatClass;
+Class* Classpath::doubleClass;
+Class* Classpath::longClass;
+
+Class* Classpath::vmStackWalker;
+
+Class* Classpath::InvocationTargetException;
+Class* Classpath::ArrayStoreException;
+Class* Classpath::ClassCastException;
+Class* Classpath::IllegalMonitorStateException;
+Class* Classpath::IllegalArgumentException;
+Class* Classpath::InterruptedException;
+Class* Classpath::IndexOutOfBoundsException;
+Class* Classpath::ArrayIndexOutOfBoundsException;
+Class* Classpath::NegativeArraySizeException;
+Class* Classpath::NullPointerException;
+Class* Classpath::SecurityException;
+Class* Classpath::ClassFormatError;
+Class* Classpath::ClassCircularityError;
+Class* Classpath::NoClassDefFoundError;
+Class* Classpath::UnsupportedClassVersionError;
+Class* Classpath::NoSuchFieldError;
+Class* Classpath::NoSuchMethodError;
+Class* Classpath::InstantiationError;
+Class* Classpath::InstantiationException;
+Class* Classpath::IllegalAccessError;
+Class* Classpath::IllegalAccessException;
+Class* Classpath::VerifyError;
+Class* Classpath::ExceptionInInitializerError;
+Class* Classpath::LinkageError;
+Class* Classpath::AbstractMethodError;
+Class* Classpath::UnsatisfiedLinkError;
+Class* Classpath::InternalError;
+Class* Classpath::OutOfMemoryError;
+Class* Classpath::StackOverflowError;
+Class* Classpath::UnknownError;
+Class* Classpath::ClassNotFoundException;
+Class* Classpath::ArithmeticException;
+
+JavaMethod* Classpath::InitInvocationTargetException;
+JavaMethod* Classpath::InitArrayStoreException;
+JavaMethod* Classpath::InitClassCastException;
+JavaMethod* Classpath::InitIllegalMonitorStateException;
+JavaMethod* Classpath::InitIllegalArgumentException;
+JavaMethod* Classpath::InitInterruptedException;
+JavaMethod* Classpath::InitIndexOutOfBoundsException;
+JavaMethod* Classpath::InitArrayIndexOutOfBoundsException;
+JavaMethod* Classpath::InitNegativeArraySizeException;
+JavaMethod* Classpath::InitNullPointerException;
+JavaMethod* Classpath::InitSecurityException;
+JavaMethod* Classpath::InitClassFormatError;
+JavaMethod* Classpath::InitClassCircularityError;
+JavaMethod* Classpath::InitNoClassDefFoundError;
+JavaMethod* Classpath::InitUnsupportedClassVersionError;
+JavaMethod* Classpath::InitNoSuchFieldError;
+JavaMethod* Classpath::InitNoSuchMethodError;
+JavaMethod* Classpath::InitInstantiationError;
+JavaMethod* Classpath::InitInstantiationException;
+JavaMethod* Classpath::InitIllegalAccessError;
+JavaMethod* Classpath::InitIllegalAccessException;
+JavaMethod* Classpath::InitVerifyError;
+JavaMethod* Classpath::InitExceptionInInitializerError;
+JavaMethod* Classpath::InitLinkageError;
+JavaMethod* Classpath::InitAbstractMethodError;
+JavaMethod* Classpath::InitUnsatisfiedLinkError;
+JavaMethod* Classpath::InitInternalError;
+JavaMethod* Classpath::InitOutOfMemoryError;
+JavaMethod* Classpath::InitStackOverflowError;
+JavaMethod* Classpath::InitUnknownError;
+JavaMethod* Classpath::InitClassNotFoundException;
+JavaMethod* Classpath::InitArithmeticException;
+JavaMethod* Classpath::InitObject;
+JavaMethod* Classpath::FinalizeObject;
+JavaMethod* Classpath::IntToString;
+
+JavaMethod* Classpath::SystemArraycopy;
+JavaMethod* Classpath::VMSystemArraycopy;
+Class* Classpath::SystemClass;
+Class* Classpath::EnumClass;
+
+JavaMethod* Classpath::ErrorWithExcpNoClassDefFoundError;
+JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;
+JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;
+
+ClassArray* Classpath::ArrayOfByte;
+ClassArray* Classpath::ArrayOfChar;
+ClassArray* Classpath::ArrayOfString;
+ClassArray* Classpath::ArrayOfInt;
+ClassArray* Classpath::ArrayOfShort;
+ClassArray* Classpath::ArrayOfBool;
+ClassArray* Classpath::ArrayOfLong;
+ClassArray* Classpath::ArrayOfFloat;
+ClassArray* Classpath::ArrayOfDouble;
+ClassArray* Classpath::ArrayOfObject;
+
+ClassPrimitive* Classpath::OfByte;
+ClassPrimitive* Classpath::OfChar;
+ClassPrimitive* Classpath::OfInt;
+ClassPrimitive* Classpath::OfShort;
+ClassPrimitive* Classpath::OfBool;
+ClassPrimitive* Classpath::OfLong;
+ClassPrimitive* Classpath::OfFloat;
+ClassPrimitive* Classpath::OfDouble;
+ClassPrimitive* Classpath::OfVoid;
+
+Class* Classpath::OfObject;
+
+JavaField* Classpath::methodClass;
+JavaField* Classpath::fieldClass;
+JavaField* Classpath::constructorClass;
+
+JavaMethod* Classpath::EnqueueReference;
+Class* Classpath::newReference;
+
+void Classpath::CreateJavaThread(Jnjvm* vm, JavaThread* myth,
+ const char* thName, JavaObject* Group) {
+ JavaObjectVMThread* vmth = NULL;
+ JavaObject* th = NULL;
+ JavaObject* name = NULL;
+ llvm_gcroot(Group, 0);
+ llvm_gcroot(vmth, 0);
+ llvm_gcroot(th, 0);
+ llvm_gcroot(name, 0);
+
+ th = newThread->doNew(vm);
+ myth->javaThread = th;
+ vmth = (JavaObjectVMThread*)newVMThread->doNew(vm);
+ name = vm->asciizToStr(thName);
+
+ initThread->invokeIntSpecial(vm, newThread, th, &vmth, &name, 1, 0);
+ vmThread->setInstanceObjectField(th, vmth);
+ assocThread->setInstanceObjectField(vmth, th);
+ running->setInstanceInt8Field(vmth, (uint32)1);
+ JavaObjectVMThread::setVmdata(vmth, myth);
+
+ group->setInstanceObjectField(th, Group);
+ groupAddThread->invokeIntSpecial(vm, threadGroup, Group, &th);
+
+ finaliseCreateInitialThread->invokeIntStatic(vm,
inheritableThreadLocal, &th);
+}
+
+void Classpath::InitializeThreading(Jnjvm* vm) {
+
+ JavaObject* RG = 0;
+ JavaObject* SystemGroup = 0;
+ JavaObject* systemName = 0;
+ llvm_gcroot(RG, 0);
+ llvm_gcroot(SystemGroup, 0);
+ llvm_gcroot(systemName, 0);
+
+ // Resolve and initialize classes first.
+ newThread->resolveClass();
+ newThread->initialiseClass(vm);
+
+ newVMThread->resolveClass();
+ newVMThread->initialiseClass(vm);
+
+ threadGroup->resolveClass();
+ threadGroup->initialiseClass(vm);
+
+ // Create the main thread
+ RG = rootGroup->getStaticObjectField();
+ assert(RG && "No root group");
+ assert(vm->getMainThread() && "VM did not set its main thread");
+ CreateJavaThread(vm, (JavaThread*)vm->getMainThread(), "main", RG);
+
+ // Create the "system" group.
+ SystemGroup = threadGroup->doNew(vm);
+ initGroup->invokeIntSpecial(vm, threadGroup, SystemGroup);
+ systemName = vm->asciizToStr("system");
+ groupName->setInstanceObjectField(SystemGroup, systemName);
+
+ // Create the finalizer thread.
+ assert(vm->getFinalizerThread() && "VM did not set its finalizer thread");
+ CreateJavaThread(vm, vm->getFinalizerThread(), "Finalizer", SystemGroup);
+
+ // Create the enqueue thread.
+ assert(vm->getReferenceThread() && "VM did not set its enqueue thread");
+ CreateJavaThread(vm, vm->getReferenceThread(), "Reference", SystemGroup);
+}
+
+extern "C" void
Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2(
+ JavaObjectReference* reference, JavaObject* referent) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaObjectReference::init(reference, referent, 0);
+ JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);
+
+ END_NATIVE_EXCEPTION
+
+}
+
+extern "C" void
Java_java_lang_ref_WeakReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
+ JavaObjectReference* reference,
+ JavaObject* referent,
+ JavaObject* queue) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+ llvm_gcroot(queue, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaObjectReference::init(reference, referent, queue);
+ JavaThread::get()->getJVM()->getReferenceThread()->addWeakReference(reference);
+
+ END_NATIVE_EXCEPTION
+
+}
+
+extern "C" void
Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2(
+ JavaObjectReference* reference, JavaObject* referent) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaObjectReference::init(reference, referent, 0);
+ JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);
+
+ END_NATIVE_EXCEPTION
+
+}
+
+extern "C" void
Java_java_lang_ref_SoftReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
+ JavaObjectReference* reference,
+ JavaObject* referent,
+ JavaObject* queue) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+ llvm_gcroot(queue, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaObjectReference::init(reference, referent, queue);
+ JavaThread::get()->getJVM()->getReferenceThread()->addSoftReference(reference);
+
+ END_NATIVE_EXCEPTION
+
+}
+
+extern "C" void
Java_java_lang_ref_PhantomReference__0003Cinit_0003E__Ljava_lang_Object_2Ljava_lang_ref_ReferenceQueue_2(
+ JavaObjectReference* reference,
+ JavaObject* referent,
+ JavaObject* queue) {
+ llvm_gcroot(reference, 0);
+ llvm_gcroot(referent, 0);
+ llvm_gcroot(queue, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaObjectReference::init(reference, referent, queue);
+ JavaThread::get()->getJVM()->getReferenceThread()->addPhantomReference(reference);
+
+ END_NATIVE_EXCEPTION
+}
+
+extern "C" JavaString* Java_java_lang_VMString_intern__Ljava_lang_String_2(
+ JavaString* obj) {
+ const ArrayUInt16* array = 0;
+ JavaString* res = 0;
+ llvm_gcroot(obj, 0);
+ llvm_gcroot(array, 0);
+ llvm_gcroot(res, 0);
+ // If the string is already interned, just return.
+ if (obj->getVirtualTable() == JavaString::internStringVT) return obj;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ array = JavaString::strToArray(obj, vm);
+ res = vm->constructString(array);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+extern "C" uint8 Java_java_lang_Class_isArray__(JavaObjectClass* klass) {
+ llvm_gcroot(klass, 0);
+ UserCommonClass* cl = 0;
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ cl = JavaObjectClass::getClass(klass);
+
+ END_NATIVE_EXCEPTION
+
+ return (uint8)cl->isArray();
+}
+
+extern "C" JavaObject* Java_gnu_classpath_VMStackWalker_getCallingClass__() {
+
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ UserClass* cl = th->getCallingClassLevel(2);
+ if (cl != NULL) res = cl->getClassDelegatee(th->getJVM());
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+extern "C" JavaObject*
Java_gnu_classpath_VMStackWalker_getCallingClassLoader__() {
+
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ UserClass* cl = th->getCallingClassLevel(2);
+ res = cl->classLoader->getJavaClassLoader();
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+extern "C" JavaObject*
Java_gnu_classpath_VMStackWalker_firstNonNullClassLoader__() {
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ res = th->getNonNullClassLoader();
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+extern "C" JavaObject*
Java_sun_reflect_Reflection_getCallerClass__I(uint32 index) {
+
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ JavaThread* th = JavaThread::get();
+ Jnjvm* vm = th->getJVM();
+ UserClass* cl = th->getCallingClassLevel(index);
+ if (cl) res = cl->getClassDelegatee(vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+extern "C" JavaObject*
Java_java_lang_reflect_AccessibleObject_getAnnotation__Ljava_lang_Class_2(
+ JavaObject* obj) {
+ llvm_gcroot(obj, 0);
+ return 0;
+}
+
+extern "C" JavaObject*
Java_java_lang_reflect_AccessibleObject_getDeclaredAnnotations__() {
+ JavaObject* res = 0;
+ llvm_gcroot(res, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ UserClassArray* array = vm->upcalls->constructorArrayAnnotation;
+ res = array->doNew(0, vm);
+
+ END_NATIVE_EXCEPTION
+
+ return res;
+}
+
+extern "C" void nativeJavaObjectClassTracer(
+ JavaObjectClass* obj, word_t closure) {
+ JavaObjectClass::staticTracer(obj, closure);
+}
+
+extern "C" void nativeJavaObjectFieldTracer(
+ JavaObjectField* obj, word_t closure) {
+ JavaObjectField::staticTracer(obj, closure);
+}
+
+extern "C" void nativeJavaObjectMethodTracer(
+ JavaObjectMethod* obj, word_t closure) {
+ JavaObjectMethod::staticTracer(obj, closure);
+}
+
+extern "C" void nativeJavaObjectConstructorTracer(
+ JavaObjectConstructor* obj, word_t closure) {
+ JavaObjectConstructor::staticTracer(obj, closure);
+}
+
+extern "C" void nativeJavaObjectVMThreadTracer(
+ JavaObjectVMThread* obj, word_t closure) {
+ JavaObjectVMThread::staticTracer(obj, closure);
+}
+
+extern "C" JavaString*
Java_java_lang_VMSystem_getenv__Ljava_lang_String_2(JavaString* str) {
+ JavaString* ret = 0;
+ llvm_gcroot(str, 0);
+ llvm_gcroot(ret, 0);
+
+ BEGIN_NATIVE_EXCEPTION(0)
+
+ mvm::ThreadAllocator allocator;
+ char* buf = JavaString::strToAsciiz(str, &allocator);
+ char* res = getenv(buf);
+ if (res) {
+ Jnjvm* vm = JavaThread::get()->getJVM();
+ ret = vm->asciizToStr(res);
+ }
+
+ END_NATIVE_EXCEPTION
+
+ return ret;
+}
+
+void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
+
+ newClassLoader =
+ UPCALL_CLASS(loader, "java/lang/ClassLoader");
+
+ getSystemClassLoader =
+ UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader",
+ "()Ljava/lang/ClassLoader;", ACC_STATIC);
+
+ setContextClassLoader =
+ UPCALL_METHOD(loader, "java/lang/Thread", "setContextClassLoader",
+ "(Ljava/lang/ClassLoader;)V", ACC_VIRTUAL);
+
+ newString =
+ UPCALL_CLASS(loader, "java/lang/String");
+
+ newClass =
+ UPCALL_CLASS(loader, "java/lang/Class");
+
+ newThrowable =
+ UPCALL_CLASS(loader, "java/lang/Throwable");
+
+ newException =
+ UPCALL_CLASS(loader, "java/lang/Exception");
+
+ newPointer32 =
+ UPCALL_CLASS(loader, "gnu/classpath/Pointer32");
+
+ newPointer64 =
+ UPCALL_CLASS(loader, "gnu/classpath/Pointer64");
+
+ newDirectByteBuffer =
+ UPCALL_CLASS(loader, "java/nio/DirectByteBufferImpl$ReadWrite");
+
+ InitDirectByteBuffer =
+ UPCALL_METHOD(loader, "java/nio/DirectByteBufferImpl$ReadWrite", "<init>",
+ "(Ljava/lang/Object;Lgnu/classpath/Pointer;III)V",
+ ACC_VIRTUAL);
+
+ initClass =
+ UPCALL_METHOD(loader, "java/lang/Class", "<init>", "(Ljava/lang/Object;)V",
+ ACC_VIRTUAL);
+
+ initClassWithProtectionDomain =
+ UPCALL_METHOD(loader, "java/lang/Class", "<init>",
+ "(Ljava/lang/Object;Ljava/security/ProtectionDomain;)V",
+ ACC_VIRTUAL);
+
+ vmdataClass =
+ UPCALL_FIELD(loader, "java/lang/Class", "vmdata", "Ljava/lang/Object;",
+ ACC_VIRTUAL);
+
+ setProperty =
+ UPCALL_METHOD(loader, "java/util/Properties", "setProperty",
+ "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
+ ACC_VIRTUAL);
+
+ initString =
+ UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V",
ACC_VIRTUAL);
+
+ initConstructor =
+ UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",
+ "(Ljava/lang/Class;I)V", ACC_VIRTUAL);
+
+ newConstructor =
+ UPCALL_CLASS(loader, "java/lang/reflect/Constructor");
+
+ constructorArrayClass =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);
+
+ constructorArrayAnnotation =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);
+
+ constructorSlot =
+ UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot",
"I", ACC_VIRTUAL);
+
+ initMethod =
+ UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",
+ "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
+
+ newMethod =
+ UPCALL_CLASS(loader, "java/lang/reflect/Method");
+
+ methodArrayClass =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);
+
+ methodSlot =
+ UPCALL_FIELD(loader, "java/lang/reflect/Method", "slot", "I", ACC_VIRTUAL);
+
+ initField =
+ UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",
+ "(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
+
+ newField =
+ UPCALL_CLASS(loader, "java/lang/reflect/Field");
+
+ fieldArrayClass =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);
+
+ fieldSlot =
+ UPCALL_FIELD(loader, "java/lang/reflect/Field", "slot", "I", ACC_VIRTUAL);
+
+
+ classArrayClass =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);
+
+ newVMThrowable =
+ UPCALL_CLASS(loader, "java/lang/VMThrowable");
+
+ initVMThrowable =
+ UPCALL_METHOD(loader, "java/lang/VMThrowable", "<init>", "()V",
ACC_VIRTUAL);
+
+ vmDataVMThrowable =
+ UPCALL_FIELD(loader, "java/lang/VMThrowable", "vmdata",
"Ljava/lang/Object;",
+ ACC_VIRTUAL);
+
+ bufferAddress =
+ UPCALL_FIELD(loader, "java/nio/Buffer", "address",
"Lgnu/classpath/Pointer;",
+ ACC_VIRTUAL);
+
+ dataPointer32 =
+ UPCALL_FIELD(loader, "gnu/classpath/Pointer32", "data", "I", ACC_VIRTUAL);
+
+ dataPointer64 =
+ UPCALL_FIELD(loader, "gnu/classpath/Pointer64", "data", "J", ACC_VIRTUAL);
+
+ vmdataClassLoader =
+ UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata",
"Ljava/lang/Object;",
+ ACC_VIRTUAL);
+
+ newStackTraceElement =
+ UPCALL_CLASS(loader, "java/lang/StackTraceElement");
+
+ stackTraceArray =
+ UPCALL_ARRAY_CLASS(loader, "java/lang/StackTraceElement", 1);
+
+ initStackTraceElement =
+ UPCALL_METHOD(loader, "java/lang/StackTraceElement", "<init>",
+
"(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Z)V",
+ ACC_VIRTUAL);
+
+ boolValue =
+ UPCALL_FIELD(loader, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);
+
+ byteValue =
+ UPCALL_FIELD(loader, "java/lang/Byte", "value", "B", ACC_VIRTUAL);
+
+ shortValue =
+ UPCALL_FIELD(loader, "java/lang/Short", "value", "S", ACC_VIRTUAL);
+
+ charValue =
+ UPCALL_FIELD(loader, "java/lang/Character", "value", "C", ACC_VIRTUAL);
+
+ intValue =
+ UPCALL_FIELD(loader, "java/lang/Integer", "value", "I", ACC_VIRTUAL);
+
+ longValue =
+ UPCALL_FIELD(loader, "java/lang/Long", "value", "J", ACC_VIRTUAL);
+
+ floatValue =
+ UPCALL_FIELD(loader, "java/lang/Float", "value", "F", ACC_VIRTUAL);
+
+ doubleValue =
+ UPCALL_FIELD(loader, "java/lang/Double", "value", "D", ACC_VIRTUAL);
+
+ Classpath::voidClass =
+ UPCALL_CLASS(loader, "java/lang/Void");
+
+ Classpath::boolClass =
+ UPCALL_CLASS(loader, "java/lang/Boolean");
+
+ Classpath::byteClass =
+ UPCALL_CLASS(loader, "java/lang/Byte");
+
+ Classpath::shortClass =
+ UPCALL_CLASS(loader, "java/lang/Short");
+
+ Classpath::charClass =
+ UPCALL_CLASS(loader, "java/lang/Character");
+
+ Classpath::intClass =
+ UPCALL_CLASS(loader, "java/lang/Integer");
+
+ Classpath::floatClass =
+ UPCALL_CLASS(loader, "java/lang/Float");
+
+ Classpath::doubleClass =
+ UPCALL_CLASS(loader, "java/lang/Double");
+
+ Classpath::longClass =
+ UPCALL_CLASS(loader, "java/lang/Long");
+
+ Classpath::OfObject =
+ UPCALL_CLASS(loader, "java/lang/Object");
+
+ vmStackWalker =
+ UPCALL_CLASS(loader, "gnu/classpath/VMStackWalker");
+
+ loadInClassLoader =
+ UPCALL_METHOD(loader, "java/lang/ClassLoader", "loadClass",
+ "(Ljava/lang/String;)Ljava/lang/Class;", ACC_VIRTUAL);
+
+ JavaMethod* internString =
+ UPCALL_METHOD(loader, "java/lang/VMString", "intern",
+ "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
+ internString->setNative();
+
+ JavaMethod* isArray =
+ UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL);
+ isArray->setNative();
+
+ // Make sure classes the JIT optimizes on are loaded.
+ UPCALL_CLASS(loader, "java/lang/VMFloat");
+ UPCALL_CLASS(loader, "java/lang/VMDouble");
+
+ UPCALL_REFLECT_CLASS_EXCEPTION(loader, InvocationTargetException);
+ UPCALL_CLASS_EXCEPTION(loader, ArrayStoreException);
+ UPCALL_CLASS_EXCEPTION(loader, ClassCastException);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalMonitorStateException);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalArgumentException);
+ UPCALL_CLASS_EXCEPTION(loader, InterruptedException);
+ UPCALL_CLASS_EXCEPTION(loader, IndexOutOfBoundsException);
+ UPCALL_CLASS_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
+ UPCALL_CLASS_EXCEPTION(loader, NegativeArraySizeException);
+ UPCALL_CLASS_EXCEPTION(loader, NullPointerException);
+ UPCALL_CLASS_EXCEPTION(loader, SecurityException);
+ UPCALL_CLASS_EXCEPTION(loader, ClassFormatError);
+ UPCALL_CLASS_EXCEPTION(loader, ClassCircularityError);
+ UPCALL_CLASS_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_CLASS_EXCEPTION(loader, UnsupportedClassVersionError);
+ UPCALL_CLASS_EXCEPTION(loader, NoSuchFieldError);
+ UPCALL_CLASS_EXCEPTION(loader, NoSuchMethodError);
+ UPCALL_CLASS_EXCEPTION(loader, InstantiationError);
+ UPCALL_CLASS_EXCEPTION(loader, InstantiationException);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalAccessError);
+ UPCALL_CLASS_EXCEPTION(loader, IllegalAccessException);
+ UPCALL_CLASS_EXCEPTION(loader, VerifyError);
+ UPCALL_CLASS_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_CLASS_EXCEPTION(loader, LinkageError);
+ UPCALL_CLASS_EXCEPTION(loader, AbstractMethodError);
+ UPCALL_CLASS_EXCEPTION(loader, UnsatisfiedLinkError);
+ UPCALL_CLASS_EXCEPTION(loader, InternalError);
+ UPCALL_CLASS_EXCEPTION(loader, OutOfMemoryError);
+ UPCALL_CLASS_EXCEPTION(loader, StackOverflowError);
+ UPCALL_CLASS_EXCEPTION(loader, UnknownError);
+ UPCALL_CLASS_EXCEPTION(loader, ClassNotFoundException);
+ UPCALL_CLASS_EXCEPTION(loader, ArithmeticException);
+
+ UPCALL_METHOD_EXCEPTION(loader, InvocationTargetException);
+ UPCALL_METHOD_EXCEPTION(loader, ArrayStoreException);
+ UPCALL_METHOD_EXCEPTION(loader, ClassCastException);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalMonitorStateException);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalArgumentException);
+ UPCALL_METHOD_EXCEPTION(loader, InterruptedException);
+ UPCALL_METHOD_EXCEPTION(loader, IndexOutOfBoundsException);
+ UPCALL_METHOD_EXCEPTION(loader, ArrayIndexOutOfBoundsException);
+ UPCALL_METHOD_EXCEPTION(loader, NegativeArraySizeException);
+ UPCALL_METHOD_EXCEPTION(loader, NullPointerException);
+ UPCALL_METHOD_EXCEPTION(loader, SecurityException);
+ UPCALL_METHOD_EXCEPTION(loader, ClassFormatError);
+ UPCALL_METHOD_EXCEPTION(loader, ClassCircularityError);
+ UPCALL_METHOD_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_METHOD_EXCEPTION(loader, UnsupportedClassVersionError);
+ UPCALL_METHOD_EXCEPTION(loader, NoSuchFieldError);
+ UPCALL_METHOD_EXCEPTION(loader, NoSuchMethodError);
+ UPCALL_METHOD_EXCEPTION(loader, InstantiationError);
+ UPCALL_METHOD_EXCEPTION(loader, InstantiationException);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalAccessError);
+ UPCALL_METHOD_EXCEPTION(loader, IllegalAccessException);
+ UPCALL_METHOD_EXCEPTION(loader, VerifyError);
+ UPCALL_METHOD_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_METHOD_EXCEPTION(loader, LinkageError);
+ UPCALL_METHOD_EXCEPTION(loader, AbstractMethodError);
+ UPCALL_METHOD_EXCEPTION(loader, UnsatisfiedLinkError);
+ UPCALL_METHOD_EXCEPTION(loader, InternalError);
+ UPCALL_METHOD_EXCEPTION(loader, OutOfMemoryError);
+ UPCALL_METHOD_EXCEPTION(loader, StackOverflowError);
+ UPCALL_METHOD_EXCEPTION(loader, UnknownError);
+ UPCALL_METHOD_EXCEPTION(loader, ClassNotFoundException);
+ UPCALL_METHOD_EXCEPTION(loader, ArithmeticException);
+
+ UPCALL_METHOD_WITH_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);
+
+ InitObject = UPCALL_METHOD(loader, "java/lang/Object", "<init>", "()V",
+ ACC_VIRTUAL);
+
+ FinalizeObject = UPCALL_METHOD(loader, "java/lang/Object", "finalize", "()V",
+ ACC_VIRTUAL);
+
+ IntToString = UPCALL_METHOD(loader, "java/lang/Integer", "toString",
+ "(II)Ljava/lang/String;", ACC_STATIC);
+
+ SystemArraycopy = UPCALL_METHOD(loader, "java/lang/System", "arraycopy",
+ "(Ljava/lang/Object;ILjava/lang/Object;II)V",
+ ACC_STATIC);
+
+ VMSystemArraycopy = UPCALL_METHOD(loader, "java/lang/VMSystem", "arraycopy",
+ "(Ljava/lang/Object;ILjava/lang/Object;II)V",
+ ACC_STATIC);
+
+ SystemClass = UPCALL_CLASS(loader, "java/lang/System");
+ EnumClass = UPCALL_CLASS(loader, "java/lang/Enum");
+
+ newThread =
+ UPCALL_CLASS(loader, "java/lang/Thread");
+
+ newVMThread =
+ UPCALL_CLASS(loader, "java/lang/VMThread");
+
+ assocThread =
+ UPCALL_FIELD(loader, "java/lang/VMThread", "thread", "Ljava/lang/Thread;",
+ ACC_VIRTUAL);
+
+ vmdataVMThread =
+ UPCALL_FIELD(loader, "java/lang/VMThread", "vmdata", "Ljava/lang/Object;",
+ ACC_VIRTUAL);
+
+ inheritableThreadLocal =
+ UPCALL_CLASS(loader, "java/lang/InheritableThreadLocal");
+
+ finaliseCreateInitialThread =
+ UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal", "newChildThread",
+ "(Ljava/lang/Thread;)V", ACC_STATIC);
+
+ initThread =
+ UPCALL_METHOD(loader, "java/lang/Thread", "<init>",
+ "(Ljava/lang/VMThread;Ljava/lang/String;IZ)V", ACC_VIRTUAL);
+
+ initVMThread =
+ UPCALL_METHOD(loader, "java/lang/VMThread", "<init>",
+ "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
+
+ runVMThread =
+ UPCALL_METHOD(loader, "java/lang/VMThread", "run", "()V", ACC_VIRTUAL);
+
+
+ groupAddThread =
+ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread",
+ "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
+
+ initGroup =
+ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "<init>",
+ "()V", ACC_VIRTUAL);
+
+ groupName =
+ UPCALL_FIELD(loader, "java/lang/ThreadGroup", "name", "Ljava/lang/String;",
+ ACC_VIRTUAL);
+
+ threadName =
+ UPCALL_FIELD(loader, "java/lang/Thread", "name", "Ljava/lang/String;",
+ ACC_VIRTUAL);
+
+
+ priority =
+ UPCALL_FIELD(loader, "java/lang/Thread", "priority", "I", ACC_VIRTUAL);
+
+ daemon =
+ UPCALL_FIELD(loader, "java/lang/Thread", "daemon", "Z", ACC_VIRTUAL);
+
+ group =
+ UPCALL_FIELD(loader, "java/lang/Thread", "group",
+ "Ljava/lang/ThreadGroup;", ACC_VIRTUAL);
+
+ running =
+ UPCALL_FIELD(loader, "java/lang/VMThread", "running", "Z", ACC_VIRTUAL);
+
+ threadGroup =
+ UPCALL_CLASS(loader, "java/lang/ThreadGroup");
+
+ rootGroup =
+ UPCALL_FIELD(loader, "java/lang/ThreadGroup", "root",
+ "Ljava/lang/ThreadGroup;", ACC_STATIC);
+
+ vmThread =
+ UPCALL_FIELD(loader, "java/lang/Thread", "vmThread",
+ "Ljava/lang/VMThread;", ACC_VIRTUAL);
+
+ getUncaughtExceptionHandler =
+ UPCALL_METHOD(loader, "java/lang/Thread", "getUncaughtExceptionHandler",
+ "()Ljava/lang/Thread$UncaughtExceptionHandler;",
ACC_VIRTUAL);
+
+ uncaughtException =
+ UPCALL_METHOD(loader, "java/lang/Thread$UncaughtExceptionHandler",
+ "uncaughtException",
+ "(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL);
+
+
+ methodClass =
+ UPCALL_FIELD(loader, "java/lang/reflect/Method", "declaringClass",
+ "Ljava/lang/Class;", ACC_VIRTUAL);
+
+ fieldClass =
+ UPCALL_FIELD(loader, "java/lang/reflect/Field", "declaringClass",
+ "Ljava/lang/Class;", ACC_VIRTUAL);
+
+ constructorClass =
+ UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "clazz",
+ "Ljava/lang/Class;", ACC_VIRTUAL);
+
+ loader->loadName(loader->asciizConstructUTF8("java/lang/String"),
+ true, false, NULL);
+
+ loader->loadName(loader->asciizConstructUTF8("java/lang/Object"),
+ true, false, NULL);
+
+ // Don't compile methods here, we still don't know where to allocate Java
+ // strings.
+
+ JavaMethod* getEnv =
+ UPCALL_METHOD(loader, "java/lang/VMSystem", "getenv",
+ "(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
+ getEnv->setNative();
+
+ JavaMethod* getCallingClass =
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass",
+ "()Ljava/lang/Class;", ACC_STATIC);
+ getCallingClass->setNative();
+
+ JavaMethod* getCallingClassLoader =
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
"getCallingClassLoader",
+ "()Ljava/lang/ClassLoader;", ACC_STATIC);
+ getCallingClassLoader->setNative();
+
+ JavaMethod* firstNonNullClassLoader =
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker",
"firstNonNullClassLoader",
+ "()Ljava/lang/ClassLoader;", ACC_STATIC);
+ firstNonNullClassLoader->setNative();
+
+ JavaMethod* getCallerClass =
+ UPCALL_METHOD(loader, "sun/reflect/Reflection", "getCallerClass",
+ "(I)Ljava/lang/Class;", ACC_STATIC);
+ getCallerClass->setNative();
+
+ JavaMethod* postProperties =
+ UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit",
+ "(Ljava/util/Properties;)V", ACC_STATIC);
+ postProperties->setNative();
+
+ // Also implement these twos, implementation in GNU Classpath
0.97.2 is buggy.
+ JavaMethod* getAnnotation =
+ UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",
"getAnnotation",
+ "(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;",
+ ACC_VIRTUAL);
+ getAnnotation->setNative();
+
+ JavaMethod* getAnnotations =
+ UPCALL_METHOD(loader, "java/lang/reflect/AccessibleObject",
+ "getDeclaredAnnotations",
+ "()[Ljava/lang/annotation/Annotation;",
+ ACC_VIRTUAL);
+ getAnnotations->setNative();
+
+ JavaMethod* getBootPackages =
+ UPCALL_METHOD(loader, "java/lang/VMClassLoader", "getBootPackages",
+ "()[Ljava/lang/String;", ACC_STATIC);
+ getBootPackages->setNative();
+
+ //===----------------------------------------------------------------------===//
+ //
+ // To make classes non GC-allocated, we have to bypass the tracer
functions of
+ // java.lang.Class, java.lang.reflect.Field, java.lang.reflect.Method and
+ // java.lang.reflect.constructor. The new tracer functions trace
the classloader
+ // instead of the class/field/method.
+ //
+ //===----------------------------------------------------------------------===//
+
+ newClass->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectClassTracer,
+ "nativeJavaObjectClassTracer");
+
+ newConstructor->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectConstructorTracer,
+ "nativeJavaObjectConstructorTracer");
+
+ newMethod->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectMethodTracer,
+ "nativeJavaObjectMethodTracer");
+
+ newField->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectFieldTracer,
+ "nativeJavaObjectFieldTracer");
+
+ newVMThread->getVirtualVT()->setNativeTracer(
+ (word_t)nativeJavaObjectVMThreadTracer,
+ "nativeJavaObjectVMThreadTracer");
+
+ newReference = UPCALL_CLASS(loader, "java/lang/ref/Reference");
+
+ EnqueueReference =
+ UPCALL_METHOD(loader, "java/lang/ref/Reference", "enqueue", "()Z",
+ ACC_VIRTUAL);
+
+ JavaMethod* initWeakReference =
+ UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
+ "(Ljava/lang/Object;)V",
+ ACC_VIRTUAL);
+ initWeakReference->setNative();
+
+ initWeakReference =
+ UPCALL_METHOD(loader, "java/lang/ref/WeakReference", "<init>",
+ "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
+ ACC_VIRTUAL);
+ initWeakReference->setNative();
+
+ JavaMethod* initSoftReference =
+ UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",
+ "(Ljava/lang/Object;)V",
+ ACC_VIRTUAL);
+ initSoftReference->setNative();
+
+ initSoftReference =
+ UPCALL_METHOD(loader, "java/lang/ref/SoftReference", "<init>",
+ "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
+ ACC_VIRTUAL);
+ initSoftReference->setNative();
+
+ JavaMethod* initPhantomReference =
+ UPCALL_METHOD(loader, "java/lang/ref/PhantomReference", "<init>",
+ "(Ljava/lang/Object;Ljava/lang/ref/ReferenceQueue;)V",
+ ACC_VIRTUAL);
+ initPhantomReference->setNative();
+}
+
+#include "ClasspathConstructor.inc"
+#include "Classpath.inc"
+#include "ClasspathField.inc"
+#include "ClasspathMethod.inc"
diff --git a/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
new file mode 100644
index 0000000..ae5eb63
--- /dev/null
+++ b/lib/J3/ClassLib/OpenJDK/JavaUpcalls.h
@@ -0,0 +1,283 @@
+//===---------- JavaUpcalls.h - Upcalls to Java entities
------------------===//
+//
+// The VMKit project
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef JNJVM_JAVA_UPCALLS_H
+#define JNJVM_JAVA_UPCALLS_H
+
+#include "mvm/Allocator.h"
+
+#include "JnjvmConfig.h"
+
+#define UPCALL_CLASS(vm, name)
\
+ vm->loadName(vm->asciizConstructUTF8(name), true, false, NULL)
+
+#define UPCALL_PRIMITIVE_CLASS(loader, name, nb)
\
+ new(loader->allocator, "Primitive class")
\
+ UserClassPrimitive(loader,
loader->asciizConstructUTF8(name), nb) \
+
+#define UPCALL_FIELD(vm, cl, name, type, acc)
\
+ UPCALL_CLASS(vm,
cl)->lookupFieldDontThrow(vm->asciizConstructUTF8(name), \
+
vm->asciizConstructUTF8(type), \
+ isStatic(acc), false, 0)
+
+#define UPCALL_METHOD(vm, cl, name, type, acc)
\
+ UPCALL_CLASS(vm,
cl)->lookupMethodDontThrow(vm->asciizConstructUTF8(name), \
+
vm->asciizConstructUTF8(type), \
+ isStatic(acc), false, 0)
+
+#define UPCALL_ARRAY_CLASS(loader, name, depth)
\
+ loader->constructArray(
\
+ loader->constructArrayName(depth, loader->asciizConstructUTF8(name)))
+
+#define UPCALL_CLASS_EXCEPTION(loader, name)
\
+ name = UPCALL_CLASS(loader, "java/lang/"#name)
+
+#define UPCALL_REFLECT_CLASS_EXCEPTION(loader, name)
\
+ name = UPCALL_CLASS(loader, "java/lang/reflect/"#name)
+
+#define UPCALL_METHOD_EXCEPTION(loader, name) \
+ Init##name =
name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \
+
loader->asciizConstructUTF8("(Ljava/lang/String;)V"), \
+ false, false, 0);
+
+#define UPCALL_METHOD_WITH_EXCEPTION(loader, name) \
+ ErrorWithExcp##name =
name->lookupMethodDontThrow(loader->asciizConstructUTF8("<init>"), \
+
loader->asciizConstructUTF8("(Ljava/lang/Throwable;)V"), \
+ false, false, 0);
+
+namespace j3 {
+
+class Jnjvm;
+class JavaField;
+class JavaMethod;
+class JavaObject;
+class JavaThread;
+class Class;
+class ClassArray;
+class JnjvmClassLoader;
+
+class Classpath : public mvm::PermanentObject {
+public:
+ ISOLATE_STATIC UserClass* newClassLoader;
+ ISOLATE_STATIC JavaMethod* getSystemClassLoader;
+ ISOLATE_STATIC JavaMethod* setContextClassLoader;
+ ISOLATE_STATIC UserClass* newString;
+ ISOLATE_STATIC UserClass* newClass;
+ ISOLATE_STATIC UserClass* newThrowable;
+ ISOLATE_STATIC UserClass* newException;
+ ISOLATE_STATIC JavaMethod* initClass;
+ ISOLATE_STATIC JavaMethod* initClassWithProtectionDomain;
+ ISOLATE_STATIC JavaField* vmdataClass;
+ ISOLATE_STATIC JavaMethod* setProperty;
+ ISOLATE_STATIC JavaMethod* initString;
+ ISOLATE_STATIC JavaMethod* getCallingClassLoader;
+ ISOLATE_STATIC JavaMethod* initConstructor;
+ ISOLATE_STATIC UserClassArray* constructorArrayClass;
+ ISOLATE_STATIC UserClassArray* constructorArrayAnnotation;
+ ISOLATE_STATIC UserClass* newConstructor;
+ ISOLATE_STATIC JavaField* constructorSlot;
+ ISOLATE_STATIC JavaMethod* initMethod;
+ ISOLATE_STATIC JavaMethod* initField;
+ ISOLATE_STATIC UserClassArray* methodArrayClass;
+ ISOLATE_STATIC UserClassArray* fieldArrayClass;
+ ISOLATE_STATIC UserClass* newMethod;
+ ISOLATE_STATIC UserClass* newField;
+ ISOLATE_STATIC JavaField* methodSlot;
+ ISOLATE_STATIC JavaField* fieldSlot;
+ ISOLATE_STATIC UserClassArray* classArrayClass;
+ ISOLATE_STATIC JavaMethod* loadInClassLoader;
+ ISOLATE_STATIC JavaMethod* initVMThrowable;
+ ISOLATE_STATIC JavaField* vmDataVMThrowable;
+ ISOLATE_STATIC UserClass* newVMThrowable;
+ ISOLATE_STATIC JavaField* bufferAddress;
+ ISOLATE_STATIC JavaField* dataPointer32;
+ ISOLATE_STATIC JavaField* dataPointer64;
+ ISOLATE_STATIC UserClass* newPointer32;
+ ISOLATE_STATIC UserClass* newPointer64;
+ ISOLATE_STATIC UserClass* newDirectByteBuffer;
+ ISOLATE_STATIC JavaMethod* InitDirectByteBuffer;
+ ISOLATE_STATIC JavaField* vmdataClassLoader;
+ ISOLATE_STATIC UserClass* enumClass;
+
+ ISOLATE_STATIC JavaField* boolValue;
+ ISOLATE_STATIC JavaField* byteValue;
+ ISOLATE_STATIC JavaField* shortValue;
+ ISOLATE_STATIC JavaField* charValue;
+ ISOLATE_STATIC JavaField* intValue;
+ ISOLATE_STATIC JavaField* longValue;
+ ISOLATE_STATIC JavaField* floatValue;
+ ISOLATE_STATIC JavaField* doubleValue;
+
+ ISOLATE_STATIC UserClass* newStackTraceElement;
+ ISOLATE_STATIC UserClassArray* stackTraceArray;
+ ISOLATE_STATIC JavaMethod* initStackTraceElement;
+
+ ISOLATE_STATIC void initialiseClasspath(JnjvmClassLoader* loader);
+
+ ISOLATE_STATIC UserClass* voidClass;
+ ISOLATE_STATIC UserClass* boolClass;
+ ISOLATE_STATIC UserClass* byteClass;
+ ISOLATE_STATIC UserClass* shortClass;
+ ISOLATE_STATIC UserClass* charClass;
+ ISOLATE_STATIC UserClass* intClass;
+ ISOLATE_STATIC UserClass* floatClass;
+ ISOLATE_STATIC UserClass* doubleClass;
+ ISOLATE_STATIC UserClass* longClass;
+
+ ISOLATE_STATIC UserClass* vmStackWalker;
+
+ ISOLATE_STATIC UserClass* newThread;
+ ISOLATE_STATIC UserClass* newVMThread;
+ ISOLATE_STATIC JavaField* assocThread;
+ ISOLATE_STATIC JavaField* vmdataVMThread;
+ ISOLATE_STATIC JavaMethod* finaliseCreateInitialThread;
+ ISOLATE_STATIC JavaMethod* initThread;
+ ISOLATE_STATIC JavaMethod* initVMThread;
+ ISOLATE_STATIC JavaMethod* runVMThread;
+ ISOLATE_STATIC JavaMethod* groupAddThread;
+ ISOLATE_STATIC JavaField* threadName;
+ ISOLATE_STATIC JavaField* groupName;
+ ISOLATE_STATIC JavaMethod* initGroup;
+ ISOLATE_STATIC JavaField* priority;
+ ISOLATE_STATIC JavaField* daemon;
+ ISOLATE_STATIC JavaField* group;
+ ISOLATE_STATIC JavaField* running;
+ ISOLATE_STATIC UserClass* threadGroup;
+ ISOLATE_STATIC JavaField* rootGroup;
+ ISOLATE_STATIC JavaField* vmThread;
+ ISOLATE_STATIC JavaMethod* getUncaughtExceptionHandler;
+ ISOLATE_STATIC JavaMethod* uncaughtException;
+ ISOLATE_STATIC UserClass* inheritableThreadLocal;
+
+
+ ISOLATE_STATIC UserClass* InvocationTargetException;
+ ISOLATE_STATIC UserClass* ArrayStoreException;
+ ISOLATE_STATIC UserClass* ClassCastException;
+ ISOLATE_STATIC UserClass* IllegalMonitorStateException;
+ ISOLATE_STATIC UserClass* IllegalArgumentException;
+ ISOLATE_STATIC UserClass* InterruptedException;
+ ISOLATE_STATIC UserClass* IndexOutOfBoundsException;
+ ISOLATE_STATIC UserClass* ArrayIndexOutOfBoundsException;
+ ISOLATE_STATIC UserClass* NegativeArraySizeException;
+ ISOLATE_STATIC UserClass* NullPointerException;
+ ISOLATE_STATIC UserClass* SecurityException;
+ ISOLATE_STATIC UserClass* ClassFormatError;
+ ISOLATE_STATIC UserClass* ClassCircularityError;
+ ISOLATE_STATIC UserClass* NoClassDefFoundError;
+ ISOLATE_STATIC UserClass* UnsupportedClassVersionError;
+ ISOLATE_STATIC UserClass* NoSuchFieldError;
+ ISOLATE_STATIC UserClass* NoSuchMethodError;
+ ISOLATE_STATIC UserClass* InstantiationError;
+ ISOLATE_STATIC UserClass* InstantiationException;
+ ISOLATE_STATIC UserClass* IllegalAccessError;
+ ISOLATE_STATIC UserClass* IllegalAccessException;
+ ISOLATE_STATIC UserClass* VerifyError;
+ ISOLATE_STATIC UserClass* ExceptionInInitializerError;
+ ISOLATE_STATIC UserClass* LinkageError;
+ ISOLATE_STATIC UserClass* AbstractMethodError;
+ ISOLATE_STATIC UserClass* UnsatisfiedLinkError;
+ ISOLATE_STATIC UserClass* InternalError;
+ ISOLATE_STATIC UserClass* OutOfMemoryError;
+ ISOLATE_STATIC UserClass* StackOverflowError;
+ ISOLATE_STATIC UserClass* UnknownError;
+ ISOLATE_STATIC UserClass* ClassNotFoundException;
+ ISOLATE_STATIC UserClass* ArithmeticException;
+
+ ISOLATE_STATIC JavaMethod* InitInvocationTargetException;
+ ISOLATE_STATIC JavaMethod* InitArrayStoreException;
+ ISOLATE_STATIC JavaMethod* InitClassCastException;
+ ISOLATE_STATIC JavaMethod* InitIllegalMonitorStateException;
+ ISOLATE_STATIC JavaMethod* InitIllegalArgumentException;
+ ISOLATE_STATIC JavaMethod* InitInterruptedException;
+ ISOLATE_STATIC JavaMethod* InitIndexOutOfBoundsException;
+ ISOLATE_STATIC JavaMethod* InitArrayIndexOutOfBoundsException;
+ ISOLATE_STATIC JavaMethod* InitNegativeArraySizeException;
+ ISOLATE_STATIC JavaMethod* InitNullPointerException;
+ ISOLATE_STATIC JavaMethod* InitSecurityException;
+ ISOLATE_STATIC JavaMethod* InitClassFormatError;
+ ISOLATE_STATIC JavaMethod* InitClassCircularityError;
+ ISOLATE_STATIC JavaMethod* InitNoClassDefFoundError;
+ ISOLATE_STATIC JavaMethod* InitUnsupportedClassVersionError;
+ ISOLATE_STATIC JavaMethod* InitNoSuchFieldError;
+ ISOLATE_STATIC JavaMethod* InitNoSuchMethodError;
+ ISOLATE_STATIC JavaMethod* InitInstantiationError;
+ ISOLATE_STATIC JavaMethod* InitInstantiationException;
+ ISOLATE_STATIC JavaMethod* InitIllegalAccessError;
+ ISOLATE_STATIC JavaMethod* InitIllegalAccessException;
+ ISOLATE_STATIC JavaMethod* InitVerifyError;
+ ISOLATE_STATIC JavaMethod* InitExceptionInInitializerError;
+ ISOLATE_STATIC JavaMethod* InitLinkageError;
+ ISOLATE_STATIC JavaMethod* InitAbstractMethodError;
+ ISOLATE_STATIC JavaMethod* InitUnsatisfiedLinkError;
+ ISOLATE_STATIC JavaMethod* InitInternalError;
+ ISOLATE_STATIC JavaMethod* InitOutOfMemoryError;
+ ISOLATE_STATIC JavaMethod* InitStackOverflowError;
+ ISOLATE_STATIC JavaMethod* InitUnknownError;
+ ISOLATE_STATIC JavaMethod* InitClassNotFoundException;
+ ISOLATE_STATIC JavaMethod* InitArithmeticException;
+
+ ISOLATE_STATIC JavaMethod* SystemArraycopy;
+ ISOLATE_STATIC JavaMethod* VMSystemArraycopy;
+ ISOLATE_STATIC Class* SystemClass;
+
+ ISOLATE_STATIC JavaMethod* IntToString;
+
+ ISOLATE_STATIC JavaMethod* InitObject;
+ ISOLATE_STATIC JavaMethod* FinalizeObject;
+
+ ISOLATE_STATIC JavaMethod* ErrorWithExcpNoClassDefFoundError;
+ ISOLATE_STATIC JavaMethod* ErrorWithExcpExceptionInInitializerError;
+ ISOLATE_STATIC JavaMethod* ErrorWithExcpInvocationTargetException;
+
+
+
+ ISOLATE_STATIC UserClassArray* ArrayOfByte;
+ ISOLATE_STATIC UserClassArray* ArrayOfChar;
+ ISOLATE_STATIC UserClassArray* ArrayOfInt;
+ ISOLATE_STATIC UserClassArray* ArrayOfShort;
+ ISOLATE_STATIC UserClassArray* ArrayOfBool;
+ ISOLATE_STATIC UserClassArray* ArrayOfLong;
+ ISOLATE_STATIC UserClassArray* ArrayOfFloat;
+ ISOLATE_STATIC UserClassArray* ArrayOfDouble;
+ ISOLATE_STATIC UserClassArray* ArrayOfObject;
+ ISOLATE_STATIC UserClassArray* ArrayOfString;
+
+ ISOLATE_STATIC UserClassPrimitive* OfByte;
+ ISOLATE_STATIC UserClassPrimitive* OfChar;
+ ISOLATE_STATIC UserClassPrimitive* OfInt;
+ ISOLATE_STATIC UserClassPrimitive* OfShort;
+ ISOLATE_STATIC UserClassPrimitive* OfBool;
+ ISOLATE_STATIC UserClassPrimitive* OfLong;
+ ISOLATE_STATIC UserClassPrimitive* OfFloat;
+ ISOLATE_STATIC UserClassPrimitive* OfDouble;
+ ISOLATE_STATIC UserClassPrimitive* OfVoid;
+
+ ISOLATE_STATIC UserClass* OfObject;
+
+ ISOLATE_STATIC JavaField* methodClass;
+ ISOLATE_STATIC JavaField* fieldClass;
+ ISOLATE_STATIC JavaField* constructorClass;
+
+ ISOLATE_STATIC JavaMethod* EnqueueReference;
+ ISOLATE_STATIC Class* newReference;
+
+ ISOLATE_STATIC UserClass* EnumClass;
+
+private:
+ ISOLATE_STATIC void CreateJavaThread(Jnjvm* vm, JavaThread* myth,
+ const char* name, JavaObject* Group);
+
+public:
+ ISOLATE_STATIC void InitializeThreading(Jnjvm* vm);
+};
+
+
+} // end namespace j3
+
+#endif
--
1.7.5.1
More information about the vmkit-commits
mailing list