From 421f9e6091ca35352c825e7ec69439b3651da021 Mon Sep 17 00:00:00 2001 From: Andrew Haley Date: Tue, 3 Dec 2002 13:50:05 +0000 Subject: natClassLoader.cc (_Jv_PrepareCompiledClass): Call _Jv_PushClass. 2002-12-03 Andrew Haley * java/lang/natClassLoader.cc (_Jv_PrepareCompiledClass): Call _Jv_PushClass. (_Jv_InitNewClassFields): Set protectionDomain and chain = NULL. (_Jv_PopClass): New. (_Jv_PushClass): New. * java/lang/natClass.cc (forName (jstring)): Use a StackTrace to discover the ClassLoader of our caller. (_Jv_CheckArrayStore): Don't check that a class is assignment compatible with Object. * java/lang/natVMTHrowable.cc: Delete. * gnu/gcj/runtime/StackTrace.java: New, partly copied from java.lang.VMThrowable. (StackTrace(), StackTrace(int)): New constructors. (classAt, methodAt, update, methodAtAddress): New methods. (map): New field. * java/lang/VMThrowable.java: Use StackTrace instead of natVMTHrowable. * java/lang/Class.h (getClassLoaderInternal): New. (class Class): Be friendly with _Jv_PopClass and _Jv_PushClass. Be friendly with gnu::gcj::runtime::StackTrace. (Object.chain): New field. * include/java-interp.h (class _Jv_InterpMethod): Be friendly with gnu::gcj::runtime::StackTrace. * prims.cc (_Jv_NewObjectArray): Use getClassLoaderInternal() instead of getClassLoader(). * verify.cc (class _Jv_BytecodeVerifier): Likewise. java::lang::VMThrowable. * Makefile.am (core_java_source_files): Add MethodRef.java, StackTrace.java. (nat_source_files): Remove natVMThrowable.cc; add natStackTrace.cc. * Makefile.in: Rebuild. 2002-12-03 Andrew Haley * class.c (make_class_data): New field, "chain". * decl.c (java_init_decl_processing): Likewise. From-SVN: r59769 --- libjava/java/lang/Class.h | 13 +++++++++++++ libjava/java/lang/VMThrowable.java | 26 ++++++++++++++++++++------ libjava/java/lang/natClass.cc | 26 +++++++++++++++++++++++--- libjava/java/lang/natClassLoader.cc | 32 ++++++++++++++++++++++++++++++++ 4 files changed, 88 insertions(+), 9 deletions(-) (limited to 'libjava/java') diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h index bd2903d..6fb918a 100644 --- a/libjava/java/lang/Class.h +++ b/libjava/java/lang/Class.h @@ -20,6 +20,7 @@ details. */ #include #include #include +#include // We declare these here to avoid including gcj/cni.h. extern "C" void _Jv_InitClass (jclass klass); @@ -138,6 +139,13 @@ public: java::lang::ClassLoader *getClassLoader (void); + // This is an internal method that circumvents the usual security + // checks when getting the class loader. + java::lang::ClassLoader *getClassLoaderInternal (void) + { + return loader; + } + java::lang::reflect::Constructor *getConstructor (JArray *); JArray *getConstructors (void); java::lang::reflect::Constructor *getDeclaredConstructor (JArray *); @@ -296,6 +304,8 @@ private: java::lang::ClassLoader *loader); friend jclass _Jv_FindClassInCache (_Jv_Utf8Const *name, java::lang::ClassLoader *loader); + friend jclass _Jv_PopClass (void); + friend void _Jv_PushClass (jclass k); friend void _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader, _Jv_VTable *array_vtable = 0); @@ -349,6 +359,7 @@ private: #endif friend class _Jv_BytecodeVerifier; + friend class gnu::gcj::runtime::StackTrace; // Chain for class pool. jclass next; @@ -403,6 +414,8 @@ private: jclass arrayclass; // Security Domain to which this class belongs (or null). java::security::ProtectionDomain *protectionDomain; + // Used by Jv_PopClass and _Jv_PushClass to communicate with StackTrace. + jclass chain; }; #endif /* __JAVA_LANG_CLASS_H__ */ diff --git a/libjava/java/lang/VMThrowable.java b/libjava/java/lang/VMThrowable.java index 0a2c922..4c33857 100644 --- a/libjava/java/lang/VMThrowable.java +++ b/libjava/java/lang/VMThrowable.java @@ -38,9 +38,10 @@ exception statement from your version. */ package java.lang; import gnu.gcj.runtime.NameFinder; +import gnu.gcj.runtime.StackTrace; /** - * VM dependant state and support methods Throwabele. + * VM dependent state and support methods Throwable. * It is deliberately package local and final and should only be accessed * by the Throwable class. *

