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
16 #include <java-interp.h>
17 #include <java-stack.h>
21 #include <java/lang/Class.h>
22 #include <java/lang/Long.h>
23 #include <java/util/ArrayList.h>
24 #include <java/util/IdentityHashMap.h>
25 #include <gnu/java/lang/MainThread.h>
26 #include <gnu/gcj/runtime/NameFinder.h>
27 #include <gnu/gcj/runtime/StringBuffer.h>
29 #include <sysdep/backtrace.h>
30 #include <sysdep/descriptor.h>
32 using namespace java::lang
;
33 using namespace java::lang::reflect
;
34 using namespace java::util
;
35 using namespace gnu::gcj::runtime
;
37 // Maps ncode values to their containing native class.
38 // NOTE: Currently this Map contradicts class GC for native classes. This map
39 // (and the "new class stack") will need to use WeakReferences in order to
40 // enable native class GC.
41 static java::util::IdentityHashMap
*ncodeMap
;
43 // Check the "class stack" for any classes initialized since we were last
44 // called, and add them to ncodeMap.
46 _Jv_StackTrace::UpdateNCodeMap ()
48 // The Map should be large enough so that a typical Java app doesn't cause
49 // it to rehash, without using too much memory. ~5000 entries should be
52 ncodeMap
= new java::util::IdentityHashMap (5087);
55 while ((klass
= _Jv_PopClass ()))
56 if (!_Jv_IsInterpretedClass (klass
))
58 //printf ("got %s\n", klass->name->data);
59 for (int i
= 0; i
< klass
->method_count
; i
++)
61 _Jv_Method
*method
= &klass
->methods
[i
];
62 void *ncode
= method
->ncode
;
63 // Add non-abstract methods to ncodeMap.
66 ncode
= UNWRAP_FUNCTION_DESCRIPTOR (ncode
);
67 ncodeMap
->put ((java::lang::Object
*) ncode
, klass
);
73 // Given a native frame, return the class which this code belongs
74 // to. Returns NULL if this IP is not associated with a native Java class.
75 // If NCODE is supplied, it will be set with the ip for the entry point of the
78 _Jv_StackTrace::ClassForFrame (_Jv_StackFrame
*frame
)
80 JvAssert (frame
->type
== frame_native
);
83 // look it up in ncodeMap
85 klass
= (jclass
) ncodeMap
->get ((jobject
) frame
->start_ip
);
91 _Jv_StackTrace::UnwindTraceFn (struct _Unwind_Context
*context
, void *state_ptr
)
93 _Jv_UnwindState
*state
= (_Jv_UnwindState
*) state_ptr
;
94 jint pos
= state
->pos
;
96 // Check if the trace buffer needs to be extended.
97 if (pos
== state
->length
)
99 int newLength
= state
->length
* 2;
100 void *newFrames
= _Jv_AllocBytes (newLength
* sizeof(_Jv_StackFrame
));
101 memcpy (newFrames
, state
->frames
, state
->length
* sizeof(_Jv_StackFrame
));
102 state
->frames
= (_Jv_StackFrame
*) newFrames
;
103 state
->length
= newLength
;
106 void *func_addr
= (void *) _Unwind_GetRegionStart (context
);
108 // If we see the interpreter's main function, "pop" an entry off the
109 // interpreter stack and use that instead, so that the trace goes through
110 // the java code and not the interpreter itself. This assumes a 1:1
111 // correspondance between call frames in the interpreted stack and occurances
112 // of _Jv_InterpMethod::run() on the native stack.
114 void *interp_run
= (void *) &_Jv_InterpMethod::run
;
115 if (func_addr
== UNWRAP_FUNCTION_DESCRIPTOR (interp_run
))
117 state
->frames
[pos
].type
= frame_interpreter
;
118 state
->frames
[pos
].interp
.meth
= state
->interp_frame
->self
;
119 state
->frames
[pos
].interp
.pc
= state
->interp_frame
->pc
;
120 state
->interp_frame
= state
->interp_frame
->next
;
126 int ip_before_insn
= 0;
127 ip
= _Unwind_GetIPInfo (context
, &ip_before_insn
);
129 // If the unwinder gave us a 'return' address, roll it back a little
130 // to ensure we get the correct line number for the call itself.
131 if (! ip_before_insn
)
134 state
->frames
[pos
].type
= frame_native
;
135 state
->frames
[pos
].ip
= (void *) ip
;
136 state
->frames
[pos
].start_ip
= func_addr
;
139 _Unwind_Reason_Code result
= _URC_NO_REASON
;
140 if (state
->trace_function
!= NULL
)
141 result
= (state
->trace_function
) (state
);
146 // Return a raw stack trace from the current point of execution. The raw
147 // trace will include all functions that have unwind info.
149 _Jv_StackTrace::GetStackTrace(void)
151 int trace_size
= 100;
152 _Jv_StackFrame frames
[trace_size
];
153 _Jv_UnwindState
state (trace_size
);
154 state
.frames
= (_Jv_StackFrame
*) &frames
;
156 _Unwind_Backtrace (UnwindTraceFn
, &state
);
158 // Copy the trace and return it.
159 int traceSize
= sizeof (_Jv_StackTrace
) +
160 (sizeof (_Jv_StackFrame
) * state
.pos
);
161 _Jv_StackTrace
*trace
= (_Jv_StackTrace
*) _Jv_AllocBytes (traceSize
);
162 trace
->length
= state
.pos
;
163 memcpy (trace
->frames
, state
.frames
, sizeof (_Jv_StackFrame
) * state
.pos
);
168 _Jv_StackTrace::getLineNumberForFrame(_Jv_StackFrame
*frame
, NameFinder
*finder
,
169 jstring
*sourceFileName
, jint
*lineNum
,
173 if (frame
->type
== frame_interpreter
)
175 _Jv_InterpMethod
*interp_meth
= frame
->interp
.meth
;
176 _Jv_InterpClass
*interp_class
=
177 (_Jv_InterpClass
*) interp_meth
->defining_class
->aux_info
;
178 *sourceFileName
= interp_class
->source_file_name
;
179 // The interpreter advances the PC before executing an instruction,
180 // so roll-back 1 byte to ensure the line number is accurate.
181 *lineNum
= interp_meth
->get_source_line(frame
->interp
.pc
- 1);
186 // Use _Jv_platform_dladdr() to determine in which binary the address IP
189 jstring binaryName
= NULL
;
190 const char *argv0
= _Jv_GetSafeArg(0);
192 void *ip
= frame
->ip
;
193 _Unwind_Ptr offset
= 0;
195 if (_Jv_platform_dladdr (ip
, &info
))
198 binaryName
= JvNewStringUTF (info
.file_name
);
202 if (*methodName
== NULL
&& info
.sym_name
)
203 *methodName
= JvNewStringUTF (info
.sym_name
);
205 // addr2line expects relative addresses for shared libraries.
206 if (strcmp (info
.file_name
, argv0
) == 0)
207 offset
= (_Unwind_Ptr
) ip
;
209 offset
= (_Unwind_Ptr
) ip
- (_Unwind_Ptr
) info
.base
;
211 finder
->lookup (binaryName
, (jlong
) offset
);
212 *sourceFileName
= finder
->getSourceFile();
213 *lineNum
= finder
->getLineNum();
214 if (*lineNum
== -1 && NameFinder::showRaw())
216 gnu::gcj::runtime::StringBuffer
*t
=
217 new gnu::gcj::runtime::StringBuffer(binaryName
);
218 t
->append ((jchar
)' ');
219 t
->append ((jchar
)'[');
220 // + 1 to compensate for the - 1 adjustment above;
221 t
->append (Long::toHexString (offset
+ 1));
222 t
->append ((jchar
)']');
223 *sourceFileName
= t
->toString();
228 // Look up class and method info for the given stack frame, setting
229 // frame->klass and frame->meth if they are known.
231 _Jv_StackTrace::FillInFrameInfo (_Jv_StackFrame
*frame
)
234 _Jv_Method
*meth
= NULL
;
236 if (frame
->type
== frame_native
)
238 klass
= _Jv_StackTrace::ClassForFrame (frame
);
241 // Find method in class
242 for (int j
= 0; j
< klass
->method_count
; j
++)
244 void *wncode
= UNWRAP_FUNCTION_DESCRIPTOR (klass
->methods
[j
].ncode
);
245 if (wncode
== frame
->start_ip
)
247 meth
= &klass
->methods
[j
];
253 else if (frame
->type
== frame_interpreter
)
255 _Jv_InterpMethod
*interp_meth
= frame
->interp
.meth
;
256 klass
= interp_meth
->defining_class
;
257 meth
= interp_meth
->self
;
261 JvFail ("Unknown frame type");
263 frame
->klass
= klass
;
267 // Convert raw stack frames to a Java array of StackTraceElement objects.
268 JArray
< ::java::lang::StackTraceElement
*>*
269 _Jv_StackTrace::GetStackTraceElements (_Jv_StackTrace
*trace
,
270 Throwable
*throwable
__attribute__((unused
)))
272 ArrayList
*list
= new ArrayList ();
274 #if defined (SJLJ_EXCEPTIONS) && ! defined (WIN32)
275 // We can't use the nCodeMap without unwinder support. Instead,
276 // fake the method name by giving the IP in hex - better than nothing.
277 jstring hex
= JvNewStringUTF ("0x");
279 for (int i
= 0; i
< trace
->length
; i
++)
281 jstring sourceFileName
= NULL
;
283 _Jv_StackFrame
*frame
= &trace
->frames
[i
];
285 jstring className
= NULL
;
286 jstring methodName
= hex
->concat (Long::toHexString ((jlong
) frame
->ip
));
288 StackTraceElement
*element
= new StackTraceElement (sourceFileName
,
289 lineNum
, className
, methodName
, 0);
293 #else /* SJLJ_EXCEPTIONS && !WIN32 */
295 //JvSynchronized (ncodeMap);
298 NameFinder
*finder
= new NameFinder();
300 int end_idx
= trace
->length
- 1;
302 // First pass: strip superfluous frames from beginning and end of the trace.
303 for (int i
= 0; i
< trace
->length
; i
++)
305 _Jv_StackFrame
*frame
= &trace
->frames
[i
];
306 FillInFrameInfo (frame
);
308 if (!frame
->klass
|| !frame
->meth
)
312 // Throw away the top of the stack till we see:
313 // - the constructor(s) of this Throwable, or
314 // - the Throwable.fillInStackTrace call.
315 if (frame
->klass
== throwable
->getClass()
316 && strcmp (frame
->meth
->name
->chars(), "<init>") == 0)
319 if (frame
->klass
== &Throwable::class$
320 && strcmp (frame
->meth
->name
->chars(), "fillInStackTrace") == 0)
323 // End the trace at the application's main() method if we see call_main.
324 if (frame
->klass
== &gnu::java::lang::MainThread::class$
325 && strcmp (frame
->meth
->name
->chars(), "call_main") == 0)
329 const jboolean remove_unknown
330 = gnu::gcj::runtime::NameFinder::removeUnknown();
332 // Second pass: Look up line-number info for remaining frames.
333 for (int i
= start_idx
; i
<= end_idx
; i
++)
335 _Jv_StackFrame
*frame
= &trace
->frames
[i
];
337 if (frame
->klass
== NULL
&& remove_unknown
)
341 jstring className
= NULL
;
342 if (frame
->klass
!= NULL
)
343 className
= frame
->klass
->getName ();
345 jstring methodName
= NULL
;
347 methodName
= JvNewStringUTF (frame
->meth
->name
->chars());
349 jstring sourceFileName
= NULL
;
352 getLineNumberForFrame(frame
, finder
, &sourceFileName
, &lineNum
,
355 StackTraceElement
*element
= new StackTraceElement (sourceFileName
, lineNum
,
356 className
, methodName
, 0);
361 #endif /* SJLJ_EXCEPTIONS && !WIN32 */
363 JArray
<Object
*> *array
= JvNewObjectArray (list
->size (),
364 &StackTraceElement::class$
, NULL
);
366 return (JArray
<StackTraceElement
*>*) list
->toArray (array
);
369 struct CallingClassTraceData
373 _Jv_Method
*foundMeth
;
374 bool seen_checkClass
;
378 _Jv_StackTrace::calling_class_trace_fn (_Jv_UnwindState
*state
)
380 CallingClassTraceData
*trace_data
= (CallingClassTraceData
*)
382 _Jv_StackFrame
*frame
= &state
->frames
[state
->pos
];
383 FillInFrameInfo (frame
);
385 if (trace_data
->seen_checkClass
387 && frame
->klass
!= trace_data
->checkClass
)
389 trace_data
->foundClass
= frame
->klass
;
390 trace_data
->foundMeth
= frame
->meth
;
391 return _URC_NORMAL_STOP
;
394 if (frame
->klass
== trace_data
->checkClass
)
395 trace_data
->seen_checkClass
= true;
397 return _URC_NO_REASON
;
400 // Find the class immediately above the given class on the call stack. Any
401 // intermediate non-Java
402 // frames are ignored. If the calling class could not be determined (eg because
403 // the unwinder is not supported on this platform), NULL is returned.
404 // This function is used to implement calling-classloader checks and reflection
405 // accessibility checks.
406 // CHECKCLASS is typically the class calling GetCallingClass. The first class
407 // above CHECKCLASS on the call stack will be returned.
409 _Jv_StackTrace::GetCallingClass (jclass checkClass
)
411 jclass result
= NULL
;
412 GetCallerInfo (checkClass
, &result
, NULL
);
417 _Jv_StackTrace::GetCallerInfo (jclass checkClass
, jclass
*caller_class
,
418 _Jv_Method
**caller_meth
)
421 _Jv_StackFrame frames
[trace_size
];
422 _Jv_UnwindState
state (trace_size
);
423 state
.frames
= (_Jv_StackFrame
*) &frames
;
425 CallingClassTraceData trace_data
;
426 trace_data
.checkClass
= checkClass
;
427 trace_data
.seen_checkClass
= false;
428 trace_data
.foundClass
= NULL
;
429 trace_data
.foundMeth
= NULL
;
431 state
.trace_function
= calling_class_trace_fn
;
432 state
.trace_data
= (void *) &trace_data
;
434 //JvSynchronized (ncodeMap);
437 _Unwind_Backtrace (UnwindTraceFn
, &state
);
440 *caller_class
= trace_data
.foundClass
;
442 *caller_meth
= trace_data
.foundMeth
;
445 // Return a java array containing the Java classes on the stack above CHECKCLASS.
447 _Jv_StackTrace::GetClassContext (jclass checkClass
)
449 JArray
<jclass
> *result
= NULL
;
451 int trace_size
= 100;
452 _Jv_StackFrame frames
[trace_size
];
453 _Jv_UnwindState
state (trace_size
);
454 state
.frames
= (_Jv_StackFrame
*) &frames
;
456 //JvSynchronized (ncodeMap);
459 _Unwind_Backtrace (UnwindTraceFn
, &state
);
461 // Count the number of Java frames on the stack.
462 int jframe_count
= 0;
463 bool seen_checkClass
= false;
465 for (int i
= 0; i
< state
.pos
; i
++)
467 _Jv_StackFrame
*frame
= &state
.frames
[i
];
468 FillInFrameInfo (frame
);
480 seen_checkClass
= frame
->klass
== checkClass
;
482 result
= (JArray
<jclass
> *) _Jv_NewObjectArray (jframe_count
, &Class::class$
, NULL
);
485 for (int i
= start_pos
; i
< state
.pos
; i
++)
487 _Jv_StackFrame
*frame
= &state
.frames
[i
];
489 elements(result
)[pos
++] = frame
->klass
;
495 _Jv_StackTrace::non_system_trace_fn (_Jv_UnwindState
*state
)
497 _Jv_StackFrame
*frame
= &state
->frames
[state
->pos
];
498 FillInFrameInfo (frame
);
500 ClassLoader
*classLoader
= NULL
;
504 classLoader
= frame
->klass
->getClassLoaderInternal();
506 if (classLoader
!= NULL
)
508 state
->trace_data
= (void *) classLoader
;
509 return _URC_NORMAL_STOP
;
514 return _URC_NO_REASON
;
518 _Jv_StackTrace::GetFirstNonSystemClassLoader ()
521 _Jv_StackFrame frames
[trace_size
];
522 _Jv_UnwindState
state (trace_size
);
523 state
.frames
= (_Jv_StackFrame
*) &frames
;
524 state
.trace_function
= non_system_trace_fn
;
525 state
.trace_data
= NULL
;
527 //JvSynchronized (ncodeMap);
530 _Unwind_Backtrace (UnwindTraceFn
, &state
);
532 if (state
.trace_data
)
533 return (ClassLoader
*) state
.trace_data
;