[vmkit-commits] [PATCH] Move shared Classpath code in ClassLib, copy unshared to OpenJDK/ for modification
Nicolas Geoffray
nicolas.geoffray at gmail.com
Tue Oct 25 14:34:08 PDT 2011
Looks good!
On Tue, Oct 25, 2011 at 11:31 PM, Will Dietz <wdietz2 at illinois.edu> wrote:
> 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
> _______________________________________________
> vmkit-commits mailing list
> vmkit-commits at cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/vmkit-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/vmkit-commits/attachments/20111025/dde20efe/attachment.html>
More information about the vmkit-commits
mailing list