#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 "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
-#include "dlfcn.h"
+# define __USE_GNU
+# endif
+# include "dlfcn.h"
#endif
#if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64))
{
struct thread *thread=arch_os_get_current_thread();
return (((char *) thread->control_stack_start <= (char *) pointer) &&
- ((char *) pointer < (char *) current_control_stack_pointer));
+ ((char *) pointer < (char *) access_control_stack_pointer(thread)));
}
static void
call_info_from_lisp_state(struct call_info *info)
{
- info->frame = (struct call_frame *)current_control_frame_pointer;
+ info->frame = (struct call_frame *)access_control_frame_pointer(arch_os_get_current_thread());
info->interrupted = 0;
info->code = NULL;
info->lra = 0;
{
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];
+ thread->interrupt_contexts[free_ici];
if ((struct call_frame *)(unsigned long)
(*os_context_register_addr(context, reg_CFP))
== info->frame) {
#else
static int
+altstack_pointer_p (void *p) {
+#ifndef LISP_FEATURE_WIN32
+ void* stack_start = ((void *)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);
}
static int
x86_call_context (void *fp, void **ra, void **ocfp)
{
- void *lisp_ocfp;
- void *lisp_ra;
void *c_ocfp;
void *c_ra;
- int lisp_valid_p, c_valid_p;
+ int c_valid_p;
if (!stack_pointer_p(fp))
return 0;
c_ocfp = *((void **) fp);
c_ra = *((void **) fp + 1);
- lisp_ocfp = *((void **) fp - 1);
- lisp_ra = *((void **) fp - 2);
- lisp_valid_p = (lisp_ocfp > fp
- && stack_pointer_p(lisp_ocfp)
- && ra_pointer_p(lisp_ra));
c_valid_p = (c_ocfp > fp
&& stack_pointer_p(c_ocfp)
&& ra_pointer_p(c_ra));
- if (lisp_valid_p && c_valid_p) {
- void *lisp_path_fp;
- void *c_path_fp;
- void *dummy;
-
- int lisp_path_p = x86_call_context(lisp_ocfp, &lisp_path_fp, &dummy);
- int c_path_p = x86_call_context(c_ocfp, &c_path_fp, &dummy);
-
- if (lisp_path_p && c_path_p) {
-#if defined __FreeBSD__ && __FreeBSD_version > 400000
- if (lisp_ocfp > c_ocfp)
- *ra = lisp_ra, *ocfp = lisp_ocfp;
- else
- *ra = c_ra, *ocfp = c_ocfp;
-#else
- *ra = lisp_ra, *ocfp = lisp_ocfp;
-#endif
- }
- else if (lisp_path_p)
- *ra = lisp_ra, *ocfp = lisp_ocfp;
- else if (c_path_p)
- *ra = c_ra, *ocfp = c_ocfp;
- else
- return 0;
- }
- else if (lisp_valid_p)
- *ra = lisp_ra, *ocfp = lisp_ocfp;
- else if (c_valid_p)
+ if (c_valid_p)
*ra = c_ra, *ocfp = c_ocfp;
else
return 0;
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();
+ struct interrupt_data *data = thread->interrupt_data;
+#ifndef LISP_FEATURE_WIN32
+ get_current_sigmask(&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_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
+ printf("Pending handler = %p\n", data->pending_handler);
+}
+
+/* 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;
}
}
+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
projects / sbcl.git / blobdiff