[vmkit-commits] [vmkit] r55309 - in /vmkit/trunk/lib/JnJVM: Classpath/ClasspathVMThread.cpp.inc VMCore/JavaUpcalls.cpp VMCore/JavaUpcalls.h VMCore/Jnjvm.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Mon Aug 25 01:56:20 PDT 2008
Author: geoffray
Date: Mon Aug 25 03:56:20 2008
New Revision: 55309
URL: http://llvm.org/viewvc/llvm-project?rev=55309&view=rev
Log:
Put all classpath classes, fields, and methods into the same class.
Modified:
vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
Modified: vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc?rev=55309&r1=55308&r2=55309&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc (original)
+++ vmkit/trunk/lib/JnJVM/Classpath/ClasspathVMThread.cpp.inc Mon Aug 25 03:56:20 2008
@@ -57,10 +57,10 @@
Collector::inject_my_thread(&argc);
#endif
CommonClass* vmthClass = vmThread->classOf;
- JavaObject* thread = ClasspathThread::assocThread->getVirtualObjectField(vmThread);
+ JavaObject* thread = Classpath::assocThread->getVirtualObjectField(vmThread);
Jnjvm* isolate = intern->isolate;
ThreadSystem* ts = isolate->threadSystem;
- bool isDaemon = ClasspathThread::daemon->getVirtualInt8Field(thread);
+ bool isDaemon = Classpath::daemon->getVirtualInt8Field(thread);
intern->threadID = (mvm::Thread::self() << 8) & 0x7FFFFF00;
@@ -108,13 +108,13 @@
#endif
jobject _vmThread, sint64 stackSize) {
JavaObject* vmThread = (JavaObject*)_vmThread;
- JavaObject* javaThread = ClasspathThread::assocThread->getVirtualObjectField(vmThread);
+ JavaObject* javaThread = Classpath::assocThread->getVirtualObjectField(vmThread);
assert(javaThread);
Jnjvm* vm = JavaThread::get()->isolate;
JavaThread* th = allocator_new(vm->allocator, JavaThread)();
th->initialise(javaThread, vm);
- ClasspathThread::vmdata->setVirtualObjectField(vmThread, (JavaObject*)th);
+ Classpath::vmdataVMThread->setVirtualObjectField(vmThread, (JavaObject*)th);
int tid = 0;
arg_thread_t* arg = (arg_thread_t*)malloc(sizeof(arg_thread_t));
arg->intern = th;
@@ -133,10 +133,10 @@
jobject _vmthread) {
JavaObject* vmthread = (JavaObject*)_vmthread;
- while (ClasspathThread::vmdata->getVirtualObjectField(vmthread) == 0)
+ while (Classpath::vmdataVMThread->getVirtualObjectField(vmthread) == 0)
mvm::Thread::yield();
- JavaThread* th = (JavaThread*)ClasspathThread::vmdata->getVirtualObjectField(vmthread);
+ JavaThread* th = (JavaThread*)Classpath::vmdataVMThread->getVirtualObjectField(vmthread);
th->lock->lock();
th->interruptFlag = 1;
@@ -167,7 +167,7 @@
#endif
jobject _vmthread) {
JavaObject* vmthread = (JavaObject*)_vmthread;
- JavaThread* th = (JavaThread*)ClasspathThread::vmdata->getVirtualObjectField(vmthread);
+ JavaThread* th = (JavaThread*)Classpath::vmdataVMThread->getVirtualObjectField(vmthread);
return (jboolean)th->interruptFlag;
}
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp?rev=55309&r1=55308&r2=55309&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.cpp Mon Aug 25 03:56:20 2008
@@ -36,21 +36,21 @@
using namespace jnjvm;
-Class* ClasspathThread::newThread;
-Class* ClasspathThread::newVMThread;
-JavaField* ClasspathThread::assocThread;
-JavaField* ClasspathThread::vmdata;
-JavaMethod* ClasspathThread::finaliseCreateInitialThread;
-JavaMethod* ClasspathThread::initVMThread;
-JavaMethod* ClasspathThread::groupAddThread;
-JavaField* ClasspathThread::name;
-JavaField* ClasspathThread::priority;
-JavaField* ClasspathThread::daemon;
-JavaField* ClasspathThread::group;
-JavaField* ClasspathThread::running;
-JavaField* ClasspathThread::rootGroup;
-JavaField* ClasspathThread::vmThread;
-JavaMethod* ClasspathThread::uncaughtException;
+Class* Classpath::newThread;
+Class* Classpath::newVMThread;
+JavaField* Classpath::assocThread;
+JavaField* Classpath::vmdataVMThread;
+JavaMethod* Classpath::finaliseCreateInitialThread;
+JavaMethod* Classpath::initVMThread;
+JavaMethod* Classpath::groupAddThread;
+JavaField* Classpath::name;
+JavaField* Classpath::priority;
+JavaField* Classpath::daemon;
+JavaField* Classpath::group;
+JavaField* Classpath::running;
+JavaField* Classpath::rootGroup;
+JavaField* Classpath::vmThread;
+JavaMethod* Classpath::uncaughtException;
JavaMethod* Classpath::setContextClassLoader;
JavaMethod* Classpath::getSystemClassLoader;
@@ -111,199 +111,73 @@
Class* Classpath::vmStackWalker;
-Class* ClasspathException::InvocationTargetException;
-Class* ClasspathException::ArrayStoreException;
-Class* ClasspathException::ClassCastException;
-Class* ClasspathException::IllegalMonitorStateException;
-Class* ClasspathException::IllegalArgumentException;
-Class* ClasspathException::InterruptedException;
-Class* ClasspathException::IndexOutOfBoundsException;
-Class* ClasspathException::ArrayIndexOutOfBoundsException;
-Class* ClasspathException::NegativeArraySizeException;
-Class* ClasspathException::NullPointerException;
-Class* ClasspathException::SecurityException;
-Class* ClasspathException::ClassFormatError;
-Class* ClasspathException::ClassCircularityError;
-Class* ClasspathException::NoClassDefFoundError;
-Class* ClasspathException::UnsupportedClassVersionError;
-Class* ClasspathException::NoSuchFieldError;
-Class* ClasspathException::NoSuchMethodError;
-Class* ClasspathException::InstantiationError;
-Class* ClasspathException::IllegalAccessError;
-Class* ClasspathException::IllegalAccessException;
-Class* ClasspathException::VerifyError;
-Class* ClasspathException::ExceptionInInitializerError;
-Class* ClasspathException::LinkageError;
-Class* ClasspathException::AbstractMethodError;
-Class* ClasspathException::UnsatisfiedLinkError;
-Class* ClasspathException::InternalError;
-Class* ClasspathException::OutOfMemoryError;
-Class* ClasspathException::StackOverflowError;
-Class* ClasspathException::UnknownError;
-Class* ClasspathException::ClassNotFoundException;
-
-JavaMethod* ClasspathException::InitInvocationTargetException;
-JavaMethod* ClasspathException::InitArrayStoreException;
-JavaMethod* ClasspathException::InitClassCastException;
-JavaMethod* ClasspathException::InitIllegalMonitorStateException;
-JavaMethod* ClasspathException::InitIllegalArgumentException;
-JavaMethod* ClasspathException::InitInterruptedException;
-JavaMethod* ClasspathException::InitIndexOutOfBoundsException;
-JavaMethod* ClasspathException::InitArrayIndexOutOfBoundsException;
-JavaMethod* ClasspathException::InitNegativeArraySizeException;
-JavaMethod* ClasspathException::InitNullPointerException;
-JavaMethod* ClasspathException::InitSecurityException;
-JavaMethod* ClasspathException::InitClassFormatError;
-JavaMethod* ClasspathException::InitClassCircularityError;
-JavaMethod* ClasspathException::InitNoClassDefFoundError;
-JavaMethod* ClasspathException::InitUnsupportedClassVersionError;
-JavaMethod* ClasspathException::InitNoSuchFieldError;
-JavaMethod* ClasspathException::InitNoSuchMethodError;
-JavaMethod* ClasspathException::InitInstantiationError;
-JavaMethod* ClasspathException::InitIllegalAccessError;
-JavaMethod* ClasspathException::InitIllegalAccessException;
-JavaMethod* ClasspathException::InitVerifyError;
-JavaMethod* ClasspathException::InitExceptionInInitializerError;
-JavaMethod* ClasspathException::InitLinkageError;
-JavaMethod* ClasspathException::InitAbstractMethodError;
-JavaMethod* ClasspathException::InitUnsatisfiedLinkError;
-JavaMethod* ClasspathException::InitInternalError;
-JavaMethod* ClasspathException::InitOutOfMemoryError;
-JavaMethod* ClasspathException::InitStackOverflowError;
-JavaMethod* ClasspathException::InitUnknownError;
-JavaMethod* ClasspathException::InitClassNotFoundException;
-
-JavaMethod* ClasspathException::ErrorWithExcpNoClassDefFoundError;
-JavaMethod* ClasspathException::ErrorWithExcpExceptionInInitializerError;
-JavaMethod* ClasspathException::ErrorWithExcpInvocationTargetException;
+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::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;
+
+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::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::ErrorWithExcpNoClassDefFoundError;
+JavaMethod* Classpath::ErrorWithExcpExceptionInInitializerError;
+JavaMethod* Classpath::ErrorWithExcpInvocationTargetException;
-void ClasspathThread::initialise(JnjvmClassLoader* vm) {
- newThread =
- UPCALL_CLASS(vm, "java/lang/Thread");
-
- newVMThread =
- UPCALL_CLASS(vm, "java/lang/VMThread");
-
- assocThread =
- UPCALL_FIELD(vm, "java/lang/VMThread", "thread", "Ljava/lang/Thread;",
- ACC_VIRTUAL);
-
- vmdata =
- UPCALL_FIELD(vm, "java/lang/VMThread", "vmdata", "Ljava/lang/Object;",
- ACC_VIRTUAL);
-
- finaliseCreateInitialThread =
- UPCALL_METHOD(vm, "java/lang/InheritableThreadLocal", "newChildThread",
- "(Ljava/lang/Thread;)V", ACC_STATIC);
-
- initVMThread =
- UPCALL_METHOD(vm, "java/lang/VMThread", "<init>",
- "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
-
- groupAddThread =
- UPCALL_METHOD(vm, "java/lang/ThreadGroup", "addThread",
- "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
-
- name =
- UPCALL_FIELD(vm, "java/lang/Thread", "name", "Ljava/lang/String;",
- ACC_VIRTUAL);
-
- priority =
- UPCALL_FIELD(vm, "java/lang/Thread", "priority", "I", ACC_VIRTUAL);
-
- daemon =
- UPCALL_FIELD(vm, "java/lang/Thread", "daemon", "Z", ACC_VIRTUAL);
-
- group =
- UPCALL_FIELD(vm, "java/lang/Thread", "group",
- "Ljava/lang/ThreadGroup;", ACC_VIRTUAL);
-
- running =
- UPCALL_FIELD(vm, "java/lang/VMThread", "running", "Z", ACC_VIRTUAL);
-
- rootGroup =
- UPCALL_FIELD(vm, "java/lang/ThreadGroup", "root",
- "Ljava/lang/ThreadGroup;", ACC_STATIC);
-
- vmThread =
- UPCALL_FIELD(vm, "java/lang/Thread", "vmThread",
- "Ljava/lang/VMThread;", ACC_VIRTUAL);
-
- uncaughtException =
- UPCALL_METHOD(vm, "java/lang/ThreadGroup", "uncaughtException",
- "(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL);
-}
-
-void ClasspathException::initialise(JnjvmClassLoader* loader) {
- 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, 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_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, 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_WITH_EXCEPTION(loader, NoClassDefFoundError);
- UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
- UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);
-}
-
-
-void ClasspathThread::createInitialThread(Jnjvm* vm, JavaObject* th) {
+void Classpath::createInitialThread(Jnjvm* vm, JavaObject* th) {
JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
JCL->loadName(newVMThread->name, true, true);
vm->initialiseClass(newVMThread);
@@ -323,7 +197,7 @@
groupAddThread->invokeIntSpecial(vm, RG, th);
}
-void ClasspathThread::mapInitialThread(Jnjvm* vm) {
+void Classpath::mapInitialThread(Jnjvm* vm) {
JnjvmClassLoader* JCL = JnjvmClassLoader::bootstrapLoader;
JCL->loadName(newThread->name, true, true);
vm->initialiseClass(newThread);
@@ -332,223 +206,344 @@
JavaThread* myth = JavaThread::get();
myth->javaThread = th;
JavaObject* vmth = vmThread->getVirtualObjectField(th);
- vmdata->setVirtualObjectField(vmth, (JavaObject*)myth);
+ vmdataVMThread->setVirtualObjectField(vmth, (JavaObject*)myth);
finaliseCreateInitialThread->invokeIntStatic(vm, th);
}
-void Classpath::initialiseClasspath(JnjvmClassLoader* vm) {
+void Classpath::initialiseClasspath(JnjvmClassLoader* loader) {
getSystemClassLoader =
- UPCALL_METHOD(vm, "java/lang/ClassLoader", "getSystemClassLoader",
+ UPCALL_METHOD(loader, "java/lang/ClassLoader", "getSystemClassLoader",
"()Ljava/lang/ClassLoader;", ACC_STATIC);
setContextClassLoader =
- UPCALL_METHOD(vm, "java/lang/Thread", "setContextClassLoader",
+ UPCALL_METHOD(loader, "java/lang/Thread", "setContextClassLoader",
"(Ljava/lang/ClassLoader;)V", ACC_VIRTUAL);
newString =
- UPCALL_CLASS(vm, "java/lang/String");
+ UPCALL_CLASS(loader, "java/lang/String");
newClass =
- UPCALL_CLASS(vm, "java/lang/Class");
+ UPCALL_CLASS(loader, "java/lang/Class");
newThrowable =
- UPCALL_CLASS(vm, "java/lang/Throwable");
+ UPCALL_CLASS(loader, "java/lang/Throwable");
newException =
- UPCALL_CLASS(vm, "java/lang/Exception");
+ UPCALL_CLASS(loader, "java/lang/Exception");
initClass =
- UPCALL_METHOD(vm, "java/lang/Class", "<init>", "(Ljava/lang/Object;)V",
+ UPCALL_METHOD(loader, "java/lang/Class", "<init>", "(Ljava/lang/Object;)V",
ACC_VIRTUAL);
initClassWithProtectionDomain =
- UPCALL_METHOD(vm, "java/lang/Class", "<init>",
+ UPCALL_METHOD(loader, "java/lang/Class", "<init>",
"(Ljava/lang/Object;Ljava/security/ProtectionDomain;)V",
ACC_VIRTUAL);
vmdataClass =
- UPCALL_FIELD(vm, "java/lang/Class", "vmdata", "Ljava/lang/Object;",
+ UPCALL_FIELD(loader, "java/lang/Class", "vmdata", "Ljava/lang/Object;",
ACC_VIRTUAL);
setProperty =
- UPCALL_METHOD(vm, "java/util/Properties", "setProperty",
+ UPCALL_METHOD(loader, "java/util/Properties", "setProperty",
"(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/Object;",
ACC_VIRTUAL);
initString =
- UPCALL_METHOD(vm, "java/lang/String", "<init>", "([CIIZ)V", ACC_VIRTUAL);
+ UPCALL_METHOD(loader, "java/lang/String", "<init>", "([CIIZ)V", ACC_VIRTUAL);
initConstructor =
- UPCALL_METHOD(vm, "java/lang/reflect/Constructor", "<init>",
+ UPCALL_METHOD(loader, "java/lang/reflect/Constructor", "<init>",
"(Ljava/lang/Class;I)V", ACC_VIRTUAL);
newConstructor =
- UPCALL_CLASS(vm, "java/lang/reflect/Constructor");
+ UPCALL_CLASS(loader, "java/lang/reflect/Constructor");
constructorArrayClass =
- UPCALL_ARRAY_CLASS(vm, "java/lang/reflect/Constructor", 1);
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Constructor", 1);
constructorArrayAnnotation =
- UPCALL_ARRAY_CLASS(vm, "java/lang/annotation/Annotation", 1);
+ UPCALL_ARRAY_CLASS(loader, "java/lang/annotation/Annotation", 1);
constructorSlot =
- UPCALL_FIELD(vm, "java/lang/reflect/Constructor", "slot", "I", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/reflect/Constructor", "slot", "I", ACC_VIRTUAL);
initMethod =
- UPCALL_METHOD(vm, "java/lang/reflect/Method", "<init>",
+ UPCALL_METHOD(loader, "java/lang/reflect/Method", "<init>",
"(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
newMethod =
- UPCALL_CLASS(vm, "java/lang/reflect/Method");
+ UPCALL_CLASS(loader, "java/lang/reflect/Method");
methodArrayClass =
- UPCALL_ARRAY_CLASS(vm, "java/lang/reflect/Method", 1);
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Method", 1);
methodSlot =
- UPCALL_FIELD(vm, "java/lang/reflect/Method", "slot", "I", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/reflect/Method", "slot", "I", ACC_VIRTUAL);
initField =
- UPCALL_METHOD(vm, "java/lang/reflect/Field", "<init>",
+ UPCALL_METHOD(loader, "java/lang/reflect/Field", "<init>",
"(Ljava/lang/Class;Ljava/lang/String;I)V", ACC_VIRTUAL);
newField =
- UPCALL_CLASS(vm, "java/lang/reflect/Field");
+ UPCALL_CLASS(loader, "java/lang/reflect/Field");
fieldArrayClass =
- UPCALL_ARRAY_CLASS(vm, "java/lang/reflect/Field", 1);
+ UPCALL_ARRAY_CLASS(loader, "java/lang/reflect/Field", 1);
fieldSlot =
- UPCALL_FIELD(vm, "java/lang/reflect/Field", "slot", "I", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/reflect/Field", "slot", "I", ACC_VIRTUAL);
classArrayClass =
- UPCALL_ARRAY_CLASS(vm, "java/lang/Class", 1);
+ UPCALL_ARRAY_CLASS(loader, "java/lang/Class", 1);
newVMThrowable =
- UPCALL_CLASS(vm, "java/lang/VMThrowable");
+ UPCALL_CLASS(loader, "java/lang/VMThrowable");
initVMThrowable =
- UPCALL_METHOD(vm, "java/lang/VMThrowable", "<init>", "()V", ACC_VIRTUAL);
+ UPCALL_METHOD(loader, "java/lang/VMThrowable", "<init>", "()V", ACC_VIRTUAL);
vmDataVMThrowable =
- UPCALL_FIELD(vm, "java/lang/VMThrowable", "vmdata", "Ljava/lang/Object;",
+ UPCALL_FIELD(loader, "java/lang/VMThrowable", "vmdata", "Ljava/lang/Object;",
ACC_VIRTUAL);
bufferAddress =
- UPCALL_FIELD(vm, "java/nio/Buffer", "address", "Lgnu/classpath/Pointer;",
+ UPCALL_FIELD(loader, "java/nio/Buffer", "address", "Lgnu/classpath/Pointer;",
ACC_VIRTUAL);
dataPointer32 =
- UPCALL_FIELD(vm, "gnu/classpath/Pointer32", "data", "I", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "gnu/classpath/Pointer32", "data", "I", ACC_VIRTUAL);
vmdataClassLoader =
- UPCALL_FIELD(vm, "java/lang/ClassLoader", "vmdata", "Ljava/lang/Object;",
+ UPCALL_FIELD(loader, "java/lang/ClassLoader", "vmdata", "Ljava/lang/Object;",
ACC_VIRTUAL);
newStackTraceElement =
- UPCALL_CLASS(vm, "java/lang/StackTraceElement");
+ UPCALL_CLASS(loader, "java/lang/StackTraceElement");
stackTraceArray =
- UPCALL_ARRAY_CLASS(vm, "java/lang/StackTraceElement", 1);
+ UPCALL_ARRAY_CLASS(loader, "java/lang/StackTraceElement", 1);
initStackTraceElement =
- UPCALL_METHOD(vm, "java/lang/StackTraceElement", "<init>",
+ UPCALL_METHOD(loader, "java/lang/StackTraceElement", "<init>",
"(Ljava/lang/String;ILjava/lang/String;Ljava/lang/String;Z)V",
ACC_VIRTUAL);
boolValue =
- UPCALL_FIELD(vm, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Boolean", "value", "Z", ACC_VIRTUAL);
byteValue =
- UPCALL_FIELD(vm, "java/lang/Byte", "value", "B", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Byte", "value", "B", ACC_VIRTUAL);
shortValue =
- UPCALL_FIELD(vm, "java/lang/Short", "value", "S", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Short", "value", "S", ACC_VIRTUAL);
charValue =
- UPCALL_FIELD(vm, "java/lang/Character", "value", "C", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Character", "value", "C", ACC_VIRTUAL);
intValue =
- UPCALL_FIELD(vm, "java/lang/Integer", "value", "I", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Integer", "value", "I", ACC_VIRTUAL);
longValue =
- UPCALL_FIELD(vm, "java/lang/Long", "value", "J", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Long", "value", "J", ACC_VIRTUAL);
floatValue =
- UPCALL_FIELD(vm, "java/lang/Float", "value", "F", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Float", "value", "F", ACC_VIRTUAL);
doubleValue =
- UPCALL_FIELD(vm, "java/lang/Double", "value", "D", ACC_VIRTUAL);
+ UPCALL_FIELD(loader, "java/lang/Double", "value", "D", ACC_VIRTUAL);
Classpath::voidClass =
- UPCALL_CLASS(vm, "java/lang/Void");
+ UPCALL_CLASS(loader, "java/lang/Void");
Classpath::boolClass =
- UPCALL_CLASS(vm, "java/lang/Boolean");
+ UPCALL_CLASS(loader, "java/lang/Boolean");
Classpath::byteClass =
- UPCALL_CLASS(vm, "java/lang/Byte");
+ UPCALL_CLASS(loader, "java/lang/Byte");
Classpath::shortClass =
- UPCALL_CLASS(vm, "java/lang/Short");
+ UPCALL_CLASS(loader, "java/lang/Short");
Classpath::charClass =
- UPCALL_CLASS(vm, "java/lang/Character");
+ UPCALL_CLASS(loader, "java/lang/Character");
Classpath::intClass =
- UPCALL_CLASS(vm, "java/lang/Integer");
+ UPCALL_CLASS(loader, "java/lang/Integer");
Classpath::floatClass =
- UPCALL_CLASS(vm, "java/lang/Float");
+ UPCALL_CLASS(loader, "java/lang/Float");
Classpath::doubleClass =
- UPCALL_CLASS(vm, "java/lang/Double");
+ UPCALL_CLASS(loader, "java/lang/Double");
Classpath::longClass =
- UPCALL_CLASS(vm, "java/lang/Long");
+ UPCALL_CLASS(loader, "java/lang/Long");
vmStackWalker =
- UPCALL_CLASS(vm, "gnu/classpath/VMStackWalker");
+ UPCALL_CLASS(loader, "gnu/classpath/VMStackWalker");
loadInClassLoader =
- UPCALL_METHOD(vm, "java/lang/ClassLoader", "loadClass",
+ UPCALL_METHOD(loader, "java/lang/ClassLoader", "loadClass",
"(Ljava/lang/String;Z)Ljava/lang/Class;", ACC_VIRTUAL);
JavaMethod* internString =
- UPCALL_METHOD(vm, "java/lang/VMString", "intern",
+ UPCALL_METHOD(loader, "java/lang/VMString", "intern",
"(Ljava/lang/String;)Ljava/lang/String;", ACC_STATIC);
- vm->TheModule->setMethod(internString, "internString");
+ loader->TheModule->setMethod(internString, "internString");
JavaMethod* isArray =
- UPCALL_METHOD(vm, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL);
- vm->TheModule->setMethod(isArray, "isArray");
+ UPCALL_METHOD(loader, "java/lang/Class", "isArray", "()Z", ACC_VIRTUAL);
+ loader->TheModule->setMethod(isArray, "isArray");
+
+
+ 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, 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_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, 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_WITH_EXCEPTION(loader, NoClassDefFoundError);
+ UPCALL_METHOD_WITH_EXCEPTION(loader, ExceptionInInitializerError);
+ UPCALL_METHOD_WITH_EXCEPTION(loader, InvocationTargetException);
+
+
+ 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);
+
+ finaliseCreateInitialThread =
+ UPCALL_METHOD(loader, "java/lang/InheritableThreadLocal", "newChildThread",
+ "(Ljava/lang/Thread;)V", ACC_STATIC);
+
+ initVMThread =
+ UPCALL_METHOD(loader, "java/lang/VMThread", "<init>",
+ "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
+
+ groupAddThread =
+ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "addThread",
+ "(Ljava/lang/Thread;)V", ACC_VIRTUAL);
+
+ name =
+ 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);
+
+ 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);
+
+ uncaughtException =
+ UPCALL_METHOD(loader, "java/lang/ThreadGroup", "uncaughtException",
+ "(Ljava/lang/Thread;Ljava/lang/Throwable;)V", ACC_VIRTUAL);
+
- ClasspathThread::initialise(vm);
- ClasspathException::initialise(vm);
-
- vm->loadName(vm->asciizConstructUTF8("java/lang/String"),
+ loader->loadName(loader->asciizConstructUTF8("java/lang/String"),
true, false);
- vm->loadName(vm->asciizConstructUTF8("java/lang/Object"),
+ loader->loadName(loader->asciizConstructUTF8("java/lang/Object"),
true, false);
// Don't compile methods here, we still don't know where to allocate Java
// strings.
JavaMethod* getCallingClass =
- UPCALL_METHOD(vm, "gnu/classpath/VMStackWalker", "getCallingClass",
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClass",
"()Ljava/lang/Class;", ACC_STATIC);
- vm->TheModule->setMethod(getCallingClass, "getCallingClass");
+ loader->TheModule->setMethod(getCallingClass, "getCallingClass");
JavaMethod* getCallingClassLoader =
- UPCALL_METHOD(vm, "gnu/classpath/VMStackWalker", "getCallingClassLoader",
+ UPCALL_METHOD(loader, "gnu/classpath/VMStackWalker", "getCallingClassLoader",
"()Ljava/lang/ClassLoader;", ACC_STATIC);
- vm->TheModule->setMethod(getCallingClassLoader, "getCallingClassLoader");
+ loader->TheModule->setMethod(getCallingClassLoader, "getCallingClassLoader");
JavaMethod* postProperties =
- UPCALL_METHOD(vm, "gnu/classpath/VMSystemProperties", "postInit",
+ UPCALL_METHOD(loader, "gnu/classpath/VMSystemProperties", "postInit",
"(Ljava/util/Properties;)V", ACC_STATIC);
- vm->TheModule->setMethod(postProperties, "propertiesPostInit");
+ loader->TheModule->setMethod(postProperties, "propertiesPostInit");
}
extern "C" JavaString* internString(JavaString* obj) {
Modified: vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h?rev=55309&r1=55308&r2=55309&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/JavaUpcalls.h Mon Aug 25 03:56:20 2008
@@ -51,14 +51,73 @@
class Class;
class ClassArray;
-class ClasspathThread {
-public:
- static void initialise(JnjvmClassLoader* vm);
+class Classpath {
+public:
+ static JavaMethod* getSystemClassLoader;
+ static JavaMethod* setContextClassLoader;
+ static Class* newString;
+ static Class* newClass;
+ static Class* newThrowable;
+ static Class* newException;
+ static JavaMethod* initClass;
+ static JavaMethod* initClassWithProtectionDomain;
+ static JavaField* vmdataClass;
+ static JavaMethod* setProperty;
+ static JavaMethod* initString;
+ static JavaMethod* getCallingClassLoader;
+ static JavaMethod* initConstructor;
+ static ClassArray* constructorArrayClass;
+ static ClassArray* constructorArrayAnnotation;
+ static Class* newConstructor;
+ static JavaField* constructorSlot;
+ static JavaMethod* initMethod;
+ static JavaMethod* initField;
+ static ClassArray* methodArrayClass;
+ static ClassArray* fieldArrayClass;
+ static Class* newMethod;
+ static Class* newField;
+ static JavaField* methodSlot;
+ static JavaField* fieldSlot;
+ static ClassArray* classArrayClass;
+ static JavaMethod* loadInClassLoader;
+ static JavaMethod* initVMThrowable;
+ static JavaField* vmDataVMThrowable;
+ static Class* newVMThrowable;
+ static JavaField* bufferAddress;
+ static JavaField* dataPointer32;
+ static JavaField* vmdataClassLoader;
+
+ static JavaField* boolValue;
+ static JavaField* byteValue;
+ static JavaField* shortValue;
+ static JavaField* charValue;
+ static JavaField* intValue;
+ static JavaField* longValue;
+ static JavaField* floatValue;
+ static JavaField* doubleValue;
+
+ static Class* newStackTraceElement;
+ static ClassArray* stackTraceArray;
+ static JavaMethod* initStackTraceElement;
+
+ static void initialiseClasspath(JnjvmClassLoader* loader);
+
+ static Class* voidClass;
+ static Class* boolClass;
+ static Class* byteClass;
+ static Class* shortClass;
+ static Class* charClass;
+ static Class* intClass;
+ static Class* floatClass;
+ static Class* doubleClass;
+ static Class* longClass;
+
+ static Class* vmStackWalker;
static Class* newThread;
static Class* newVMThread;
static JavaField* assocThread;
- static JavaField* vmdata;
+ static JavaField* vmdataVMThread;
static JavaMethod* finaliseCreateInitialThread;
static JavaMethod* initVMThread;
static JavaMethod* groupAddThread;
@@ -71,14 +130,6 @@
static JavaField* vmThread;
static JavaMethod* uncaughtException;
- static void createInitialThread(Jnjvm* vm, JavaObject* th);
- static void mapInitialThread(Jnjvm* vm);
-};
-
-class ClasspathException {
-public:
- static void initialise(JnjvmClassLoader* vm);
-
static Class* InvocationTargetException;
static Class* ArrayStoreException;
static Class* ClassCastException;
@@ -144,70 +195,9 @@
static JavaMethod* ErrorWithExcpNoClassDefFoundError;
static JavaMethod* ErrorWithExcpExceptionInInitializerError;
static JavaMethod* ErrorWithExcpInvocationTargetException;
-};
-
-class Classpath {
-public:
- static JavaMethod* getSystemClassLoader;
- static JavaMethod* setContextClassLoader;
- static Class* newString;
- static Class* newClass;
- static Class* newThrowable;
- static Class* newException;
- static JavaMethod* initClass;
- static JavaMethod* initClassWithProtectionDomain;
- static JavaField* vmdataClass;
- static JavaMethod* setProperty;
- static JavaMethod* initString;
- static JavaMethod* getCallingClassLoader;
- static JavaMethod* initConstructor;
- static ClassArray* constructorArrayClass;
- static ClassArray* constructorArrayAnnotation;
- static Class* newConstructor;
- static JavaField* constructorSlot;
- static JavaMethod* initMethod;
- static JavaMethod* initField;
- static ClassArray* methodArrayClass;
- static ClassArray* fieldArrayClass;
- static Class* newMethod;
- static Class* newField;
- static JavaField* methodSlot;
- static JavaField* fieldSlot;
- static ClassArray* classArrayClass;
- static JavaMethod* loadInClassLoader;
- static JavaMethod* initVMThrowable;
- static JavaField* vmDataVMThrowable;
- static Class* newVMThrowable;
- static JavaField* bufferAddress;
- static JavaField* dataPointer32;
- static JavaField* vmdataClassLoader;
-
- static JavaField* boolValue;
- static JavaField* byteValue;
- static JavaField* shortValue;
- static JavaField* charValue;
- static JavaField* intValue;
- static JavaField* longValue;
- static JavaField* floatValue;
- static JavaField* doubleValue;
-
- static Class* newStackTraceElement;
- static ClassArray* stackTraceArray;
- static JavaMethod* initStackTraceElement;
-
- static void initialiseClasspath(JnjvmClassLoader* loader);
-
- static Class* voidClass;
- static Class* boolClass;
- static Class* byteClass;
- static Class* shortClass;
- static Class* charClass;
- static Class* intClass;
- static Class* floatClass;
- static Class* doubleClass;
- static Class* longClass;
- static Class* vmStackWalker;
+ static void createInitialThread(Jnjvm* vm, JavaObject* th);
+ static void mapInitialThread(Jnjvm* vm);
};
Modified: vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp?rev=55309&r1=55308&r2=55309&view=diff
==============================================================================
--- vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp (original)
+++ vmkit/trunk/lib/JnJVM/VMCore/Jnjvm.cpp Mon Aug 25 03:56:20 2008
@@ -173,18 +173,18 @@
}
void Jnjvm::arrayStoreException() {
- error(ClasspathException::ArrayStoreException,
- ClasspathException::InitArrayStoreException, "");
+ error(Classpath::ArrayStoreException,
+ Classpath::InitArrayStoreException, "");
}
void Jnjvm::indexOutOfBounds(const JavaObject* obj, sint32 entry) {
- error(ClasspathException::ArrayIndexOutOfBoundsException,
- ClasspathException::InitArrayIndexOutOfBoundsException, "%d", entry);
+ error(Classpath::ArrayIndexOutOfBoundsException,
+ Classpath::InitArrayIndexOutOfBoundsException, "%d", entry);
}
void Jnjvm::negativeArraySizeException(sint32 size) {
- error(ClasspathException::NegativeArraySizeException,
- ClasspathException::InitNegativeArraySizeException, "%d", size);
+ error(Classpath::NegativeArraySizeException,
+ Classpath::InitNegativeArraySizeException, "%d", size);
}
void Jnjvm::nullPointerException(const char* fmt, ...) {
@@ -192,115 +192,115 @@
va_start(ap, fmt);
char* val = va_arg(ap, char*);
va_end(ap);
- error(ClasspathException::NullPointerException,
- ClasspathException::InitNullPointerException, fmt, val);
+ error(Classpath::NullPointerException,
+ Classpath::InitNullPointerException, fmt, val);
}
void Jnjvm::illegalAccessException(const char* msg) {
- error(ClasspathException::IllegalAccessException,
- ClasspathException::InitIllegalAccessException, msg);
+ error(Classpath::IllegalAccessException,
+ Classpath::InitIllegalAccessException, msg);
}
void Jnjvm::illegalMonitorStateException(const JavaObject* obj) {
- error(ClasspathException::IllegalMonitorStateException,
- ClasspathException::InitIllegalMonitorStateException, "");
+ error(Classpath::IllegalMonitorStateException,
+ Classpath::InitIllegalMonitorStateException, "");
}
void Jnjvm::interruptedException(const JavaObject* obj) {
- error(ClasspathException::InterruptedException,
- ClasspathException::InitInterruptedException, "");
+ error(Classpath::InterruptedException,
+ Classpath::InitInterruptedException, "");
}
void Jnjvm::initializerError(const JavaObject* excp) {
- errorWithExcp(ClasspathException::ExceptionInInitializerError,
- ClasspathException::ErrorWithExcpExceptionInInitializerError,
+ errorWithExcp(Classpath::ExceptionInInitializerError,
+ Classpath::ErrorWithExcpExceptionInInitializerError,
excp);
}
void Jnjvm::invocationTargetException(const JavaObject* excp) {
- errorWithExcp(ClasspathException::InvocationTargetException,
- ClasspathException::ErrorWithExcpInvocationTargetException,
+ errorWithExcp(Classpath::InvocationTargetException,
+ Classpath::ErrorWithExcpInvocationTargetException,
excp);
}
void Jnjvm::outOfMemoryError(sint32 n) {
- error(ClasspathException::OutOfMemoryError,
- ClasspathException::InitOutOfMemoryError, "%d", n);
+ error(Classpath::OutOfMemoryError,
+ Classpath::InitOutOfMemoryError, "%d", n);
}
void Jnjvm::illegalArgumentExceptionForMethod(JavaMethod* meth,
CommonClass* required,
CommonClass* given) {
- error(ClasspathException::IllegalArgumentException,
- ClasspathException::InitIllegalArgumentException,
+ error(Classpath::IllegalArgumentException,
+ Classpath::InitIllegalArgumentException,
"for method %s", meth->printString());
}
void Jnjvm::illegalArgumentExceptionForField(JavaField* field,
CommonClass* required,
CommonClass* given) {
- error(ClasspathException::IllegalArgumentException,
- ClasspathException::InitIllegalArgumentException,
+ error(Classpath::IllegalArgumentException,
+ Classpath::InitIllegalArgumentException,
"for field %s", field->printString());
}
void Jnjvm::illegalArgumentException(const char* msg) {
- error(ClasspathException::IllegalArgumentException,
- ClasspathException::InitIllegalArgumentException,
+ error(Classpath::IllegalArgumentException,
+ Classpath::InitIllegalArgumentException,
msg);
}
void Jnjvm::classCastException(const char* msg) {
- error(ClasspathException::ClassCastException,
- ClasspathException::InitClassCastException,
+ error(Classpath::ClassCastException,
+ Classpath::InitClassCastException,
msg);
}
void Jnjvm::noSuchFieldError(CommonClass* cl, const UTF8* name) {
- error(ClasspathException::NoSuchFieldError,
- ClasspathException::InitNoSuchFieldError,
+ error(Classpath::NoSuchFieldError,
+ Classpath::InitNoSuchFieldError,
"unable to find %s in %s",
name->printString(), cl->printString());
}
void Jnjvm::noSuchMethodError(CommonClass* cl, const UTF8* name) {
- error(ClasspathException::NoSuchMethodError,
- ClasspathException::InitNoSuchMethodError,
+ error(Classpath::NoSuchMethodError,
+ Classpath::InitNoSuchMethodError,
"unable to find %s in %s",
name->printString(), cl->printString());
}
void Jnjvm::classFormatError(const char* msg, ...) {
- error(ClasspathException::ClassFormatError,
- ClasspathException::InitClassFormatError,
+ error(Classpath::ClassFormatError,
+ Classpath::InitClassFormatError,
msg);
}
void Jnjvm::noClassDefFoundError(JavaObject* obj) {
- errorWithExcp(ClasspathException::NoClassDefFoundError,
- ClasspathException::ErrorWithExcpNoClassDefFoundError,
+ errorWithExcp(Classpath::NoClassDefFoundError,
+ Classpath::ErrorWithExcpNoClassDefFoundError,
obj);
}
void Jnjvm::noClassDefFoundError(const char* fmt, ...) {
- error(ClasspathException::NoClassDefFoundError,
- ClasspathException::InitNoClassDefFoundError,
+ error(Classpath::NoClassDefFoundError,
+ Classpath::InitNoClassDefFoundError,
fmt);
}
void Jnjvm::classNotFoundException(JavaString* str) {
- error(ClasspathException::ClassNotFoundException,
- ClasspathException::InitClassNotFoundException,
+ error(Classpath::ClassNotFoundException,
+ Classpath::InitClassNotFoundException,
"unable to load %s",
str->strToAsciiz());
}
void Jnjvm::unknownError(const char* fmt, ...) {
- error(ClasspathException::UnknownError,
- ClasspathException::InitUnknownError,
+ error(Classpath::UnknownError,
+ Classpath::InitUnknownError,
fmt);
}
@@ -661,13 +661,13 @@
}
void Jnjvm::mapInitialThread() {
- ClasspathThread::mapInitialThread(this);
+ Classpath::mapInitialThread(this);
}
void Jnjvm::loadBootstrap() {
JnjvmClassLoader* loader = JnjvmClassLoader::bootstrapLoader;
#define LOAD_CLASS(cl) \
- loader->loadName(cl->name, true, true);\
+ cl->resolveClass(); \
initialiseClass(cl);
LOAD_CLASS(Classpath::newClass);
@@ -677,36 +677,36 @@
LOAD_CLASS(Classpath::newField);
LOAD_CLASS(Classpath::newStackTraceElement);
LOAD_CLASS(Classpath::newVMThrowable);
- LOAD_CLASS(ClasspathException::InvocationTargetException);
- LOAD_CLASS(ClasspathException::ArrayStoreException);
- LOAD_CLASS(ClasspathException::ClassCastException);
- LOAD_CLASS(ClasspathException::IllegalMonitorStateException);
- LOAD_CLASS(ClasspathException::IllegalArgumentException);
- LOAD_CLASS(ClasspathException::InterruptedException);
- LOAD_CLASS(ClasspathException::IndexOutOfBoundsException);
- LOAD_CLASS(ClasspathException::ArrayIndexOutOfBoundsException);
- LOAD_CLASS(ClasspathException::NegativeArraySizeException);
- LOAD_CLASS(ClasspathException::NullPointerException);
- LOAD_CLASS(ClasspathException::SecurityException);
- LOAD_CLASS(ClasspathException::ClassFormatError);
- LOAD_CLASS(ClasspathException::ClassCircularityError);
- LOAD_CLASS(ClasspathException::NoClassDefFoundError);
- LOAD_CLASS(ClasspathException::UnsupportedClassVersionError);
- LOAD_CLASS(ClasspathException::NoSuchFieldError);
- LOAD_CLASS(ClasspathException::NoSuchMethodError);
- LOAD_CLASS(ClasspathException::InstantiationError);
- LOAD_CLASS(ClasspathException::IllegalAccessError);
- LOAD_CLASS(ClasspathException::IllegalAccessException);
- LOAD_CLASS(ClasspathException::VerifyError);
- LOAD_CLASS(ClasspathException::ExceptionInInitializerError);
- LOAD_CLASS(ClasspathException::LinkageError);
- LOAD_CLASS(ClasspathException::AbstractMethodError);
- LOAD_CLASS(ClasspathException::UnsatisfiedLinkError);
- LOAD_CLASS(ClasspathException::InternalError);
- LOAD_CLASS(ClasspathException::OutOfMemoryError);
- LOAD_CLASS(ClasspathException::StackOverflowError);
- LOAD_CLASS(ClasspathException::UnknownError);
- LOAD_CLASS(ClasspathException::ClassNotFoundException);
+ LOAD_CLASS(Classpath::InvocationTargetException);
+ LOAD_CLASS(Classpath::ArrayStoreException);
+ LOAD_CLASS(Classpath::ClassCastException);
+ LOAD_CLASS(Classpath::IllegalMonitorStateException);
+ LOAD_CLASS(Classpath::IllegalArgumentException);
+ LOAD_CLASS(Classpath::InterruptedException);
+ LOAD_CLASS(Classpath::IndexOutOfBoundsException);
+ LOAD_CLASS(Classpath::ArrayIndexOutOfBoundsException);
+ LOAD_CLASS(Classpath::NegativeArraySizeException);
+ LOAD_CLASS(Classpath::NullPointerException);
+ LOAD_CLASS(Classpath::SecurityException);
+ LOAD_CLASS(Classpath::ClassFormatError);
+ LOAD_CLASS(Classpath::ClassCircularityError);
+ LOAD_CLASS(Classpath::NoClassDefFoundError);
+ LOAD_CLASS(Classpath::UnsupportedClassVersionError);
+ LOAD_CLASS(Classpath::NoSuchFieldError);
+ LOAD_CLASS(Classpath::NoSuchMethodError);
+ LOAD_CLASS(Classpath::InstantiationError);
+ LOAD_CLASS(Classpath::IllegalAccessError);
+ LOAD_CLASS(Classpath::IllegalAccessException);
+ LOAD_CLASS(Classpath::VerifyError);
+ LOAD_CLASS(Classpath::ExceptionInInitializerError);
+ LOAD_CLASS(Classpath::LinkageError);
+ LOAD_CLASS(Classpath::AbstractMethodError);
+ LOAD_CLASS(Classpath::UnsatisfiedLinkError);
+ LOAD_CLASS(Classpath::InternalError);
+ LOAD_CLASS(Classpath::OutOfMemoryError);
+ LOAD_CLASS(Classpath::StackOverflowError);
+ LOAD_CLASS(Classpath::UnknownError);
+ LOAD_CLASS(Classpath::ClassNotFoundException);
#undef LOAD_CLASS
mapInitialThread();
@@ -733,9 +733,9 @@
JavaThread::clearException();
JavaObject* obj = JavaThread::currentThread();
JavaObject* group =
- ClasspathThread::group->getVirtualObjectField(obj);
+ Classpath::group->getVirtualObjectField(obj);
try{
- ClasspathThread::uncaughtException->invokeIntSpecial(this, group, obj,
+ Classpath::uncaughtException->invokeIntSpecial(this, group, obj,
exc);
}catch(...) {
printf("Even uncaught exception throwed an exception!\n");
More information about the vmkit-commits
mailing list