2005-03-10 Bryce McKinlay <mckinlay@redhat.com>

	New Stack Trace infrastructure.
	* Makefile.am (libgcj0_convenience_la_SOURCES): Add stacktrace.cc.
	(gnu/gcj/runtime/StackTrace.lo): Removed.
	(ordinary_java_source_files): Remove obsolete files.
	(nat_source_files): Remove obsolete files. Add natVMThrowable.cc.
	* configure.host (fallback_backtrace_h): Set backtrace header
	for mingw and cygwin targets.
	* configure.ac: Make symlink for fallback backtrace headers.
	* Makefile.in, configure: Rebuilt.
	* defineclass.cc (_Jv_ClassReader::read_one_code_attribute):
	Read 'LineNumberTable' attribute.
	(_Jv_ClassReader::read_one_class_attribute): Read 'SourceFile'
	attribute.
	(_Jv_ClassReader::handleCodeAttribute): Initialize method line
	table fields.
	* exception.cc: Remove unused include.
	* interpret.cc (DIRECT_THREADED, insn_slot): Moved to java-interp.h.
	(SAVE_PC): New macro. Save current PC in the interpreter frame.
	(NULLCHECK, NULLARRAYCHECK): Use SAVE_PC.
	(_Jv_InterpMethod::compile): Translate bytecode PC values in the line
	table to direct threaded instruction values.
	(_Jv_StartOfInterpreter, _Jv_EndOfInterpreter): Removed.
	(_Jv_InterpMethod::run): No longer member function. All
	callers updated. Remove _Unwind calls. Call SAVE_PC whenever a call
	is made or where an instruction could throw.
	(_Jv_InterpMethod::get_source_line): New. Look up source line numbers
	in line_table.
	* prims.cc (catch_segv): Construct exception after MAKE_THROW_FRAME.
	(catch_fpe): Likewise.
	* stacktrace.cc: New file. Stack trace code now here.
	* gnu/gcj/runtime/MethodRef.java:
	* gnu/gcj/runtime/NameFinder.java: Mostly reimplemented. Now simply
	calls addr2line to look up PC addresses in a given binary or shared
	library.
	* gnu/gcj/runtime/StackTrace.java, gnu/gcj/runtime/natNameFinder.cc,
	gnu/gcj/runtime/natStackTrace.cc: Removed.
	* gnu/java/lang/MainThread.java (call_main): Add comment warning that
	this function name is specially recognised by the stack trace code
	and shouldn't be changed.
	* include/java-interp.h (DIRECT_THREADED, insn_slot): Moved here.
	(struct  _Jv_LineTableEntry, line_table, line_table_len): New.
	(_Jv_InterpMethod::run): Update declaration.
	(_Jv_StackTrace_): New friend. NameFinder and StackTrace no longer
	friends.
	(_Jv_InterpFrame): Renamed from _Jv_MethodChain. Add PC field.
	* include/java-stack.h: New file. Declarations for stack tracing.
	* include/jvm.h (_Jv_Frame_info): Removed.
	* java/lang/Class.h: Update friend declarations.
	* java/lang/VMClassLoader.java (getSystemClassLoader): Simplify
	exception message.
	* java/lang/VMThrowable.java (fillInStackTrace): Now native.
	(getStackTrace): Now native.
	(data): New RawDataManaged field.
	* java/lang/natClass.cc: Update includes.
	(forName): Use _Jv_StackTrace::GetCallingClass for
	calling-classloader check.
	(getClassLoader): Likewise.
	* java/lang/natRuntime.cc: Update includes.
	(_load): Use _Jv_StackTrace::GetFirstNonSystemClassLoader.
	* java/lang/natVMSecurityManager.cc: Update includes.
	(getClassContext): Use _Jv_StackTrace::GetClassContext.
	* java/lang/natVMThrowable.cc: New file. Native methods for
	VMThrowable.
	* java/lang/reflect/natArray.cc: Update includes.
	(newInstance): Use _Jv_StackTrace::GetCallingClass to implement
	accessibility check.
	* java/lang/reflect/natConstructor.cc: Update includes.
	(newInstance): Use _Jv_StackTrace::GetCallingClass to implement
	accessibility check.
	* java/lang/reflect/natField.cc: Update includes.
	(getAddr): Use _Jv_StackTrace::GetCallingClass to implement
	accessibility check.
	* java/lang/reflect/natMethod.cc: Update includes.
	(invoke): Use _Jv_StackTrace::GetCallingClass to implement
	accessibility check.
	* java/util/natResourceBundle.cc: Update includes.
	(getCallingClassLoader): Use _Jv_StackTrace::GetCallingClass.
	* java/util/logging/natLogger.cc: Update includes. Use
	_Jv_StackTrace::GetCallerInfo to get call-site info.
	* sysdep/generic/backtrace.h: Fallback backtrace code. Stub
	implementation.
	* sysdep/i386/backtrace.h: New. Fallback backtrace code. i386
	implementation.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@96253 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 527 insertions, 0 deletions

