aboutsummaryrefslogtreecommitdiff
path: root/libjava/java/lang
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/java/lang')
-rw-r--r--libjava/java/lang/Class.h13
-rw-r--r--libjava/java/lang/VMThrowable.java26
-rw-r--r--libjava/java/lang/natClass.cc26
-rw-r--r--libjava/java/lang/natClassLoader.cc32
4 files changed, 88 insertions, 9 deletions
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 <java/lang/reflect/Modifier.h>
#include <java/security/ProtectionDomain.h>
#include <java/lang/Package.h>
+#include <gnu/gcj/runtime/StackTrace.h>
// 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<jclass> *);
JArray<java::lang::reflect::Constructor *> *getConstructors (void);
java::lang::reflect::Constructor *getDeclaredConstructor (JArray<jclass> *);
@@ -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.
* <p>
@@ -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 <code>StackTraceElement</code> 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 <java/lang/IllegalAccessError.h>
#include <java/lang/IllegalArgumentException.h>
#include <java/lang/IncompatibleClassChangeError.h>
+#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/InstantiationException.h>
#include <java/lang/NoClassDefFoundError.h>
#include <java/lang/NoSuchFieldException.h>
@@ -47,7 +48,10 @@ details. */
#include <java/lang/System.h>
#include <java/lang/SecurityManager.h>
#include <java/lang/StringBuffer.h>
+#include <gnu/gcj/runtime/StackTrace.h>
#include <gcj/method.h>
+#include <gnu/gcj/runtime/MethodRef.h>
+#include <gnu/gcj/RawData.h>
#include <java-cpool.h>
@@ -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;
+}
generated by cgit v1.1 at 2025-05-03 03:30:37 +0000