1 // stacktrace.cc - Functions for unwinding & inspecting the call stack.
3 /* Copyright (C) 2005, 2006 Free Software Foundation
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
15 #include <java-interp.h>
16 #include <java-stack.h>
24 #include <java/lang/Class.h>
25 #include <java/lang/Long.h>
26 #include <java/util/ArrayList.h>
27 #include <java/util/IdentityHashMap.h>
28 #include <gnu/java/lang/MainThread.h>
29 #include <gnu/gcj/runtime/NameFinder.h>
31 #include <sysdep/backtrace.h>
32 #include <sysdep/descriptor.h>
34 using namespace java::lang;
35 using namespace java::lang::reflect;
36 using namespace java::util;
37 using namespace gnu::gcj::runtime;
39 // Maps ncode values to their containing native class.
40 // NOTE: Currently this Map contradicts class GC for native classes. This map
41 // (and the "new class stack") will need to use WeakReferences in order to
42 // enable native class GC.
43 static java::util::IdentityHashMap *ncodeMap;
45 // Check the "class stack" for any classes initialized since we were last
46 // called, and add them to ncodeMap.
48 _Jv_StackTrace::UpdateNCodeMap ()
50 // The Map should be large enough so that a typical Java app doesn't cause
51 // it to rehash, without using too much memory. ~5000 entries should be
54 ncodeMap = new java::util::IdentityHashMap (5087);
57 while ((klass = _Jv_PopClass ()))
59 //printf ("got %s\n", klass->name->data);
61 JvAssert (! _Jv_IsInterpretedClass (klass));
63 for (int i=0; i < klass->method_count; i++)
65 _Jv_Method *method = &klass->methods[i];
66 void *ncode = method->ncode;
67 // Add non-abstract methods to ncodeMap.
70 ncode = UNWRAP_FUNCTION_DESCRIPTOR (ncode);
71 ncodeMap->put ((java::lang::Object *)ncode, klass);
77 // Given a native frame, return the class which this code belongs
78 // to. Returns NULL if this IP is not associated with a native Java class.
79 // If NCODE is supplied, it will be set with the ip for the entry point of the
82 _Jv_StackTrace::ClassForFrame (_Jv_StackFrame *frame)
84 JvAssert (frame->type == frame_native);
86 // use _Unwind_FindEnclosingFunction to find start of method
87 //void *entryPoint = _Unwind_FindEnclosingFunction (ip);
89 // look it up in ncodeMap
91 klass = (jclass) ncodeMap->get ((jobject) frame->start_ip);
97 _Jv_StackTrace::UnwindTraceFn (struct _Unwind_Context *context, void *state_ptr)
99 _Jv_UnwindState *state = (_Jv_UnwindState *) state_ptr;
100 jint pos = state->pos;
102 // Check if the trace buffer needs to be extended.
103 if (pos == state->length)
105 int newLength = state->length * 2;
106 void *newFrames = _Jv_AllocBytes (newLength * sizeof(_Jv_StackFrame));
107 memcpy (newFrames, state->frames, state->length * sizeof(_Jv_StackFrame));
108 state->frames = (_Jv_StackFrame *) newFrames;
109 state->length = newLength;
112 void *func_addr = (void *) _Unwind_GetRegionStart (context);
114 // If we see the interpreter's main function, "pop" an entry off the
115 // interpreter stack and use that instead, so that the trace goes through
116 // the java code and not the interpreter itself. This assumes a 1:1
117 // correspondance between call frames in the interpreted stack and occurances
118 // of _Jv_InterpMethod::run() on the native stack.
120 void *interp_run = (void *) &_Jv_InterpMethod::run;
121 if (func_addr == UNWRAP_FUNCTION_DESCRIPTOR (interp_run))
123 state->frames[pos].type = frame_interpreter;
124 state->frames[pos].interp.meth = state->interp_frame->self;
125 state->frames[pos].interp.pc = state->interp_frame->pc;
126 state->interp_frame = state->interp_frame->next;
131 state->frames[pos].type = frame_native;
132 state->frames[pos].ip = (void *) _Unwind_GetIP (context);
133 state->frames[pos].start_ip = func_addr;
136 //printf ("unwind ip: %p\n", _Unwind_GetIP (context));
138 _Unwind_Reason_Code result = _URC_NO_REASON;
139 if (state->trace_function != NULL)
140 result = (state->trace_function) (state);
145 // Return a raw stack trace from the current point of execution. The raw
146 // trace will include all functions that have unwind info.
148 _Jv_StackTrace::GetStackTrace(void)
150 int trace_size = 100;
151 _Jv_StackFrame frames[trace_size];
152 _Jv_UnwindState state (trace_size);
153 state.frames = (_Jv_StackFrame *) &frames;
155 #ifdef SJLJ_EXCEPTIONS
156 // The Unwind interface doesn't work with the SJLJ exception model.
157 // Fall back to a platform-specific unwinder.
158 fallback_backtrace (&state);
159 #else /* SJLJ_EXCEPTIONS */
160 _Unwind_Backtrace (UnwindTraceFn, &state);
161 #endif /* SJLJ_EXCEPTIONS */
163 // Copy the trace and return it.
164 int traceSize = sizeof (_Jv_StackTrace) +
165 (sizeof (_Jv_StackFrame) * state.pos);
166 _Jv_StackTrace *trace = (_Jv_StackTrace *) _Jv_AllocBytes (traceSize);
167 trace->length = state.pos;
168 memcpy (trace->frames, state.frames, sizeof (_Jv_StackFrame) * state.pos);
173 _Jv_StackTrace::getLineNumberForFrame(_Jv_StackFrame *frame, NameFinder *finder,
174 jstring *sourceFileName, jint *lineNum,
178 if (frame->type == frame_interpreter)
180 _Jv_InterpMethod *interp_meth = frame->interp.meth;
181 _Jv_InterpClass *interp_class =
182 (_Jv_InterpClass *) interp_meth->defining_class->aux_info;
183 *sourceFileName = interp_class->source_file_name;
184 *lineNum = interp_meth->get_source_line(frame->interp.pc);
188 // Use dladdr() to determine in which binary the address IP resides.
189 #if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR)
191 jstring binaryName = NULL;
192 const char *argv0 = _Jv_GetSafeArg(0);
194 void *ip = frame->ip;
195 _Unwind_Ptr offset = 0;
197 if (dladdr (ip, &info))
200 binaryName = JvNewStringUTF (info.dli_fname);
204 if (*methodName == NULL && info.dli_sname)
205 *methodName = JvNewStringUTF (info.dli_sname);
207 // addr2line expects relative addresses for shared libraries.
208 if (strcmp (info.dli_fname, argv0) == 0)
209 offset = (_Unwind_Ptr) ip;
211 offset = (_Unwind_Ptr) ip - (_Unwind_Ptr) info.dli_fbase;
213 //printf ("linenum ip: %p\n", ip);
214 //printf ("%s: 0x%x\n", info.dli_fname, offset);
215 //offset -= sizeof(void *);
217 // The unwinder gives us the return address. In order to get the right
218 // line number for the stack trace, roll it back a little.
221 // printf ("%s: 0x%x\n", info.dli_fname, offset);
223 finder->lookup (binaryName, (jlong) offset);
224 *sourceFileName = finder->getSourceFile();
225 *lineNum = finder->getLineNum();
230 // Look up class and method info for the given stack frame, setting
231 // frame->klass and frame->meth if they are known.
233 _Jv_StackTrace::FillInFrameInfo (_Jv_StackFrame *frame)
236 _Jv_Method *meth = NULL;
238 if (frame->type == frame_native)
240 klass = _Jv_StackTrace::ClassForFrame (frame);
243 // Find method in class
244 for (int j = 0; j < klass->method_count; j++)
246 void *wncode = UNWRAP_FUNCTION_DESCRIPTOR (klass->methods[j].ncode);
247 if (wncode == frame->start_ip)
249 meth = &klass->methods[j];
255 else if (frame->type == frame_interpreter)
257 _Jv_InterpMethod *interp_meth = frame->interp.meth;
258 klass = interp_meth->defining_class;
259 meth = interp_meth->self;
263 JvFail ("Unknown frame type");
265 frame->klass = klass;
269 // Convert raw stack frames to a Java array of StackTraceElement objects.
270 JArray< ::java::lang::StackTraceElement *>*
271 _Jv_StackTrace::GetStackTraceElements (_Jv_StackTrace *trace,
272 Throwable *throwable __attribute__((unused)))
274 ArrayList *list = new ArrayList ();
276 #ifdef SJLJ_EXCEPTIONS
277 // We can't use the nCodeMap without unwinder support. Instead,
278 // fake the method name by giving the IP in hex - better than nothing.
279 jstring hex = JvNewStringUTF ("0x");
281 for (int i = 0; i < trace->length; i++)
283 jstring sourceFileName = NULL;
285 _Jv_StackFrame *frame = &trace->frames[i];
287 jstring className = NULL;
288 jstring methodName = hex->concat (Long::toHexString ((jlong) frame->ip));
290 StackTraceElement *element = new StackTraceElement (sourceFileName,
291 lineNum, className, methodName, 0);
295 #else /* SJLJ_EXCEPTIONS */
297 //JvSynchronized (ncodeMap);
300 NameFinder *finder = new NameFinder();
302 int end_idx = trace->length - 1;
304 // First pass: strip superfluous frames from beginning and end of the trace.
305 for (int i = 0; i < trace->length; i++)
307 _Jv_StackFrame *frame = &trace->frames[i];
308 FillInFrameInfo (frame);
310 if (!frame->klass || !frame->meth)
314 // Throw away the top of the stack till we see:
315 // - the constructor(s) of this Throwable, or
316 // - the Throwable.fillInStackTrace call.
317 if (frame->klass == throwable->getClass()
318 && strcmp (frame->meth->name->chars(), "<init>") == 0)
321 if (frame->klass == &Throwable::class$
322 && strcmp (frame->meth->name->chars(), "fillInStackTrace") == 0)
325 // End the trace at the application's main() method if we see call_main.
326 if (frame->klass == &gnu::java::lang::MainThread::class$
327 && strcmp (frame->meth->name->chars(), "call_main") == 0)
331 const jboolean remove_unknown
332 = gnu::gcj::runtime::NameFinder::removeUnknown();
334 // Second pass: Look up line-number info for remaining frames.
335 for (int i = start_idx; i <= end_idx; i++)
337 _Jv_StackFrame *frame = &trace->frames[i];
339 if (frame->klass == NULL && remove_unknown)
343 jstring className = NULL;
344 if (frame->klass != NULL)
345 className = frame->klass->getName ();
347 jstring methodName = NULL;
349 methodName = JvNewStringUTF (frame->meth->name->chars());
351 jstring sourceFileName = NULL;
354 getLineNumberForFrame(frame, finder, &sourceFileName, &lineNum,
357 StackTraceElement *element = new StackTraceElement (sourceFileName, lineNum,
358 className, methodName, 0);
363 #endif /* SJLJ_EXCEPTIONS */
365 JArray<Object *> *array = JvNewObjectArray (list->size (),
366 &StackTraceElement::class$, NULL);
368 return (JArray<StackTraceElement *>*) list->toArray (array);
371 struct CallingClassTraceData
375 _Jv_Method *foundMeth;
376 bool seen_checkClass;
380 _Jv_StackTrace::calling_class_trace_fn (_Jv_UnwindState *state)
382 CallingClassTraceData *trace_data = (CallingClassTraceData *)
384 _Jv_StackFrame *frame = &state->frames[state->pos];
385 FillInFrameInfo (frame);
387 if (trace_data->seen_checkClass
389 && frame->klass != trace_data->checkClass)
391 trace_data->foundClass = frame->klass;
392 trace_data->foundMeth = frame->meth;
393 return _URC_NORMAL_STOP;
396 if (frame->klass == trace_data->checkClass)
397 trace_data->seen_checkClass = true;
399 return _URC_NO_REASON;
402 // Find the class immediately above the given class on the call stack. Any
403 // intermediate non-Java
404 // frames are ignored. If the calling class could not be determined (eg because
405 // the unwinder is not supported on this platform), NULL is returned.
406 // This function is used to implement calling-classloader checks and reflection
407 // accessibility checks.
408 // CHECKCLASS is typically the class calling GetCallingClass. The first class
409 // above CHECKCLASS on the call stack will be returned.
411 _Jv_StackTrace::GetCallingClass (jclass checkClass)
413 jclass result = NULL;
414 GetCallerInfo (checkClass, &result, NULL);
419 _Jv_StackTrace::GetCallerInfo (jclass checkClass, jclass *caller_class,
420 _Jv_Method **caller_meth)
422 #ifndef SJLJ_EXCEPTIONS
424 _Jv_StackFrame frames[trace_size];
425 _Jv_UnwindState state (trace_size);
426 state.frames = (_Jv_StackFrame *) &frames;
428 CallingClassTraceData trace_data;
429 trace_data.checkClass = checkClass;
430 trace_data.seen_checkClass = false;
431 trace_data.foundClass = NULL;
432 trace_data.foundMeth = NULL;
434 state.trace_function = calling_class_trace_fn;
435 state.trace_data = (void *) &trace_data;
437 //JvSynchronized (ncodeMap);
440 _Unwind_Backtrace (UnwindTraceFn, &state);
443 *caller_class = trace_data.foundClass;
445 *caller_meth = trace_data.foundMeth;
451 // Return a java array containing the Java classes on the stack above CHECKCLASS.
453 _Jv_StackTrace::GetClassContext (jclass checkClass)
455 JArray<jclass> *result = NULL;
457 int trace_size = 100;
458 _Jv_StackFrame frames[trace_size];
459 _Jv_UnwindState state (trace_size);
460 state.frames = (_Jv_StackFrame *) &frames;
462 //JvSynchronized (ncodeMap);
465 _Unwind_Backtrace (UnwindTraceFn, &state);
467 // Count the number of Java frames on the stack.
468 int jframe_count = 0;
469 bool seen_checkClass = false;
471 for (int i = 0; i < state.pos; i++)
473 _Jv_StackFrame *frame = &state.frames[i];
474 FillInFrameInfo (frame);
486 seen_checkClass = frame->klass == checkClass;
488 result = (JArray<jclass> *) _Jv_NewObjectArray (jframe_count, &Class::class$, NULL);
491 for (int i = start_pos; i < state.pos; i++)
493 _Jv_StackFrame *frame = &state.frames[i];
495 elements(result)[pos++] = frame->klass;
501 _Jv_StackTrace::non_system_trace_fn (_Jv_UnwindState *state)
503 _Jv_StackFrame *frame = &state->frames[state->pos];
504 FillInFrameInfo (frame);
506 ClassLoader *classLoader = NULL;
510 classLoader = frame->klass->getClassLoaderInternal();
512 if (classLoader != NULL)
514 state->trace_data = (void *) classLoader;
515 return _URC_NORMAL_STOP;
520 return _URC_NO_REASON;
524 _Jv_StackTrace::GetFirstNonSystemClassLoader ()
527 _Jv_StackFrame frames[trace_size];
528 _Jv_UnwindState state (trace_size);
529 state.frames = (_Jv_StackFrame *) &frames;
530 state.trace_function = non_system_trace_fn;
531 state.trace_data = NULL;
533 //JvSynchronized (ncodeMap);
536 _Unwind_Backtrace (UnwindTraceFn, &state);
538 if (state.trace_data)
539 return (ClassLoader *) state.trace_data;