aboutsummaryrefslogtreecommitdiff
path: root/libjava/java
diff options
context:
space:
mode:
Diffstat (limited to 'libjava/java')
-rw-r--r--libjava/java/lang/Class.h7
-rw-r--r--libjava/java/lang/VMClassLoader.java8
-rw-r--r--libjava/java/lang/VMThrowable.java44
-rw-r--r--libjava/java/lang/natClass.cc37
-rw-r--r--libjava/java/lang/natRuntime.cc25
-rw-r--r--libjava/java/lang/natVMSecurityManager.cc33
-rw-r--r--libjava/java/lang/natVMThrowable.cc45
-rw-r--r--libjava/java/lang/reflect/natArray.cc18
-rw-r--r--libjava/java/lang/reflect/natConstructor.cc16
-rw-r--r--libjava/java/lang/reflect/natField.cc14
-rw-r--r--libjava/java/lang/reflect/natMethod.cc16
-rw-r--r--libjava/java/util/logging/natLogger.cc26
-rw-r--r--libjava/java/util/natResourceBundle.cc27
13 files changed, 98 insertions, 218 deletions
diff --git a/libjava/java/lang/Class.h b/libjava/java/lang/Class.h
index d7b21e7..46feff6 100644
--- a/libjava/java/lang/Class.h
+++ b/libjava/java/lang/Class.h
@@ -21,7 +21,6 @@ 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);
@@ -238,13 +237,13 @@ jclass _Jv_GetArrayClass (jclass klass, java::lang::ClassLoader *loader);
jboolean _Jv_IsInterpretedClass (jclass);
void _Jv_InitField (jobject, jclass, int);
-class _Jv_ClassReader;
+class _Jv_ClassReader;
class _Jv_InterpClass;
class _Jv_InterpMethod;
#endif
+class _Jv_StackTrace;
class _Jv_BytecodeVerifier;
-class gnu::gcj::runtime::StackTrace;
class java::io::VMObjectStreamClass;
void _Jv_sharedlib_register_hook (jclass klass);
@@ -473,6 +472,7 @@ private:
friend class ::_Jv_ClassReader;
friend class ::_Jv_InterpClass;
friend class ::_Jv_InterpMethod;
+ friend class ::_Jv_StackTrace;
#endif
#ifdef JV_MARKOBJ_DECL
@@ -480,7 +480,6 @@ private:
#endif
friend class ::_Jv_BytecodeVerifier;
- friend class gnu::gcj::runtime::StackTrace;
friend class java::io::VMObjectStreamClass;
friend class ::_Jv_Linker;
diff --git a/libjava/java/lang/VMClassLoader.java b/libjava/java/lang/VMClassLoader.java
index e21bb64..c0739ba 100644
--- a/libjava/java/lang/VMClassLoader.java
+++ b/libjava/java/lang/VMClassLoader.java
@@ -304,12 +304,10 @@ final class VMClassLoader
default_sys
= (ClassLoader) c.newInstance(new Object[] { default_sys });
}
- catch (Exception e)
+ catch (Exception ex)
{
- System.err.println("Requested system classloader "
- + loader + " failed, using "
- + "gnu.gcj.runtime.VMClassLoader");
- e.printStackTrace();
+ throw new Error("Failed to load requested system classloader "
+ + loader, ex);
}
}
return default_sys;
diff --git a/libjava/java/lang/VMThrowable.java b/libjava/java/lang/VMThrowable.java
index 102916a..f3b079a 100644
--- a/libjava/java/lang/VMThrowable.java
+++ b/libjava/java/lang/VMThrowable.java
@@ -1,5 +1,5 @@
/* java.lang.VMThrowable -- VM support methods for Throwable.
- Copyright (C) 1998, 1999, 2002, 2004 Free Software Foundation, Inc.
+ Copyright (C) 1998, 1999, 2002, 2004, 2005 Free Software Foundation, Inc.
This file is part of GNU Classpath.
@@ -37,8 +37,7 @@ exception statement from your version. */
package java.lang;
-import gnu.gcj.runtime.NameFinder;
-import gnu.gcj.runtime.StackTrace;
+import gnu.gcj.RawDataManaged;
/**
* VM dependent state and support methods Throwable.
@@ -51,10 +50,8 @@ import gnu.gcj.runtime.StackTrace;
*/
final class VMThrowable
{
- private gnu.gcj.runtime.StackTrace trace;
-
/**
- * Private contructor, create VMThrowables with fillInStackTrace();
+ * Private contructor, create VMThrowables with StackTrace();
*/
private VMThrowable() { }
@@ -67,20 +64,7 @@ final class VMThrowable
* @return a new VMThrowable containing the current execution stack trace.
* @see Throwable#fillInStackTrace()
*/
- 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;
- }
+ static native VMThrowable fillInStackTrace(Throwable t);
/**
* Returns an <code>StackTraceElement</code> array based on the execution
@@ -90,21 +74,11 @@ final class VMThrowable
* @return a non-null but possible zero length array of StackTraceElement.
* @see Throwable#getStackTrace()
*/
- StackTraceElement[] getStackTrace(Throwable t)
- {
- StackTraceElement[] result;
- if (trace != null)
- {
- NameFinder nameFinder = new NameFinder();
- result = nameFinder.lookup(t, trace);
- nameFinder.close();
- }
- else
- result = new StackTraceElement[0];
-
- return result;
- }
-
+ native StackTraceElement[] getStackTrace(Throwable t);
+
// Setting this flag to false prevents fillInStackTrace() from running.
static boolean trace_enabled = true;
+
+ // Native stack data.
+ private RawDataManaged data;
}
diff --git a/libjava/java/lang/natClass.cc b/libjava/java/lang/natClass.cc
index f29f667..25343e3 100644
--- a/libjava/java/lang/natClass.cc
+++ b/libjava/java/lang/natClass.cc
@@ -53,7 +53,6 @@ details. */
#include <java/lang/SecurityManager.h>
#include <java/lang/StringBuffer.h>
#include <java/lang/VMClassLoader.h>
-#include <gnu/gcj/runtime/StackTrace.h>
#include <gcj/method.h>
#include <gnu/gcj/runtime/MethodRef.h>
#include <gnu/gcj/RawData.h>
@@ -62,6 +61,7 @@ details. */
#include <java-cpool.h>
#include <java-interp.h>
#include <java-assert.h>
+#include <java-stack.h>
#include <execution.h>
@@ -101,20 +101,10 @@ jclass
java::lang::Class::forName (jstring className)
{
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->getClassLoaderInternal();
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
+
+ jclass caller = _Jv_StackTrace::GetCallingClass (&Class::class$);
+ if (caller)
+ loader = caller->getClassLoaderInternal();
return forName (className, true, loader);
}
@@ -125,21 +115,10 @@ java::lang::Class::getClassLoader (void)
java::lang::SecurityManager *s = java::lang::System::getSecurityManager();
if (s != NULL)
{
- gnu::gcj::runtime::StackTrace *t
- = new gnu::gcj::runtime::StackTrace(4);
- Class *caller = NULL;
+ jclass caller = _Jv_StackTrace::GetCallingClass (&Class::class$);
ClassLoader *caller_loader = NULL;
- try
- {
- for (int i = 1; !caller; i++)
- {
- caller = t->classAt (i);
- }
- caller_loader = caller->getClassLoaderInternal();
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
+ if (caller)
+ caller_loader = caller->getClassLoaderInternal();
// If the caller has a non-null class loader, and that loader
// is not this class' loader or an ancestor thereof, then do a
diff --git a/libjava/java/lang/natRuntime.cc b/libjava/java/lang/natRuntime.cc
index 97a69b2..d013878 100644
--- a/libjava/java/lang/natRuntime.cc
+++ b/libjava/java/lang/natRuntime.cc
@@ -16,6 +16,7 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
#include <java-props.h>
+#include <java-stack.h>
#include <java/lang/Long.h>
#include <java/lang/Runtime.h>
#include <java/lang/UnknownError.h>
@@ -29,8 +30,6 @@ details. */
#include <java/lang/Process.h>
#include <java/lang/ConcreteProcess.h>
#include <java/lang/ClassLoader.h>
-#include <gnu/gcj/runtime/StackTrace.h>
-#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <jni.h>
@@ -164,27 +163,7 @@ java::lang::Runtime::_load (jstring path, jboolean do_search)
if (do_search)
{
ClassLoader *sys = ClassLoader::systemClassLoader;
- ClassLoader *look = NULL;
- gnu::gcj::runtime::StackTrace *t = new gnu::gcj::runtime::StackTrace(10);
- try
- {
- for (int i = 0; i < 10; ++i)
- {
- jclass klass = t->classAt(i);
- if (klass != NULL)
- {
- ClassLoader *loader = klass->getClassLoaderInternal();
- if (loader != NULL && loader != sys)
- {
- look = loader;
- break;
- }
- }
- }
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
+ ClassLoader *look = _Jv_StackTrace::GetFirstNonSystemClassLoader ();
if (look != NULL)
{
diff --git a/libjava/java/lang/natVMSecurityManager.cc b/libjava/java/lang/natVMSecurityManager.cc
index 8fd2875..d55b7a5 100644
--- a/libjava/java/lang/natVMSecurityManager.cc
+++ b/libjava/java/lang/natVMSecurityManager.cc
@@ -12,43 +12,18 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
+#include <java-stack.h>
+
#include <java/lang/VMSecurityManager.h>
#include <java/lang/SecurityManager.h>
#include <java/lang/ClassLoader.h>
#include <java/lang/Class.h>
-#include <gnu/gcj/runtime/StackTrace.h>
JArray<jclass> *
java::lang::VMSecurityManager::getClassContext ()
{
- JArray<jclass> *result = NULL;
- gnu::gcj::runtime::StackTrace *t = new gnu::gcj::runtime::StackTrace();
- if (t)
- {
- int maxlen = t->length();
-
- int len = 0;
- for (int i=0; i<maxlen; i++)
- {
- jclass klass = t->classAt(i);
- if (klass != NULL && klass != &java::lang::VMSecurityManager::class$
- && klass != &java::lang::SecurityManager::class$)
- ++len;
- }
-
- result =
- (JArray<jclass> *) _Jv_NewObjectArray (len, &java::lang::Class::class$,
- NULL);
-
- len = 0;
- for (int i=0; i<maxlen; i++)
- {
- jclass klass = t->classAt(i);
- if (klass != NULL && klass != &java::lang::VMSecurityManager::class$
- && klass != &java::lang::SecurityManager::class$)
- elements(result)[len++] = klass;
- }
- }
+ JArray<jclass> *result =
+ _Jv_StackTrace::GetClassContext (&SecurityManager::class$);
return result;
}
diff --git a/libjava/java/lang/natVMThrowable.cc b/libjava/java/lang/natVMThrowable.cc
new file mode 100644
index 0000000..6db1a1f
--- /dev/null
+++ b/libjava/java/lang/natVMThrowable.cc
@@ -0,0 +1,45 @@
+// natVMThrowable.cc - Native part of VMThrowable class.
+
+/* Copyright (C) 2003 Free Software Foundation
+
+ This file is part of libgcj.
+
+This software is copyrighted work licensed under the terms of the
+Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
+details. */
+
+#include <config.h>
+
+#include <stdlib.h>
+
+#include <gcj/cni.h>
+#include <jvm.h>
+#include <java-stack.h>
+
+#include <java/lang/Throwable.h>
+#include <java/lang/VMThrowable.h>
+
+using namespace gnu::gcj;
+
+java::lang::VMThrowable *
+java::lang::VMThrowable::fillInStackTrace (java::lang::Throwable *)
+{
+ using namespace java::lang;
+
+ // Don't trace stack during initialization of the runtime.
+ if (! trace_enabled)
+ return NULL;
+
+ _Jv_StackTrace *trace = _Jv_StackTrace::GetStackTrace ();
+ VMThrowable *vmthrowable = new VMThrowable ();
+ vmthrowable->data = (RawDataManaged *) trace;
+ return vmthrowable;
+}
+
+
+JArray< ::java::lang::StackTraceElement *> *
+java::lang::VMThrowable::getStackTrace (java::lang::Throwable *throwable)
+{
+ _Jv_StackTrace *trace = reinterpret_cast <_Jv_StackTrace *> (data);
+ return _Jv_StackTrace::GetStackTraceElements (trace, throwable);
+}
diff --git a/libjava/java/lang/reflect/natArray.cc b/libjava/java/lang/reflect/natArray.cc
index ce76b9c..b7bc8be 100644
--- a/libjava/java/lang/reflect/natArray.cc
+++ b/libjava/java/lang/reflect/natArray.cc
@@ -14,6 +14,7 @@ details. */
#include <jvm.h>
#include <gcj/cni.h>
+#include <java-stack.h>
#include <java/lang/reflect/Array.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/IllegalArgumentException.h>
@@ -54,21 +55,10 @@ java::lang::reflect::Array::newInstance (jclass componentType,
if (ndims == 1)
return newInstance (componentType, dims[0]);
- gnu::gcj::runtime::StackTrace *t
- = new gnu::gcj::runtime::StackTrace(4);
- Class *caller = NULL;
+ Class *caller = _Jv_StackTrace::GetCallingClass (&Array::class$);
ClassLoader *caller_loader = NULL;
- try
- {
- for (int i = 1; !caller; i++)
- {
- caller = t->classAt (i);
- }
- caller_loader = caller->getClassLoaderInternal();
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
+ if (caller)
+ caller_loader = caller->getClassLoaderInternal();
jclass arrayType = componentType;
for (int i = 0; i < ndims; i++)
diff --git a/libjava/java/lang/reflect/natConstructor.cc b/libjava/java/lang/reflect/natConstructor.cc
index 3697332..f4d9590 100644
--- a/libjava/java/lang/reflect/natConstructor.cc
+++ b/libjava/java/lang/reflect/natConstructor.cc
@@ -12,6 +12,7 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
+#include <java-stack.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
#include <java/lang/IllegalAccessException.h>
@@ -55,20 +56,7 @@ java::lang::reflect::Constructor::newInstance (jobjectArray args)
// Check accessibility, if required.
if (! (Modifier::isPublic (meth->accflags) || this->isAccessible()))
{
- gnu::gcj::runtime::StackTrace *t
- = new gnu::gcj::runtime::StackTrace(4);
- Class *caller = NULL;
- try
- {
- for (int i = 1; !caller; i++)
- {
- caller = t->classAt (i);
- }
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
-
+ Class *caller = _Jv_StackTrace::GetCallingClass (&Constructor::class$);
if (! _Jv_CheckAccess(caller, declaringClass, meth->accflags))
throw new IllegalAccessException;
}
diff --git a/libjava/java/lang/reflect/natField.cc b/libjava/java/lang/reflect/natField.cc
index 9a8107b..33a5717 100644
--- a/libjava/java/lang/reflect/natField.cc
+++ b/libjava/java/lang/reflect/natField.cc
@@ -13,6 +13,7 @@ details. */
#include <stdlib.h>
#include <jvm.h>
+#include <java-stack.h>
#include <java/lang/reflect/Field.h>
#include <java/lang/reflect/Modifier.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
@@ -78,18 +79,7 @@ getAddr (java::lang::reflect::Field* field, jclass caller, jobject obj,
// Check accessibility, if required.
if (! (Modifier::isPublic (flags) || field->isAccessible()))
{
- gnu::gcj::runtime::StackTrace *t
- = new gnu::gcj::runtime::StackTrace(7);
- try
- {
- // We want to skip all the frames on the stack from this class.
- for (int i = 1; !caller || caller == &Field::class$; i++)
- caller = t->classAt (i);
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
-
+ caller = _Jv_StackTrace::GetCallingClass (&Field::class$);
if (! _Jv_CheckAccess (caller, field->getDeclaringClass(), flags))
throw new java::lang::IllegalAccessException;
}
diff --git a/libjava/java/lang/reflect/natMethod.cc b/libjava/java/lang/reflect/natMethod.cc
index 27c26e1..4329443 100644
--- a/libjava/java/lang/reflect/natMethod.cc
+++ b/libjava/java/lang/reflect/natMethod.cc
@@ -13,6 +13,7 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
#include <jni.h>
+#include <java-stack.h>
#include <java/lang/reflect/Method.h>
#include <java/lang/reflect/Constructor.h>
@@ -168,20 +169,7 @@ java::lang::reflect::Method::invoke (jobject obj, jobjectArray args)
// Check accessibility, if required.
if (! (Modifier::isPublic (meth->accflags) || this->isAccessible()))
{
- gnu::gcj::runtime::StackTrace *t
- = new gnu::gcj::runtime::StackTrace(4);
- Class *caller = NULL;
- try
- {
- for (int i = 1; !caller; i++)
- {
- caller = t->classAt (i);
- }
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
-
+ Class *caller = _Jv_StackTrace::GetCallingClass (&Method::class$);
if (! _Jv_CheckAccess(caller, declaringClass, meth->accflags))
throw new IllegalAccessException;
}
diff --git a/libjava/java/util/logging/natLogger.cc b/libjava/java/util/logging/natLogger.cc
index 15d1ab7..e92c487 100644
--- a/libjava/java/util/logging/natLogger.cc
+++ b/libjava/java/util/logging/natLogger.cc
@@ -17,7 +17,7 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
-
+#include <java-stack.h>
#include <java/lang/Object.h>
#include <java/lang/Class.h>
@@ -25,31 +25,19 @@ details. */
#include <java/lang/StackTraceElement.h>
#include <java/lang/ArrayIndexOutOfBoundsException.h>
+using namespace java::util::logging;
+
java::lang::StackTraceElement*
java::util::logging::Logger::getCallerStackFrame ()
{
- gnu::gcj::runtime::StackTrace *t
- = new gnu::gcj::runtime::StackTrace(4);
- java::lang::Class *klass = NULL;
- int i = 2;
- try
- {
- // skip until this class
- while ((klass = t->classAt (i)) != getClass())
- i++;
- // skip the stackentries of this class
- while ((klass = t->classAt (i)) == getClass() || klass == NULL)
- i++;
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- // FIXME: RuntimeError
- }
+ jclass klass = NULL;
+ _Jv_Method *meth = NULL;
+ _Jv_StackTrace::GetCallerInfo (&Logger::class$, &klass, &meth);
java::lang::StackTraceElement *e
= new java::lang::StackTraceElement
(JvNewStringUTF (""), 0,
- klass->getName(), t->methodAt(i), false);
+ klass->getName(), _Jv_NewStringUtf8Const (meth->name), false);
return e;
}
diff --git a/libjava/java/util/natResourceBundle.cc b/libjava/java/util/natResourceBundle.cc
index 35e90ee..e8d4fb4f 100644
--- a/libjava/java/util/natResourceBundle.cc
+++ b/libjava/java/util/natResourceBundle.cc
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003 Free Software Foundation
+/* Copyright (C) 2002, 2003, 2005 Free Software Foundation
This file is part of libgcj.
@@ -12,31 +12,18 @@ details. */
#include <gcj/cni.h>
#include <jvm.h>
+#include <java-stack.h>
#include <java/util/ResourceBundle.h>
-#include <java/lang/SecurityManager.h>
#include <java/lang/ClassLoader.h>
#include <java/lang/Class.h>
-#include <java/lang/ArrayIndexOutOfBoundsException.h>
-#include <gnu/gcj/runtime/StackTrace.h>
+
+using namespace java::lang;
java::lang::ClassLoader *
java::util::ResourceBundle::getCallingClassLoader ()
{
- gnu::gcj::runtime::StackTrace *t = new gnu::gcj::runtime::StackTrace(6);
- try
- {
- /* Frame 0 is this method, frame 1 is getBundle, so starting at
- frame 2 we might see the user's class. FIXME: should account
- for reflection, JNI, etc, here. */
- for (int i = 2; ; ++i)
- {
- jclass klass = t->classAt(i);
- if (klass != NULL)
- return klass->getClassLoaderInternal();
- }
- }
- catch (::java::lang::ArrayIndexOutOfBoundsException *e)
- {
- }
+ jclass caller = _Jv_StackTrace::GetCallingClass (&ResourceBundle::class$);
+ if (caller)
+ return caller->getClassLoaderInternal();
return NULL;
}
generated by cgit v1.1 at 2025-04-16 15:47:52 +0000