X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fruntime%2Fbacktrace.c;h=e7420e93e620cac8625d7d45fe38a4c9fc7fe6f3;hb=0d442aff281993a2b2e24d0c7a5c2547b50a5b2e;hp=471e84d6d94236e0a155f8f9c1c79370a94fe9b6;hpb=e44ca193db33af531e30413546d6820163102e44;p=sbcl.git diff --git a/src/runtime/backtrace.c b/src/runtime/backtrace.c index 471e84d..e7420e9 100644 --- a/src/runtime/backtrace.c +++ b/src/runtime/backtrace.c @@ -22,6 +22,7 @@ #include "interrupt.h" #include "lispregs.h" #ifdef LISP_FEATURE_GENCGC +#include #include "arch.h" #include "gencgc-alloc-region.h" #include "genesis/compiled-debug-fun.h" @@ -133,15 +134,16 @@ call_info_from_context(struct call_info *info, os_context_t *context) /* We tried to call a function, but crapped out before $CODE could * be fixed up. Probably an undefined function. */ info->frame = - (struct call_frame *)(*os_context_register_addr(context, - reg_OCFP)); + (struct call_frame *)(unsigned long) + (*os_context_register_addr(context, reg_OCFP)); info->lra = (lispobj)(*os_context_register_addr(context, reg_LRA)); info->code = code_pointer(info->lra); pc = (unsigned long)native_pointer(info->lra); } else { info->frame = - (struct call_frame *)(*os_context_register_addr(context, reg_CFP)); + (struct call_frame *)(unsigned long) + (*os_context_register_addr(context, reg_CFP)); info->code = code_pointer(*os_context_register_addr(context, reg_CODE)); info->lra = NIL; @@ -163,7 +165,7 @@ previous_info(struct call_info *info) { struct call_frame *this_frame; struct thread *thread=arch_os_get_current_thread(); - int free; + int free_ici; if (!cs_valid_pointer_p(info->frame)) { printf("Bogus callee value (0x%08lx).\n", (unsigned long)info->frame); @@ -180,12 +182,12 @@ previous_info(struct call_info *info) if (info->lra == NIL) { /* We were interrupted. Find the correct signal context. */ - free = SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread)>>2; - while (free-- > 0) { + free_ici = fixnum_value(SymbolValue(FREE_INTERRUPT_CONTEXT_INDEX,thread)); + while (free_ici-- > 0) { os_context_t *context = - thread->interrupt_contexts[free]; - if ((struct call_frame *)(*os_context_register_addr(context, - reg_CFP)) + thread->interrupt_contexts[free_ici]; + if ((struct call_frame *)(unsigned long) + (*os_context_register_addr(context, reg_CFP)) == info->frame) { call_info_from_context(info, context); break; @@ -282,16 +284,38 @@ backtrace(int nframes) #else static int +altstack_pointer_p (void *p) { +#ifndef LISP_FEATURE_WIN32 + void* stack_start = arch_os_get_current_thread() + dynamic_values_bytes; + void* stack_end = stack_start + 32*SIGSTKSZ; + + return (p > stack_start && p <= stack_end); +#else + /* Win32 doesn't do altstack */ + return 0; +#endif +} + +static int stack_pointer_p (void *p) { - return (p < (void *) arch_os_get_current_thread()->control_stack_end - && p > (void *) &p - && (((unsigned long) p) & 3) == 0); + /* we are using sizeof(long) here, because that is the right value on both + * x86 and x86-64. (But note that false positives would not cause much harm + * given the heuristical nature of x86_call_context.) */ + unsigned long stack_alignment = sizeof(long); + + return (altstack_pointer_p(p) + || (p < (void *) arch_os_get_current_thread()->control_stack_end + && (p > (void *) &p || altstack_pointer_p(&p)) + && (((unsigned long) p) & (stack_alignment-1)) == 0)); } static int ra_pointer_p (void *ra) { + /* the check against 4096 is still a mystery to everyone interviewed about + * it, but recent changes to sb-sprof seem to suggest that such values + * do occur sometimes. */ return ((unsigned long) ra) > 4096 && !stack_pointer_p (ra); } @@ -397,6 +421,54 @@ debug_function_from_pc (struct code* code, void *pc) } static void +sbcl_putwc(wchar_t c, FILE *file) +{ +#ifdef LISP_FEATURE_OS_PROVIDES_PUTWC + putwc(c, file); +#else + if (c < 256) { + fputc(c, file); + } else { + fputc('?', file); + } +#endif +} + +static void +print_string (lispobj *object) +{ + int tag = widetag_of(*object); + struct vector *vector = (struct vector *) object; + +#define doit(TYPE) \ + do { \ + int i; \ + int n = fixnum_value(vector->length); \ + TYPE *data = (TYPE *) vector->data; \ + for (i = 0; i < n; i++) { \ + wchar_t c = (wchar_t) data[i]; \ + if (c == '\\' || c == '"') \ + putchar('\\'); \ + sbcl_putwc(c, stdout); \ + } \ + } while (0) + + switch (tag) { + case SIMPLE_BASE_STRING_WIDETAG: + doit(unsigned char); + break; +#ifdef SIMPLE_CHARACTER_STRING_WIDETAG + case SIMPLE_CHARACTER_STRING_WIDETAG: + doit(unsigned int); + break; +#endif + default: + printf("", tag); + } +#undef doit +} + +static void print_entry_name (lispobj name) { if (lowtag_of (name) == LIST_POINTER_LOWTAG) { @@ -411,33 +483,32 @@ print_entry_name (lispobj name) putchar(')'); } else if (lowtag_of(name) == OTHER_POINTER_LOWTAG) { lispobj *object = (lispobj *) native_pointer(name); - if (widetag_of(*object) == SYMBOL_HEADER_WIDETAG) { struct symbol *symbol = (struct symbol *) object; - struct vector *string; - if (symbol->package != NIL) { struct package *pkg = (struct package *) native_pointer(symbol->package); lispobj pkg_name = pkg->_name; - string = (struct vector *) native_pointer(pkg_name); - printf("%s::", (char *) string->data); + print_string(native_pointer(pkg_name)); + fputs("::", stdout); } - - object = (lispobj *) native_pointer(symbol->name); - string = (struct vector *) object; - printf("%s", (char *) string->data); + print_string(native_pointer(symbol->name)); } else if (widetag_of(*object) == SIMPLE_BASE_STRING_WIDETAG) { - struct vector *string = (struct vector *) object; - printf("\"%s\"", (char *) string->data); + putchar('"'); + print_string(object); + putchar('"'); #ifdef SIMPLE_CHARACTER_STRING_WIDETAG - } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) { - printf(""); /* FIXME */ + } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) { + putchar('"'); + print_string(object); + putchar('"'); #endif - } else + } else { printf("", (int) widetag_of(*object)); - } else + } + } else { printf("", (int) lowtag_of(name)); + } } static void @@ -455,20 +526,15 @@ print_entry_points (struct code *code) } } +/* This function has been split from backtrace() to enable Lisp + * backtraces from gdb with call backtrace_from_fp(...). Useful for + * example when debugging threading deadlocks. + */ void -backtrace(int nframes) +backtrace_from_fp(void *fp, int nframes) { - void *fp; int i; -#if defined(LISP_FEATURE_X86) - asm("movl %%ebp,%0" : "=g" (fp)); -#elif defined (LISP_FEATURE_X86_64) - asm("movq %%rbp,%0" : "=g" (fp)); -#else -#error "How did we get here?" -#endif - for (i = 0; i < nframes; ++i) { lispobj *p; void *ra; @@ -507,4 +573,20 @@ backtrace(int nframes) } } +void +backtrace(int nframes) +{ + void *fp; + +#if defined(LISP_FEATURE_X86) + asm("movl %%ebp,%0" : "=g" (fp)); +#elif defined (LISP_FEATURE_X86_64) + asm("movq %%rbp,%0" : "=g" (fp)); +#else +#error "How did we get here?" +#endif + + backtrace_from_fp(fp, nframes); +} + #endif