2 * simple backtrace facility
6 * This software is part of the SBCL system. See the README file for
9 * This software is derived from the CMU CL system, which was
10 * written at Carnegie Mellon University and released into the
11 * public domain. The software is in the public domain and is
12 * provided with absolutely no warranty. See the COPYING and CREDITS
13 * files for more information.
22 #include "interrupt.h"
24 #ifdef LISP_FEATURE_GENCGC
27 #include "gencgc-alloc-region.h"
28 #include "genesis/compiled-debug-fun.h"
29 #include "genesis/compiled-debug-info.h"
30 #include "genesis/package.h"
32 #include "genesis/static-symbols.h"
33 #include "genesis/primitive-objects.h"
36 #ifdef LISP_FEATURE_OS_PROVIDES_DLADDR
37 /* __USE_GNU needed if we want dladdr() and Dl_Info from glibc. */
42 #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64))
44 /* KLUDGE: Sigh ... I know what the call frame looks like and it had
45 * better not change. */
48 #ifndef LISP_FEATURE_ALPHA
49 struct call_frame *old_cont;
55 lispobj other_state[5];
59 #ifndef LISP_FEATURE_ALPHA
60 struct call_frame *frame;
65 #ifndef LISP_FEATURE_ALPHA
71 int pc; /* Note: this is the trace file offset, not the actual pc. */
74 #define HEADER_LENGTH(header) ((header)>>8)
76 static int previous_info(struct call_info *info);
79 code_pointer(lispobj object)
81 lispobj *headerp, header;
84 headerp = (lispobj *) native_pointer(object);
86 type = widetag_of(header);
89 case CODE_HEADER_WIDETAG:
91 case RETURN_PC_HEADER_WIDETAG:
92 case SIMPLE_FUN_HEADER_WIDETAG:
93 len = HEADER_LENGTH(header);
103 return (struct code *) headerp;
107 cs_valid_pointer_p(struct call_frame *pointer)
109 struct thread *thread=arch_os_get_current_thread();
110 return (((char *) thread->control_stack_start <= (char *) pointer) &&
111 ((char *) pointer < (char *) current_control_stack_pointer));
115 call_info_from_lisp_state(struct call_info *info)
117 info->frame = (struct call_frame *)current_control_frame_pointer;
118 info->interrupted = 0;
127 call_info_from_context(struct call_info *info, os_context_t *context)
131 info->interrupted = 1;
132 if (lowtag_of(*os_context_register_addr(context, reg_CODE))
133 == FUN_POINTER_LOWTAG) {
134 /* We tried to call a function, but crapped out before $CODE could
135 * be fixed up. Probably an undefined function. */
137 (struct call_frame *)(unsigned long)
138 (*os_context_register_addr(context, reg_OCFP));
139 info->lra = (lispobj)(*os_context_register_addr(context, reg_LRA));
140 info->code = code_pointer(info->lra);
141 pc = (unsigned long)native_pointer(info->lra);
145 (struct call_frame *)(unsigned long)
146 (*os_context_register_addr(context, reg_CFP));
148 code_pointer(*os_context_register_addr(context, reg_CODE));
150 pc = *os_context_pc_addr(context);
152 if (info->code != NULL)
153 info->pc = pc - (unsigned long) info->code -
154 #ifndef LISP_FEATURE_ALPHA
155 (HEADER_LENGTH(info->code->header) * sizeof(lispobj));
157 (HEADER_LENGTH(((struct code *)info->code)->header) * sizeof(lispobj));
164 previous_info(struct call_info *info)
166 struct call_frame *this_frame;
167 struct thread *thread=arch_os_get_current_thread();
170 if (!cs_valid_pointer_p(info->frame)) {
171 printf("Bogus callee value (0x%08lx).\n", (unsigned long)info->frame);
175 this_frame = info->frame;
176 info->lra = this_frame->saved_lra;
177 info->frame = this_frame->old_cont;
178 info->interrupted = 0;
180 if (info->frame == NULL || info->frame == this_frame)
183 if (info->lra == NIL) {
184 /* We were interrupted. Find the correct signal context. */
185 free_ici = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread));
186 while (free_ici-- > 0) {
187 os_context_t *context =
188 thread->interrupt_contexts[free_ici];
189 if ((struct call_frame *)(unsigned long)
190 (*os_context_register_addr(context, reg_CFP))
192 call_info_from_context(info, context);
198 info->code = code_pointer(info->lra);
199 if (info->code != NULL)
200 info->pc = (unsigned long)native_pointer(info->lra) -
201 (unsigned long)info->code -
202 #ifndef LISP_FEATURE_ALPHA
203 (HEADER_LENGTH(info->code->header) * sizeof(lispobj));
205 (HEADER_LENGTH(((struct code *)info->code)->header) * sizeof(lispobj));
215 backtrace(int nframes)
217 struct call_info info;
219 call_info_from_lisp_state(&info);
222 printf("<Frame 0x%08lx%s, ", (unsigned long) info.frame,
223 info.interrupted ? " [interrupted]" : "");
225 if (info.code != (struct code *) 0) {
228 printf("CODE: 0x%08lX, ", (unsigned long) info.code | OTHER_POINTER_LOWTAG);
230 #ifndef LISP_FEATURE_ALPHA
231 function = info.code->entry_points;
233 function = ((struct code *)info.code)->entry_points;
235 while (function != NIL) {
236 struct simple_fun *header;
239 header = (struct simple_fun *) native_pointer(function);
242 if (lowtag_of(name) == OTHER_POINTER_LOWTAG) {
245 object = (lispobj *) native_pointer(name);
247 if (widetag_of(*object) == SYMBOL_HEADER_WIDETAG) {
248 struct symbol *symbol;
250 symbol = (struct symbol *) object;
251 object = (lispobj *) native_pointer(symbol->name);
253 if (widetag_of(*object) == SIMPLE_BASE_STRING_WIDETAG) {
254 struct vector *string;
256 string = (struct vector *) object;
257 printf("%s, ", (char *) string->data);
259 /* FIXME: broken from (VECTOR NIL) */
260 printf("(Not simple string??\?), ");
262 printf("(Not other pointer??\?), ");
265 function = header->next;
269 printf("CODE: ???, ");
272 printf("LRA: 0x%08lx, ", (unsigned long)info.lra);
274 printf("<no LRA>, ");
277 printf("PC: 0x%x>\n", info.pc);
279 printf("PC: ??\?>\n");
281 } while (--nframes > 0 && previous_info(&info));
287 altstack_pointer_p (void *p) {
288 char* stack_start = ((char *) arch_os_get_current_thread())
289 + dynamic_values_bytes;
290 char* stack_end = stack_start + 32*SIGSTKSZ;
292 return (p > stack_start && p <= stack_end);
296 stack_pointer_p (void *p)
298 /* we are using sizeof(long) here, because that is the right value on both
299 * x86 and x86-64. (But note that false positives would not cause much harm
300 * given the heuristical nature of x86_call_context.) */
301 unsigned long stack_alignment = sizeof(long);
303 return (altstack_pointer_p(p)
304 || (p < (void *) arch_os_get_current_thread()->control_stack_end
305 && (p > (void *) &p || altstack_pointer_p(&p))
306 && (((unsigned long) p) & (stack_alignment-1)) == 0));
310 ra_pointer_p (void *ra)
312 /* the check against 4096 is still a mystery to everyone interviewed about
313 * it, but recent changes to sb-sprof seem to suggest that such values
314 * do occur sometimes. */
315 return ((unsigned long) ra) > 4096 && !stack_pointer_p (ra);
319 x86_call_context (void *fp, void **ra, void **ocfp)
325 int lisp_valid_p, c_valid_p;
327 if (!stack_pointer_p(fp))
330 c_ocfp = *((void **) fp);
331 c_ra = *((void **) fp + 1);
332 lisp_ocfp = *((void **) fp - 1);
333 lisp_ra = *((void **) fp - 2);
335 lisp_valid_p = (lisp_ocfp > fp
336 && stack_pointer_p(lisp_ocfp)
337 && ra_pointer_p(lisp_ra));
338 c_valid_p = (c_ocfp > fp
339 && stack_pointer_p(c_ocfp)
340 && ra_pointer_p(c_ra));
342 if (lisp_valid_p && c_valid_p) {
347 int lisp_path_p = x86_call_context(lisp_ocfp, &lisp_path_fp, &dummy);
348 int c_path_p = x86_call_context(c_ocfp, &c_path_fp, &dummy);
350 if (lisp_path_p && c_path_p) {
351 #if defined __FreeBSD__ && __FreeBSD_version > 400000
352 if (lisp_ocfp > c_ocfp)
353 *ra = lisp_ra, *ocfp = lisp_ocfp;
355 *ra = c_ra, *ocfp = c_ocfp;
357 *ra = lisp_ra, *ocfp = lisp_ocfp;
360 else if (lisp_path_p)
361 *ra = lisp_ra, *ocfp = lisp_ocfp;
363 *ra = c_ra, *ocfp = c_ocfp;
367 else if (lisp_valid_p)
368 *ra = lisp_ra, *ocfp = lisp_ocfp;
370 *ra = c_ra, *ocfp = c_ocfp;
377 struct compiled_debug_fun *
378 debug_function_from_pc (struct code* code, void *pc)
380 unsigned long code_header_len = sizeof(lispobj) * HeaderValue(code->header);
382 = (unsigned long) pc - (unsigned long) code - code_header_len;
383 struct compiled_debug_fun *df;
384 struct compiled_debug_info *di;
388 if (lowtag_of(code->debug_info) != INSTANCE_POINTER_LOWTAG)
391 di = (struct compiled_debug_info *) native_pointer(code->debug_info);
392 v = (struct vector *) native_pointer(di->fun_map);
393 len = fixnum_value(v->length);
394 df = (struct compiled_debug_fun *) native_pointer(v->data[0]);
399 for (i = 1;; i += 2) {
403 return ((struct compiled_debug_fun *) native_pointer(v->data[i - 1]));
405 if (offset >= fixnum_value(df->elsewhere_pc)) {
406 struct compiled_debug_fun *p
407 = ((struct compiled_debug_fun *) native_pointer(v->data[i + 1]));
408 next_pc = fixnum_value(p->elsewhere_pc);
410 next_pc = fixnum_value(v->data[i]);
412 if (offset < next_pc)
413 return ((struct compiled_debug_fun *) native_pointer(v->data[i - 1]));
420 sbcl_putwc(wchar_t c, FILE *file)
422 #ifdef LISP_FEATURE_OS_PROVIDES_PUTWC
434 print_string (lispobj *object)
436 int tag = widetag_of(*object);
437 struct vector *vector = (struct vector *) object;
442 int n = fixnum_value(vector->length); \
443 TYPE *data = (TYPE *) vector->data; \
444 for (i = 0; i < n; i++) { \
445 wchar_t c = (wchar_t) data[i]; \
446 if (c == '\\' || c == '"') \
448 sbcl_putwc(c, stdout); \
453 case SIMPLE_BASE_STRING_WIDETAG:
456 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
457 case SIMPLE_CHARACTER_STRING_WIDETAG:
462 printf("<??? type %d>", tag);
468 print_entry_name (lispobj name)
470 if (lowtag_of (name) == LIST_POINTER_LOWTAG) {
472 while (name != NIL) {
473 struct cons *cons = (struct cons *) native_pointer(name);
474 print_entry_name(cons->car);
480 } else if (lowtag_of(name) == OTHER_POINTER_LOWTAG) {
481 lispobj *object = (lispobj *) native_pointer(name);
482 if (widetag_of(*object) == SYMBOL_HEADER_WIDETAG) {
483 struct symbol *symbol = (struct symbol *) object;
484 if (symbol->package != NIL) {
486 = (struct package *) native_pointer(symbol->package);
487 lispobj pkg_name = pkg->_name;
488 print_string(native_pointer(pkg_name));
491 print_string(native_pointer(symbol->name));
492 } else if (widetag_of(*object) == SIMPLE_BASE_STRING_WIDETAG) {
494 print_string(object);
496 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
497 } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) {
499 print_string(object);
503 printf("<??? type %d>", (int) widetag_of(*object));
506 printf("<??? lowtag %d>", (int) lowtag_of(name));
511 print_entry_points (struct code *code)
513 lispobj function = code->entry_points;
515 while (function != NIL) {
516 struct simple_fun *header = (struct simple_fun *) native_pointer(function);
517 print_entry_name(header->name);
519 function = header->next;
525 /* This function has been split from backtrace() to enable Lisp
526 * backtraces from gdb with call backtrace_from_fp(...). Useful for
527 * example when debugging threading deadlocks.
530 backtrace_from_fp(void *fp, int nframes)
534 for (i = 0; i < nframes; ++i) {
539 if (!x86_call_context(fp, &ra, &next_fp))
544 p = (lispobj *) component_ptr_from_pc((lispobj *) ra);
546 struct code *cp = (struct code *) p;
547 struct compiled_debug_fun *df = debug_function_from_pc(cp, ra);
549 print_entry_name(df->name);
551 print_entry_points(cp);
553 #ifdef LISP_FEATURE_OS_PROVIDES_DLADDR
555 if (dladdr(ra, &info)) {
556 printf("Foreign function %s, fp = 0x%lx, ra = 0x%lx",
558 (unsigned long) next_fp,
562 printf("Foreign fp = 0x%lx, ra = 0x%lx",
563 (unsigned long) next_fp,
573 backtrace(int nframes)
578 #if defined(LISP_FEATURE_X86)
579 asm("movl %%ebp,%0" : "=g" (fp));
580 #elif defined (LISP_FEATURE_X86_64)
581 asm("movq %%rbp,%0" : "=g" (fp));
583 #error "How did we get here?"
586 backtrace_from_fp(fp, nframes);