src/runtime/backtrace.c

   1 /*
   2  * simple backtrace facility
   3  */
   4
   5 /*
   6  * This software is part of the SBCL system. See the README file for
   7  * more information.
   8  *
   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.
  14  */
  15
  16 #include <stdio.h>
  17 #include <signal.h>
  18 #include "sbcl.h"
  19 #include "runtime.h"
  20 #include "globals.h"
  21 #include "os.h"
  22 #include "interrupt.h"
  23 #include "lispregs.h"
  24 #ifdef LISP_FEATURE_GENCGC
  25 #include <wchar.h>
  26 #include "arch.h"
  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"
  31 #endif
  32 #include "genesis/static-symbols.h"
  33 #include "genesis/primitive-objects.h"
  34 #include "thread.h"
  35
  36 #ifdef LISP_FEATURE_OS_PROVIDES_DLADDR
  37 /* __USE_GNU needed if we want dladdr() and Dl_Info from glibc. */
  38 #define __USE_GNU
  39 #include "dlfcn.h"
  40 #endif
  41
  42 #if !(defined(LISP_FEATURE_X86) || defined(LISP_FEATURE_X86_64))
  43
  44 /* KLUDGE: Sigh ... I know what the call frame looks like and it had
  45  * better not change. */
  46
  47 struct call_frame {
  48 #ifndef LISP_FEATURE_ALPHA
  49         struct call_frame *old_cont;
  50 #else
  51         u32 old_cont;
  52 #endif
  53         lispobj saved_lra;
  54         lispobj code;
  55         lispobj other_state[5];
  56 };
  57
  58 struct call_info {
  59 #ifndef LISP_FEATURE_ALPHA
  60     struct call_frame *frame;
  61 #else
  62     u32 frame;
  63 #endif
  64     int interrupted;
  65 #ifndef LISP_FEATURE_ALPHA
  66     struct code *code;
  67 #else
  68     u32 code;
  69 #endif
  70     lispobj lra;
  71     int pc; /* Note: this is the trace file offset, not the actual pc. */
  72 };
  73
  74 #define HEADER_LENGTH(header) ((header)>>8)
  75
  76 static int previous_info(struct call_info *info);
  77
  78 static struct code *
  79 code_pointer(lispobj object)
  80 {
  81     lispobj *headerp, header;
  82     int type, len;
  83
  84     headerp = (lispobj *) native_pointer(object);
  85     header = *headerp;
  86     type = widetag_of(header);
  87
  88     switch (type) {
  89         case CODE_HEADER_WIDETAG:
  90             break;
  91         case RETURN_PC_HEADER_WIDETAG:
  92         case SIMPLE_FUN_HEADER_WIDETAG:
  93             len = HEADER_LENGTH(header);
  94             if (len == 0)
  95                 headerp = NULL;
  96             else
  97                 headerp -= len;
  98             break;
  99         default:
 100             headerp = NULL;
 101     }
 102
 103     return (struct code *) headerp;
 104 }
 105
 106 static boolean
 107 cs_valid_pointer_p(struct call_frame *pointer)
 108 {
 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));
 112 }
 113
 114 static void
 115 call_info_from_lisp_state(struct call_info *info)
 116 {
 117     info->frame = (struct call_frame *)current_control_frame_pointer;
 118     info->interrupted = 0;
 119     info->code = NULL;
 120     info->lra = 0;
 121     info->pc = 0;
 122
 123     previous_info(info);
 124 }
 125
 126 static void
 127 call_info_from_context(struct call_info *info, os_context_t *context)
 128 {
 129     unsigned long pc;
 130
 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. */
 136         info->frame =
 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);
 142     }
 143     else {
 144         info->frame =
 145             (struct call_frame *)(unsigned long)
 146                 (*os_context_register_addr(context, reg_CFP));
 147         info->code =
 148             code_pointer(*os_context_register_addr(context, reg_CODE));
 149         info->lra = NIL;
 150         pc = *os_context_pc_addr(context);
 151     }
 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));
 156 #else
 157             (HEADER_LENGTH(((struct code *)info->code)->header) * sizeof(lispobj));
 158 #endif
 159     else
 160         info->pc = 0;
 161 }
 162
 163 static int
 164 previous_info(struct call_info *info)
 165 {
 166     struct call_frame *this_frame;
 167     struct thread *thread=arch_os_get_current_thread();
 168     int free_ici;
 169
 170     if (!cs_valid_pointer_p(info->frame)) {
 171         printf("Bogus callee value (0x%08lx).\n", (unsigned long)info->frame);
 172         return 0;
 173     }
 174
 175     this_frame = info->frame;
 176     info->lra = this_frame->saved_lra;
 177     info->frame = this_frame->old_cont;
 178     info->interrupted = 0;
 179
 180     if (info->frame == NULL || info->frame == this_frame)
 181         return 0;
 182
 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))
 191                 == info->frame) {
 192                 call_info_from_context(info, context);
 193                 break;
 194             }
 195         }
 196     }
 197     else {
 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));
 204 #else
 205                 (HEADER_LENGTH(((struct code *)info->code)->header) * sizeof(lispobj));
 206 #endif
 207         else
 208             info->pc = 0;
 209     }
 210
 211     return 1;
 212 }
 213
 214 void
 215 backtrace(int nframes)
 216 {
 217     struct call_info info;
 218
 219     call_info_from_lisp_state(&info);
 220
 221     do {
 222         printf("<Frame 0x%08lx%s, ", (unsigned long) info.frame,
 223                 info.interrupted ? " [interrupted]" : "");
 224
 225         if (info.code != (struct code *) 0) {
 226             lispobj function;
 227
 228             printf("CODE: 0x%08lX, ", (unsigned long) info.code | OTHER_POINTER_LOWTAG);
 229
 230 #ifndef LISP_FEATURE_ALPHA
 231             function = info.code->entry_points;
 232 #else
 233             function = ((struct code *)info.code)->entry_points;
 234 #endif
 235             while (function != NIL) {
 236                 struct simple_fun *header;
 237                 lispobj name;
 238
 239                 header = (struct simple_fun *) native_pointer(function);
 240                 name = header->name;
 241
 242                 if (lowtag_of(name) == OTHER_POINTER_LOWTAG) {
 243                     lispobj *object;
 244
 245                     object = (lispobj *) native_pointer(name);
 246
 247                     if (widetag_of(*object) == SYMBOL_HEADER_WIDETAG) {
 248                         struct symbol *symbol;
 249
 250                         symbol = (struct symbol *) object;
 251                         object = (lispobj *) native_pointer(symbol->name);
 252                     }
 253                     if (widetag_of(*object) == SIMPLE_BASE_STRING_WIDETAG) {
 254                         struct vector *string;
 255
 256                         string = (struct vector *) object;
 257                         printf("%s, ", (char *) string->data);
 258                     } else
 259                         /* FIXME: broken from (VECTOR NIL) */
 260                         printf("(Not simple string??\?), ");
 261                 } else
 262                     printf("(Not other pointer??\?), ");
 263
 264
 265                 function = header->next;
 266             }
 267         }
 268         else
 269             printf("CODE: ???, ");
 270
 271         if (info.lra != NIL)
 272             printf("LRA: 0x%08lx, ", (unsigned long)info.lra);
 273         else
 274             printf("<no LRA>, ");
 275
 276         if (info.pc)
 277             printf("PC: 0x%x>\n", info.pc);
 278         else
 279             printf("PC: ??\?>\n");
 280
 281     } while (--nframes > 0 && previous_info(&info));
 282 }
 283
 284 #else
 285
 286 static int
 287 altstack_pointer_p (void *p) {
 288 #ifndef LISP_FEATURE_WIN32
 289     char* stack_start = ((char *) arch_os_get_current_thread())
 290         + dynamic_values_bytes;
 291     char* stack_end = stack_start + 32*SIGSTKSZ;
 292
 293     return (p > stack_start && p <= stack_end);
 294 #else
 295     /* Win32 doesn't do altstack */
 296     return 0;
 297 #endif
 298 }
 299
 300 static int
 301 stack_pointer_p (void *p)
 302 {
 303   /* we are using sizeof(long) here, because that is the right value on both
 304    * x86 and x86-64.  (But note that false positives would not cause much harm
 305    * given the heuristical nature of x86_call_context.) */
 306   unsigned long stack_alignment = sizeof(long);
 307
 308   return (altstack_pointer_p(p)
 309           || (p < (void *) arch_os_get_current_thread()->control_stack_end
 310               && (p > (void *) &p || altstack_pointer_p(&p))
 311               && (((unsigned long) p) & (stack_alignment-1)) == 0));
 312 }
 313
 314 static int
 315 ra_pointer_p (void *ra)
 316 {
 317   /* the check against 4096 is still a mystery to everyone interviewed about
 318    * it, but recent changes to sb-sprof seem to suggest that such values
 319    * do occur sometimes. */
 320   return ((unsigned long) ra) > 4096 && !stack_pointer_p (ra);
 321 }
 322
 323 static int
 324 x86_call_context (void *fp, void **ra, void **ocfp)
 325 {
 326   void *lisp_ocfp;
 327   void *lisp_ra;
 328   void *c_ocfp;
 329   void *c_ra;
 330   int lisp_valid_p, c_valid_p;
 331
 332   if (!stack_pointer_p(fp))
 333     return 0;
 334
 335   c_ocfp    = *((void **) fp);
 336   c_ra      = *((void **) fp + 1);
 337   lisp_ocfp = *((void **) fp - 1);
 338   lisp_ra   = *((void **) fp - 2);
 339
 340   lisp_valid_p = (lisp_ocfp > fp
 341                   && stack_pointer_p(lisp_ocfp)
 342                   && ra_pointer_p(lisp_ra));
 343   c_valid_p = (c_ocfp > fp
 344                && stack_pointer_p(c_ocfp)
 345                && ra_pointer_p(c_ra));
 346
 347   if (lisp_valid_p && c_valid_p) {
 348     void *lisp_path_fp;
 349     void *c_path_fp;
 350     void *dummy;
 351
 352     int lisp_path_p = x86_call_context(lisp_ocfp, &lisp_path_fp, &dummy);
 353     int c_path_p = x86_call_context(c_ocfp, &c_path_fp, &dummy);
 354
 355     if (lisp_path_p && c_path_p) {
 356 #if defined __FreeBSD__ && __FreeBSD_version > 400000
 357       if (lisp_ocfp > c_ocfp)
 358         *ra = lisp_ra, *ocfp = lisp_ocfp;
 359       else
 360         *ra = c_ra, *ocfp = c_ocfp;
 361 #else
 362       *ra = lisp_ra, *ocfp = lisp_ocfp;
 363 #endif
 364     }
 365     else if (lisp_path_p)
 366       *ra = lisp_ra, *ocfp = lisp_ocfp;
 367     else if (c_path_p)
 368       *ra = c_ra, *ocfp = c_ocfp;
 369     else
 370       return 0;
 371   }
 372   else if (lisp_valid_p)
 373     *ra = lisp_ra, *ocfp = lisp_ocfp;
 374   else if (c_valid_p)
 375     *ra = c_ra, *ocfp = c_ocfp;
 376   else
 377     return 0;
 378
 379   return 1;
 380 }
 381
 382 struct compiled_debug_fun *
 383 debug_function_from_pc (struct code* code, void *pc)
 384 {
 385   unsigned long code_header_len = sizeof(lispobj) * HeaderValue(code->header);
 386   unsigned long offset
 387     = (unsigned long) pc - (unsigned long) code - code_header_len;
 388   struct compiled_debug_fun *df;
 389   struct compiled_debug_info *di;
 390   struct vector *v;
 391   int i, len;
 392
 393   if (lowtag_of(code->debug_info) != INSTANCE_POINTER_LOWTAG)
 394     return 0;
 395
 396   di = (struct compiled_debug_info *) native_pointer(code->debug_info);
 397   v = (struct vector *) native_pointer(di->fun_map);
 398   len = fixnum_value(v->length);
 399   df = (struct compiled_debug_fun *) native_pointer(v->data[0]);
 400
 401   if (len == 1)
 402     return df;
 403
 404   for (i = 1;; i += 2) {
 405     unsigned next_pc;
 406
 407     if (i == len)
 408       return ((struct compiled_debug_fun *) native_pointer(v->data[i - 1]));
 409
 410     if (offset >= fixnum_value(df->elsewhere_pc)) {
 411       struct compiled_debug_fun *p
 412         = ((struct compiled_debug_fun *) native_pointer(v->data[i + 1]));
 413       next_pc = fixnum_value(p->elsewhere_pc);
 414     } else
 415       next_pc = fixnum_value(v->data[i]);
 416
 417     if (offset < next_pc)
 418       return ((struct compiled_debug_fun *) native_pointer(v->data[i - 1]));
 419   }
 420
 421   return NULL;
 422 }
 423
 424 static void
 425 sbcl_putwc(wchar_t c, FILE *file)
 426 {
 427 #ifdef LISP_FEATURE_OS_PROVIDES_PUTWC
 428     putwc(c, file);
 429 #else
 430     if (c < 256) {
 431         fputc(c, file);
 432     } else {
 433         fputc('?', file);
 434     }
 435 #endif
 436 }
 437
 438 static void
 439 print_string (lispobj *object)
 440 {
 441   int tag = widetag_of(*object);
 442   struct vector *vector = (struct vector *) object;
 443
 444 #define doit(TYPE)                              \
 445   do {                                          \
 446     int i;                                      \
 447     int n = fixnum_value(vector->length);       \
 448     TYPE *data = (TYPE *) vector->data;         \
 449     for (i = 0; i < n; i++) {                   \
 450       wchar_t c = (wchar_t) data[i];            \
 451       if (c == '\\' || c == '"')                \
 452         putchar('\\');                          \
 453       sbcl_putwc(c, stdout);                    \
 454     }                                           \
 455   } while (0)
 456
 457   switch (tag) {
 458   case SIMPLE_BASE_STRING_WIDETAG:
 459     doit(unsigned char);
 460     break;
 461 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
 462   case SIMPLE_CHARACTER_STRING_WIDETAG:
 463     doit(unsigned int);
 464     break;
 465 #endif
 466   default:
 467     printf("<??? type %d>", tag);
 468   }
 469 #undef doit
 470 }
 471
 472 static void
 473 print_entry_name (lispobj name)
 474 {
 475   if (lowtag_of (name) == LIST_POINTER_LOWTAG) {
 476     putchar('(');
 477     while (name != NIL) {
 478       struct cons *cons = (struct cons *) native_pointer(name);
 479       print_entry_name(cons->car);
 480       name = cons->cdr;
 481       if (name != NIL)
 482         putchar(' ');
 483     }
 484     putchar(')');
 485   } else if (lowtag_of(name) == OTHER_POINTER_LOWTAG) {
 486     lispobj *object = (lispobj *) native_pointer(name);
 487     if (widetag_of(*object) == SYMBOL_HEADER_WIDETAG) {
 488       struct symbol *symbol = (struct symbol *) object;
 489       if (symbol->package != NIL) {
 490         struct package *pkg
 491           = (struct package *) native_pointer(symbol->package);
 492         lispobj pkg_name = pkg->_name;
 493         print_string(native_pointer(pkg_name));
 494         fputs("::", stdout);
 495       }
 496       print_string(native_pointer(symbol->name));
 497     } else if (widetag_of(*object) == SIMPLE_BASE_STRING_WIDETAG) {
 498          putchar('"');
 499          print_string(object);
 500          putchar('"');
 501 #ifdef SIMPLE_CHARACTER_STRING_WIDETAG
 502       } else if (widetag_of(*object) == SIMPLE_CHARACTER_STRING_WIDETAG) {
 503          putchar('"');
 504          print_string(object);
 505          putchar('"');
 506 #endif
 507     } else {
 508       printf("<??? type %d>", (int) widetag_of(*object));
 509     }
 510   } else {
 511     printf("<??? lowtag %d>", (int) lowtag_of(name));
 512   }
 513 }
 514
 515 static void
 516 print_entry_points (struct code *code)
 517 {
 518   lispobj function = code->entry_points;
 519
 520   while (function != NIL) {
 521     struct simple_fun *header = (struct simple_fun *) native_pointer(function);
 522     print_entry_name(header->name);
 523
 524     function = header->next;
 525     if (function != NIL)
 526       printf (", ");
 527   }
 528 }
 529
 530 /* This function has been split from backtrace() to enable Lisp
 531  * backtraces from gdb with call backtrace_from_fp(...). Useful for
 532  * example when debugging threading deadlocks.
 533  */
 534 void
 535 backtrace_from_fp(void *fp, int nframes)
 536 {
 537   int i;
 538
 539   for (i = 0; i < nframes; ++i) {
 540     lispobj *p;
 541     void *ra;
 542     void *next_fp;
 543
 544     if (!x86_call_context(fp, &ra, &next_fp))
 545       break;
 546
 547     printf("%4d: ", i);
 548
 549     p = (lispobj *) component_ptr_from_pc((lispobj *) ra);
 550     if (p) {
 551       struct code *cp = (struct code *) p;
 552       struct compiled_debug_fun *df = debug_function_from_pc(cp, ra);
 553       if (df)
 554         print_entry_name(df->name);
 555       else
 556         print_entry_points(cp);
 557     } else {
 558 #ifdef LISP_FEATURE_OS_PROVIDES_DLADDR
 559         Dl_info info;
 560         if (dladdr(ra, &info)) {
 561             printf("Foreign function %s, fp = 0x%lx, ra = 0x%lx",
 562                    info.dli_sname,
 563                    (unsigned long) next_fp,
 564                    (unsigned long) ra);
 565         } else
 566 #endif
 567         printf("Foreign fp = 0x%lx, ra = 0x%lx",
 568                (unsigned long) next_fp,
 569                (unsigned long) ra);
 570     }
 571
 572     putchar('\n');
 573     fp = next_fp;
 574   }
 575 }
 576
 577 void
 578 backtrace(int nframes)
 579 {
 580   void *fp;
 581   int i;
 582
 583 #if defined(LISP_FEATURE_X86)
 584   asm("movl %%ebp,%0" : "=g" (fp));
 585 #elif defined (LISP_FEATURE_X86_64)
 586   asm("movq %%rbp,%0" : "=g" (fp));
 587 #else
 588 #error "How did we get here?"
 589 #endif
 590
 591   backtrace_from_fp(fp, nframes);
 592 }
 593
 594 #endif