diff --git a/libjava/stacktrace.cc b/libjava/stacktrace.cc
new file mode 100644
index 00000000000..0777d903a21
--- /dev/null
+++ b/libjava/stacktrace.cc
@@ -0,0 +1,527 @@
+// stacktrace.cc - Functions for unwinding & inspecting the call stack.
+
+/* Copyright (C) 2005  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 <jvm.h>
+#include <gcj/cni.h>
+#include <java-interp.h>
+#include <java-stack.h>
+
+#ifdef HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#include <java/lang/Class.h>
+#include <java/lang/Long.h>
+#include <java/util/ArrayList.h>
+#include <java/util/IdentityHashMap.h>
+#include <gnu/java/lang/MainThread.h>
+#include <gnu/gcj/runtime/NameFinder.h>
+
+#include <sysdep/backtrace.h>
+
+using namespace java::lang;
+using namespace java::lang::reflect;
+using namespace java::util;
+using namespace gnu::gcj::runtime;
+
+struct _Jv_FindCallingClassState: _Jv_UnwindState
+{
+  jclass result;
+};
+
+// Maps ncode values to their containing native class.
+// NOTE: Currently this Map contradicts class GC for native classes. This map
+// (and the "new class stack") will need to use WeakReferences in order to 
+// enable native class GC.
+static java::util::IdentityHashMap *ncodeMap;
+
+// Check the "class stack" for any classes initialized since we were last 
+// called, and add them to ncodeMap.
+void 
+_Jv_StackTrace::UpdateNCodeMap ()
+{
+  // The Map should be large enough so that a typical Java app doesn't cause 
+  // it to rehash, without using too much memory. ~5000 entries should be 
+  // enough.
+  if (ncodeMap == NULL)
+    ncodeMap = new java::util::IdentityHashMap (5087);
+  
+  jclass klass;
+  while ((klass = _Jv_PopClass ()))
+    {
+      //printf ("got %s\n", klass->name->data);
+#ifdef INTERPRETER
+      JvAssert (! _Jv_IsInterpretedClass (klass));
+#endif
+      for (int i=0; i < klass->method_count; i++)
+        {
+	  _Jv_Method *method = &klass->methods[i];
+	  // Add non-abstract methods to ncodeMap.
+	  if (method->ncode)
+	    {
+	      //printf("map->put 0x%x / %s.%s\n", method->ncode, klass->name->data,
+	      //  method->name->data);
+	      ncodeMap->put ((java::lang::Object *) method->ncode, klass);
+	    }
+	}
+    }
+}
+
+// Given a native frame, return the class which this code belongs 
+// to. Returns NULL if this IP is not associated with a native Java class.
+// If NCODE is supplied, it will be set with the ip for the entry point of the 
+// enclosing method.
+jclass
+_Jv_StackTrace::ClassForFrame (_Jv_StackFrame *frame)
+{
+  JvAssert (frame->type == frame_native);
+  jclass klass = NULL;
+  // use _Unwind_FindEnclosingFunction to find start of method
+  //void *entryPoint = _Unwind_FindEnclosingFunction (ip);
+
+  // look it up in ncodeMap
+  if (frame->start_ip)
+    klass = (jclass) ncodeMap->get ((jobject) frame->start_ip);
+
+  return klass;
+}
+
+_Unwind_Reason_Code
+_Jv_StackTrace::UnwindTraceFn (struct _Unwind_Context *context, void *state_ptr)
+{
+  _Jv_UnwindState *state = (_Jv_UnwindState *) state_ptr;
+  jint pos = state->pos;
+
+  // Check if the trace buffer needs to be extended.
+  if (pos == state->length)
+    {
+      int newLength = state->length *= 2;
+      void *newFrames = _Jv_AllocBytes (newLength * sizeof(_Jv_StackFrame));
+      memcpy (newFrames, state->frames, state->length * sizeof(_Jv_StackFrame));      
+      state->frames = (_Jv_StackFrame *) newFrames;
+      state->length = newLength;
+    }
+  
+  _Unwind_Ptr func_addr = _Unwind_GetRegionStart (context);
+  
+  // If we see the interpreter's main function, "pop" an entry off the 
+  // interpreter stack and use that instead, so that the trace goes through 
+  // the java code and not the interpreter itself. This assumes a 1:1 
+  // correspondance between call frames in the interpreted stack and occurances
+  // of _Jv_InterpMethod::run() on the native stack.
+  if (func_addr == (_Unwind_Ptr) &_Jv_InterpMethod::run)
+    {
+      state->frames[pos].type = frame_interpreter;
+      state->frames[pos].interp.meth = state->interp_frame->self;
+      state->frames[pos].interp.pc = state->interp_frame->pc;
+      state->interp_frame = state->interp_frame->next;
+    }
+  else
+    {
+      state->frames[pos].type = frame_native;
+      state->frames[pos].ip = (void *) _Unwind_GetIP (context);
+      state->frames[pos].start_ip = (void *) func_addr;
+    }
+
+  //printf ("unwind ip: %p\n", _Unwind_GetIP (context));
+
+  _Unwind_Reason_Code result = _URC_NO_REASON;
+  if (state->trace_function != NULL)
+    result = (state->trace_function) (state);
+  state->pos++;
+  return result;
+}
+
+// Return a raw stack trace from the current point of execution. The raw 
+// trace will include all functions that have unwind info.
+_Jv_StackTrace *
+_Jv_StackTrace::GetStackTrace(void)
+{
+  int trace_size = 100;
+  _Jv_StackFrame frames[trace_size];
+  _Jv_UnwindState state (trace_size);
+  state.frames = (_Jv_StackFrame *) &frames;
+
+#ifdef SJLJ_EXCEPTIONS
+  // The Unwind interface doesn't work with the SJLJ exception model.
+  // Fall back to a platform-specific unwinder.
+  fallback_backtrace (&state);
+#else /* SJLJ_EXCEPTIONS */  
+  _Unwind_Backtrace (UnwindTraceFn, &state);
+#endif /* SJLJ_EXCEPTIONS */
+  
+  // Copy the trace and return it.
+  int traceSize = sizeof (_Jv_StackTrace) + 
+    (sizeof (_Jv_StackFrame) * state.pos);
+  _Jv_StackTrace *trace = (_Jv_StackTrace *) _Jv_AllocBytes (traceSize);
+  trace->length = state.pos;
+  memcpy (trace->frames, state.frames, sizeof (_Jv_StackFrame) * state.pos);  
+  return trace;
+}
+
+void
+_Jv_StackTrace::getLineNumberForFrame(_Jv_StackFrame *frame, NameFinder *finder, 
+		 jstring *sourceFileName, jint *lineNum)
+{
+  if (frame->type == frame_interpreter)
+    {
+      _Jv_InterpMethod *interp_meth = frame->interp.meth;
+      _Jv_InterpClass *interp_class = 
+	 (_Jv_InterpClass *) interp_meth->defining_class->aux_info;
+      *sourceFileName = interp_class->source_file_name;
+      *lineNum = interp_meth->get_source_line(frame->interp.pc);
+      return;
+    }
+  // Use dladdr() to determine in which binary the address IP resides.
+#if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR)
+  extern char **_Jv_argv;
+  Dl_info info;
+  jstring binaryName = NULL;
+
+  void *ip = frame->ip;
+  _Unwind_Ptr offset = 0;
+  
+  if (dladdr (ip, &info))
+    {
+      if (info.dli_fname)
+	binaryName = JvNewStringUTF (info.dli_fname);
+      else
+        return;
+
+      // addr2line expects relative addresses for shared libraries.
+      if (strcmp (info.dli_fname, _Jv_argv[0]) == 0)
+        offset = (_Unwind_Ptr) ip;
+      else
+        offset = (_Unwind_Ptr) ip - (_Unwind_Ptr) info.dli_fbase;
+
+      //printf ("linenum ip: %p\n", ip);
+      //printf ("%s: 0x%x\n", info.dli_fname, offset);
+      //offset -= sizeof(void *);
+      
+      // The unwinder gives us the return address. In order to get the right
+      // line number for the stack trace, roll it back a little.
+      offset -= 1;
+
+      // printf ("%s: 0x%x\n", info.dli_fname, offset);
+      
+      finder->lookup (binaryName, (jlong) offset);
+      *sourceFileName = finder->getSourceFile();
+      *lineNum = finder->getLineNum();
+    }
+#endif
+}
+
+// Look up class and method info for the given stack frame, setting 
+// frame->klass and frame->meth if they are known.
+void
+_Jv_StackTrace::FillInFrameInfo (_Jv_StackFrame *frame)
+{
+  jclass klass = NULL;
+  _Jv_Method *meth = NULL;
+  
+  if (frame->type == frame_native)
+    {
+      klass = _Jv_StackTrace::ClassForFrame (frame);
+
+      if (klass != NULL)
+	// Find method in class
+	for (int j = 0; j < klass->method_count; j++)
+	  {
+	    if (klass->methods[j].ncode == frame->start_ip)
+	      {
+		meth = &klass->methods[j];
+		break;
+	      }
+	  }
+    }
+  else if (frame->type == frame_interpreter)
+    {
+      _Jv_InterpMethod *interp_meth = frame->interp.meth;
+      klass = interp_meth->defining_class;
+      meth = interp_meth->self;
+    }
+  else
+    JvFail ("Unknown frame type");
+  
+  frame->klass = klass;
+  frame->meth = meth;
+}
+
+// Convert raw stack frames to a Java array of StackTraceElement objects.
+JArray< ::java::lang::StackTraceElement *>*
+_Jv_StackTrace::GetStackTraceElements (_Jv_StackTrace *trace, 
+  Throwable *throwable __attribute__((unused)))
+{
+  ArrayList *list = new ArrayList ();
+
+#ifdef SJLJ_EXCEPTIONS
+  // We can't use the nCodeMap without unwinder support. Instead,
+  // fake the method name by giving the IP in hex - better than nothing.  
+  jstring hex = JvNewStringUTF ("0x");
+
+  for (int i = 0; i < trace->length; i++)
+    {
+      jstring sourceFileName = NULL;
+      jint lineNum = -1;
+      _Jv_StackFrame *frame = &trace->frames[i];
+      
+      jstring className = NULL;
+      jstring methodName = hex->concat (Long::toHexString ((jlong) frame->ip));
+
+      StackTraceElement *element = new StackTraceElement (sourceFileName, 
+	lineNum, className, methodName, 0);    
+      list->add (element);
+    }
+
+#else /* SJLJ_EXCEPTIONS */
+
+  //JvSynchronized (ncodeMap);
+  UpdateNCodeMap ();
+
+  NameFinder *finder = new NameFinder();
+  int start_idx = 0;
+  int end_idx = trace->length - 1;
+
+  // First pass: strip superfluous frames from beginning and end of the trace.  
+  for (int i = 0; i < trace->length; i++)
+    {
+      _Jv_StackFrame *frame = &trace->frames[i];
+      FillInFrameInfo (frame);
+
+      if (!frame->klass || !frame->meth)
+        // Not a Java frame.
+        continue;
+
+      // Throw away the top of the stack till we see:
+      //  - the constructor(s) of this Throwable, or
+      //  - the Throwable.fillInStackTrace call.
+      if (frame->klass == throwable->getClass()
+          && strcmp (frame->meth->name->chars(), "<init>") == 0)
+        start_idx = i + 1;
+
+      if (frame->klass == &Throwable::class$
+          && strcmp (frame->meth->name->chars(), "fillInStackTrace") == 0)
+	start_idx = i + 1;
+
+      // End the trace at the application's main() method if we see call_main.
+      if (frame->klass == &gnu::java::lang::MainThread::class$
+          && strcmp (frame->meth->name->chars(), "call_main") == 0)
+	end_idx = i - 1;
+    }
+  
+  // Second pass: Look up line-number info for remaining frames.
+  for (int i = start_idx; i <= end_idx; i++)
+    {
+      _Jv_StackFrame *frame = &trace->frames[i];
+      
+      if (frame->klass == NULL)
+        // Not a Java frame.
+	continue;
+      
+      jstring className = frame->klass->getName ();
+      jstring methodName = NULL;
+      if (frame->meth)
+        methodName = JvNewStringUTF (frame->meth->name->chars());
+      
+      jstring sourceFileName = NULL;
+      jint lineNum = -1;
+      
+      getLineNumberForFrame(frame, finder, &sourceFileName, &lineNum);
+      
+      StackTraceElement *element = new StackTraceElement (sourceFileName, lineNum,
+        className, methodName, 0);
+      list->add (element);
+    }
+  
+  finder->close();
+#endif /* SJLJ_EXCEPTIONS */
+
+  JArray<Object *> *array = JvNewObjectArray (list->size (), 
+    &StackTraceElement::class$, NULL);
+
+  return (JArray<StackTraceElement *>*) list->toArray (array);
+}
+
+struct CallingClassTraceData
+{
+  jclass checkClass;    
+  jclass foundClass;
+  _Jv_Method *foundMeth;
+  bool seen_checkClass;
+};
+
+_Unwind_Reason_Code
+_Jv_StackTrace::calling_class_trace_fn (_Jv_UnwindState *state)
+{
+  CallingClassTraceData *trace_data = (CallingClassTraceData *)
+    state->trace_data;
+  _Jv_StackFrame *frame = &state->frames[state->pos];
+  FillInFrameInfo (frame);
+
+  if (trace_data->seen_checkClass
+      && frame->klass
+      && frame->klass != trace_data->checkClass)
+    {
+      trace_data->foundClass = frame->klass;
+      trace_data->foundMeth = frame->meth;
+      return _URC_NORMAL_STOP;
+    }
+  
+  if (frame->klass == trace_data->checkClass)
+    trace_data->seen_checkClass = true;
+    
+  return _URC_NO_REASON;
+}
+
+// Find the class immediately above the given class on the call stack. Any 
+// intermediate non-Java 
+// frames are ignored. If the calling class could not be determined (eg because 
+// the unwinder is not supported on this platform), NULL is returned.
+// This function is used to implement calling-classloader checks and reflection
+// accessibility checks.
+// CHECKCLASS is typically the class calling GetCallingClass. The first class
+// above CHECKCLASS on the call stack will be returned.
+jclass
+_Jv_StackTrace::GetCallingClass (jclass checkClass)
+{
+  jclass result = NULL;
+  GetCallerInfo (checkClass, &result, NULL);
+  return result;
+}
+
+void
+_Jv_StackTrace::GetCallerInfo (jclass checkClass, jclass *caller_class,
+  _Jv_Method **caller_meth)
+{
+#ifndef SJLJ_EXCEPTIONS
+  int trace_size = 20;
+  _Jv_StackFrame frames[trace_size];
+  _Jv_UnwindState state (trace_size);
+  state.frames = (_Jv_StackFrame *) &frames;
+
+  CallingClassTraceData trace_data;
+  trace_data.checkClass = checkClass;
+  trace_data.seen_checkClass = false;
+  trace_data.foundClass = NULL;
+  trace_data.foundMeth = NULL;
+
+  state.trace_function = calling_class_trace_fn;
+  state.trace_data = (void *) &trace_data;
+
+  //JvSynchronized (ncodeMap);
+  UpdateNCodeMap ();
+
+  _Unwind_Backtrace (UnwindTraceFn, &state);
+  
+  if (caller_class)
+    *caller_class = trace_data.foundClass;
+  if (caller_meth)
+    *caller_meth = trace_data.foundMeth;
+#else
+  return NULL;
+#endif
+}
+
+// Return a java array containing the Java classes on the stack above CHECKCLASS.
+JArray<jclass> *
+_Jv_StackTrace::GetClassContext (jclass checkClass)
+{
+  JArray<jclass> *result = NULL;
+
+  int trace_size = 100;
+  _Jv_StackFrame frames[trace_size];
+  _Jv_UnwindState state (trace_size);
+  state.frames = (_Jv_StackFrame *) &frames;
+
+  //JvSynchronized (ncodeMap);
+  UpdateNCodeMap ();
+
+  _Unwind_Backtrace (UnwindTraceFn, &state);
+
+  // Count the number of Java frames on the stack.
+  int jframe_count = 0;
+  bool seen_checkClass = false;
+  int start_pos = -1;
+  for (int i = 0; i < state.pos; i++)
+    {
+      _Jv_StackFrame *frame = &state.frames[i];
+      FillInFrameInfo (frame);
+      
+      if (seen_checkClass
+          && frame->klass
+	  && frame->klass != checkClass)
+	{
+          jframe_count++;
+	  if (start_pos == -1)
+	    start_pos = i;
+	}
+
+      if (!seen_checkClass
+          && frame->klass
+          && frame->klass == checkClass)
+        seen_checkClass = true;
+    }
+  result = (JArray<jclass> *) _Jv_NewObjectArray (jframe_count, &Class::class$, NULL);
+  int pos = 0;
+  
+  for (int i = start_pos; i < state.pos; i++)
+    {
+      _Jv_StackFrame *frame = &state.frames[i];
+      if (frame->klass)
+        elements(result)[pos++] = frame->klass;
+    }
+  return result;
+}
+
+_Unwind_Reason_Code
+_Jv_StackTrace::non_system_trace_fn (_Jv_UnwindState *state)
+{
+  _Jv_StackFrame *frame = &state->frames[state->pos];
+  FillInFrameInfo (frame);
+  
+  ClassLoader *classLoader = NULL;
+
+  if (frame->klass)
+    {
+      classLoader = frame->klass->getClassLoaderInternal();
+      if (classLoader != NULL && classLoader != ClassLoader::systemClassLoader)
+        {
+          state->trace_data = (void *) classLoader;
+	  return _URC_NORMAL_STOP;
+	}
+    }
+
+  return _URC_NO_REASON;
+}
+
+ClassLoader *
+_Jv_StackTrace::GetFirstNonSystemClassLoader ()
+{
+  int trace_size = 32;
+  _Jv_StackFrame frames[trace_size];
+  _Jv_UnwindState state (trace_size);
+  state.frames = (_Jv_StackFrame *) &frames;
+  state.trace_function = non_system_trace_fn;
+  state.trace_data = NULL;
+
+  //JvSynchronized (ncodeMap);
+  UpdateNCodeMap ();
+  
+  _Unwind_Backtrace (UnwindTraceFn, &state);
+
+  if (state.trace_data)
+    return (ClassLoader *) state.trace_data;
+  
+  return NULL;
+}