@@ -50,8 +51,7 @@ import gnu.gcj.runtime.NameFinder; */ final class VMThrowable { - private gnu.gcj.RawData stackTraceAddrs; - private int length; + private gnu.gcj.runtime.StackTrace trace; /** * Private contructor, create VMThrowables with fillInStackTrace(); @@ -67,7 +67,20 @@ final class VMThrowable * @return a new VMThrowable containing the current execution stack trace. * @see Throwable#fillInStackTrace() */ - static native VMThrowable fillInStackTrace(Throwable t); + static VMThrowable fillInStackTrace(Throwable t) + { + VMThrowable state = null; + + /* FIXME: size of the stack trace is limited to 128 elements. + It's undoubtedly sensible to limit the stack trace, but 128 is + rather arbitrary. It may be better to configure this. */ + if (trace_enabled) + { + state = new VMThrowable (); + state.trace = new gnu.gcj.runtime.StackTrace(128); + } + return state; + } /** * Returns an StackTraceElement array based on the execution @@ -80,10 +93,11 @@ final class VMThrowable StackTraceElement[] getStackTrace(Throwable t) { StackTraceElement[] result; - if (stackTraceAddrs != null) + if (trace != null) { NameFinder nameFinder = new NameFinder(); - result = nameFinder.lookup(t, stackTraceAddrs, length); + result = nameFinder.lookup(t, trace.stackTraceAddrs(), + trace.length()); nameFinder.close(); } else diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc index fb412f2..68fbd54 100644 --- a/libjava/java/lang/natClass.cc +++ b/libjava/java/lang/natClass.cc @@ -36,6 +36,7 @@ details. */ #include #include #include +#include #include #include #include @@ -47,7 +48,10 @@ details. */ #include #include #include +#include #include +#include +#include #include @@ -71,7 +75,6 @@ java::lang::Class::forName (jstring className, jboolean initialize, if (! _Jv_VerifyClassName (name)) throw new java::lang::ClassNotFoundException (className); - // FIXME: should use bootstrap class loader if loader is null. jclass klass = (buffer[0] == '[' ? _Jv_FindClassFromSignature (name->data, loader) : _Jv_FindClass (name, loader)); @@ -88,8 +91,23 @@ java::lang::Class::forName (jstring className, jboolean initialize, jclass java::lang::Class::forName (jstring className) { - // FIXME: should use class loader from calling method. - return forName (className, true, NULL); + java::lang::ClassLoader *loader = NULL; + gnu::gcj::runtime::StackTrace *t + = new gnu::gcj::runtime::StackTrace(4); + java::lang::Class *klass = NULL; + try + { + for (int i=1; !klass; i++) + { + klass = t->classAt (i); + } + loader = klass->getClassLoader(); + } + catch (::java::lang::ArrayIndexOutOfBoundsException *e) + { + } + + return forName (className, true, loader); } java::lang::ClassLoader * @@ -1040,6 +1058,8 @@ _Jv_CheckArrayStore (jobject arr, jobject obj) { JvAssert (arr != NULL); jclass elt_class = (JV_CLASS (arr))->getComponentType(); + if (elt_class == &java::lang::Object::class$) + return; jclass obj_class = JV_CLASS (obj); if (__builtin_expect (! _Jv_IsAssignableFrom (elt_class, obj_class), false)) diff --git a/libjava/java/lang/natClassLoader.cc b/libjava/java/lang/natClassLoader.cc index 8bff169..debcb4f 100644 --- a/libjava/java/lang/natClassLoader.cc +++ b/libjava/java/lang/natClassLoader.cc @@ -326,6 +326,8 @@ _Jv_PrepareCompiledClass (jclass klass) _Jv_LinkOffsetTable(klass); klass->notifyAll (); + + _Jv_PushClass (klass); } @@ -587,6 +589,8 @@ _Jv_InitNewClassFields (jclass ret) ret->ancestors = NULL; ret->idt = NULL; ret->arrayclass = NULL; + ret->protectionDomain = NULL; + ret->chain = NULL; } jclass @@ -732,3 +736,31 @@ _Jv_NewArrayClass (jclass element, java::lang::ClassLoader *loader, element->arrayclass = array_class; } + +static jclass stack_head; + +// These two functions form a stack of classes. When a class is loaded +// it is pushed onto the stack by the class loader; this is so that +// StackTrace can quickly determine which classes have been loaded. + +jclass +_Jv_PopClass (void) +{ + JvSynchronize sync (&java::lang::Class::class$); + if (stack_head) + { + jclass tmp = stack_head; + stack_head = tmp->chain; + return tmp; + } + return NULL; +} + +void +_Jv_PushClass (jclass k) +{ + JvSynchronize sync (&java::lang::Class::class$); + jclass tmp = stack_head; + stack_head = k; + k->chain = tmp; +} -- cgit v1.1