natThrowable.cc: New file.

2000-01-14  Andrew Haley  <aph@cygnus.com>

	* java/lang/natThrowable.cc: New file.

	* java/lang/Throwable.java (fillInStackTrace): Make native.
	(printStackTrace): Call native method to do this.
	(Throwable): Call fillInStackTrace.
	(stackTrace): New variable.

	* include/jvm.h: Add _Jv_ThisExecutable functions.

	* prims.cc: (_Jv_execName): New variable.
	(catch_segv): Call fillInStackTrace.
	(catch_fpe): Ditto.
	(_Jv_ThisExecutable): New functions.
	(JvRunMain): Set the name of this executable.

	* Makefile.am: Add java/lang/natThrowable.cc.
	Add name-finder.cc.
	* Makefile.in: Rebuilt.

	* acconfig.h: Add HAVE_PROC_SELF_EXE.

	* configure.in: Force link with __frame_state_for in
	FORCELIBGCCSPEC.  Add new checks for backtrace.
	* include/config.h.in: Rebuilt.

	* name-finder.cc: New file.
	* include/name-finder.h: New file.

From-SVN: r31460

1 files changed, 95 insertions, 0 deletions

diff --git a/libjava/java/lang/natThrowable.cc b/libjava/java/lang/natThrowable.cc
new file mode 100644
index 0000000..2227e7d
--- /dev/null
+++ b/libjava/java/lang/natThrowable.cc
@@ -0,0 +1,95 @@
+// natThrowable.cc - Superclass for all exceptions.
+
+/* Copyright (C) 2000  Red Hat Inc
+
+   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.  */
+
+/**
+ * @author Andrew Haley <aph@cygnus.com>
+ * @date Jan 6  2000
+ */
+
+#include <config.h>
+
+#include <string.h>
+
+#pragma implementation "Throwable.h"
+
+#include <gcj/cni.h>
+#include <jvm.h>
+#include <java/lang/Object.h>
+#include <java-threads.h>
+#include <java/lang/Throwable.h>
+#include <java/io/PrintStream.h>
+#include <java/io/PrintWriter.h>
+
+#include <sys/types.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <unistd.h>
+
+#ifdef HAVE_EXECINFO_H
+#include <execinfo.h>
+#endif
+
+#include <name-finder.h>
+
+/* 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.  */
+
+java::lang::Throwable *
+java::lang::Throwable::fillInStackTrace (void)
+{
+#ifdef HAVE_BACKTRACE
+  void *p[128];
+  
+  // We subtract 1 from the number of elements because we don't want
+  // to include the call to fillInStackTrace in the trace.
+  int n = backtrace (p, 128) - 1;  
+
+  // ???  Might this cause a problem if the byte array isn't aligned?
+  stackTrace = JvNewByteArray (n * sizeof p[0]);
+  memcpy (elements (stackTrace), p+1, (n * sizeof p[0]));
+
+  return this;
+#endif
+}
+
+void 
+java::lang::Throwable::printStackTrace (java::io::PrintWriter *wr)
+{
+  wr->println (toString ());
+#ifdef HAVE_BACKTRACE
+  if (!stackTrace)
+    return;
+
+  void **p = (void **)elements (stackTrace);
+  int depth = stackTrace->length / sizeof p[0];
+
+  _Jv_name_finder finder (_Jv_ThisExecutable ());
+
+  for (int i = 0; i < depth; i++)
+    {
+      bool found = finder.lookup (p[i]);
+      wr->print (JvNewStringLatin1 ("   at "));
+      wr->print (JvNewStringLatin1 (finder.hex));
+      if (found)
+	{
+	  wr->print (JvNewStringLatin1 (": "));
+	  wr->print (JvNewStringLatin1 (finder.method_name));
+	  wr->print (JvNewStringLatin1 (" ("));
+	  wr->print (JvNewStringLatin1 (finder.file_name));
+	  wr->print (JvNewStringLatin1 (")"));
+	}
+      wr->println ();
+    }
+#endif /* HAVE_BACKTRACE */
+}
+