#include "interrupt.h"
#include "lispregs.h"
#ifdef LISP_FEATURE_GENCGC
+#include <wchar.h>
#include "arch.h"
#include "gencgc-alloc-region.h"
#include "genesis/compiled-debug-fun.h"
#include "genesis/primitive-objects.h"
#include "thread.h"
+#ifdef LISP_FEATURE_OS_PROVIDES_DLADDR
+# ifndef __USE_GNU
+/* __USE_GNU needed if we want dladdr() and Dl_Info from glibc. */
+# define __USE_GNU
+# endif
+# include "dlfcn.h"
+#endif
+
#if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64))
/* KLUDGE: Sigh ... I know what the call frame looks like and it had
/* 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;
{
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);
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;
#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);
}
if (i == len)
return ((struct compiled_debug_fun *) native_pointer(v->data[i - 1]));
- if (offset >= fixnum_value(df->elsewhere_pc)) {
+ if (offset >= (unsigned long)fixnum_value(df->elsewhere_pc)) {
struct compiled_debug_fun *p
= ((struct compiled_debug_fun *) native_pointer(v->data[i + 1]));
next_pc = fixnum_value(p->elsewhere_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("<??? type %d>", tag);
+ }
+#undef doit
+}
+
+static void
print_entry_name (lispobj name)
{
if (lowtag_of (name) == LIST_POINTER_LOWTAG) {
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("<oops, a unicode string>"); /* FIXME */
+ } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) {
+ putchar('"');
+ print_string(object);
+ putchar('"');
#endif
- } else
+ } else {
printf("<??? type %d>", (int) widetag_of(*object));
- } else
+ }
+ } else {
printf("<??? lowtag %d>", (int) lowtag_of(name));
+ }
}
static void
}
void
-backtrace(int nframes)
+describe_thread_state(void)
{
- 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?"
+ sigset_t mask;
+ struct thread *thread = arch_os_get_current_thread();
+#ifndef LISP_FEATURE_WIN32
+ thread_sigmask(SIG_SETMASK, NULL, &mask);
+ printf("Signal mask:\n");
+ printf(" SIGALRM = %d\n", sigismember(&mask, SIGALRM));
+ printf(" SIGINT = %d\n", sigismember(&mask, SIGINT));
+ printf(" SIGPROF = %d\n", sigismember(&mask, SIGPROF));
+#ifdef SIG_INTERRUPT_THREAD
+ printf(" SIG_INTERRUPT_THREAD = %d\n", sigismember(&mask, SIG_INTERRUPT_THREAD));
+#endif
+#ifdef SIG_STOP_FOR_GC
+ printf(" SIG_STOP_FOR_GC = %d\n", sigismember(&mask, SIG_STOP_FOR_GC));
+#endif
+#endif
+ printf("Specials:\n");
+ printf(" *GC-INHIBIT* = %s\n", (SymbolValue(GC_INHIBIT, thread) == T) ? "T" : "NIL");
+ printf(" *GC-PENDING* = %s\n",
+ (SymbolValue(GC_PENDING, thread) == T) ?
+ "T" : ((SymbolValue(GC_PENDING, thread) == NIL) ?
+ "NIL" : ":IN-PROGRESS"));
+ printf(" *INTERRUPTS-ENABLED* = %s\n", (SymbolValue(INTERRUPTS_ENABLED, thread) == T) ? "T" : "NIL");
+#ifdef STOP_FOR_GC_PENDING
+ printf(" *STOP-FOR-GC-PENDING* = %s\n", (SymbolValue(STOP_FOR_GC_PENDING, thread) == T) ? "T" : "NIL");
#endif
+}
+
+/* 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_from_fp(void *fp, int nframes)
+{
+ int i;
for (i = 0; i < nframes; ++i) {
lispobj *p;
print_entry_name(df->name);
else
print_entry_points(cp);
- } else
- printf("Foreign fp = 0x%lx, ra = 0x%lx",
- (unsigned long) next_fp,
- (unsigned long) ra);
+ } else {
+#ifdef LISP_FEATURE_OS_PROVIDES_DLADDR
+ Dl_info info;
+ if (dladdr(ra, &info)) {
+ printf("Foreign function %s, fp = 0x%lx, ra = 0x%lx",
+ info.dli_sname,
+ (unsigned long) next_fp,
+ (unsigned long) ra);
+ } else
+#endif
+ printf("Foreign fp = 0x%lx, ra = 0x%lx",
+ (unsigned long) next_fp,
+ (unsigned long) ra);
+ }
putchar('\n');
fp = next_fp;
}
}
+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