ghc/rts/Printer.c

   1 /* -----------------------------------------------------------------------------
   2  * $Id: Printer.c,v 1.19 2000/01/13 14:34:04 hwloidl Exp $
   3  *
   4  * Copyright (c) 1994-1999.
   5  *
   6  * Heap printer
   7  *
   8  * ---------------------------------------------------------------------------*/
   9
  10 #include "Rts.h"
  11 #include "Printer.h"
  12
  13 #ifdef DEBUG
  14
  15 #include "RtsUtils.h"
  16 #include "RtsFlags.h"
  17 #include "Bytecodes.h"  /* for InstrPtr */
  18 #include "Disassembler.h"
  19
  20 #include "Printer.h"
  21
  22 // HWL: explicit fixed header size to make debugging easier
  23 int fixed_hs = FIXED_HS, itbl_sz = sizeofW(StgInfoTable),
  24     uf_sz=sizeofW(StgUpdateFrame), sf_sz=sizeofW(StgSeqFrame);
  25
  26 /* --------------------------------------------------------------------------
  27  * local function decls
  28  * ------------------------------------------------------------------------*/
  29
  30 static void    printStdObject( StgClosure *obj, char* tag );
  31 static void    reset_table   ( int size );
  32 static void    prepare_table ( void );
  33 static void    insert        ( unsigned value, const char *name );
  34 #if 0 /* unused but might be useful sometime */
  35 static rtsBool lookup_name   ( char *name, unsigned *result );
  36 static void    enZcode       ( char *in, char *out );
  37 #endif
  38 static char    unZcode       ( char ch );
  39 rtsBool lookupGHCName ( StgPtr addr, const char **result );
  40 static void    printZcoded   ( const char *raw );
  41
  42 /* --------------------------------------------------------------------------
  43  * Printer
  44  * ------------------------------------------------------------------------*/
  45
  46
  47 #ifdef INTERPRETER
  48 extern void* itblNames[];
  49 extern int   nItblNames;
  50 char* lookupHugsItblName ( void* v )
  51 {
  52    int i;
  53    for (i = 0; i < nItblNames; i += 2)
  54       if (itblNames[i] == v) return itblNames[i+1];
  55    return NULL;
  56 }
  57 #endif
  58
  59 void printPtr( StgPtr p )
  60 {
  61 #ifdef INTERPRETER
  62     char* str;
  63 #endif
  64     const char *raw;
  65     if (lookupGHCName( p, &raw )) {
  66         printZcoded(raw);
  67 #ifdef INTERPRETER
  68     } else if ((raw = lookupHugsName(p)) != 0) {
  69         fprintf(stderr, "%s", raw);
  70     } else if ((str = lookupHugsItblName(p)) != 0) {
  71         fprintf(stderr, "%p=%s", p, str);
  72 #endif
  73     } else {
  74         fprintf(stderr, "%p", p);
  75     }
  76 }
  77
  78 void printObj( StgClosure *obj )
  79 {
  80     fprintf(stderr,"Object "); printPtr((StgPtr)obj); fprintf(stderr," = ");
  81     printClosure(obj);
  82 }
  83
  84 static void printStdObject( StgClosure *obj, char* tag )
  85 {
  86     StgWord i, j;
  87     const StgInfoTable* info = get_itbl(obj);
  88     fprintf(stderr,"%s(",tag);
  89     printPtr((StgPtr)obj->header.info);
  90     for (i = 0; i < info->layout.payload.ptrs; ++i) {
  91         fprintf(stderr,", ");
  92         printPtr(payloadPtr(obj,i));
  93     }
  94     for (j = 0; j < info->layout.payload.nptrs; ++j) {
  95         fprintf(stderr,", %xd#",payloadWord(obj,i+j));
  96     }
  97     fprintf(stderr,")\n");
  98 }
  99
 100 void printClosure( StgClosure *obj )
 101 {
 102     switch ( get_itbl(obj)->type ) {
 103     case INVALID_OBJECT:
 104             barf("Invalid object");
 105 #ifdef INTERPRETER
 106     case BCO:
 107             fprintf(stderr,"BCO\n");
 108             disassemble(stgCast(StgBCO*,obj),"\t");
 109             break;
 110 #endif
 111
 112     case AP_UPD:
 113         {
 114             StgAP_UPD* ap = stgCast(StgAP_UPD*,obj);
 115             StgWord i;
 116             fprintf(stderr,"AP_UPD("); printPtr((StgPtr)ap->fun);
 117             for (i = 0; i < ap->n_args; ++i) {
 118                 fprintf(stderr,", ");
 119                 printPtr(payloadPtr(ap,i));
 120             }
 121             fprintf(stderr,")\n");
 122             break;
 123         }
 124
 125     case PAP:
 126         {
 127             StgPAP* pap = stgCast(StgPAP*,obj);
 128             StgWord i;
 129             fprintf(stderr,"PAP("); printPtr((StgPtr)pap->fun);
 130             for (i = 0; i < pap->n_args; ++i) {
 131                 fprintf(stderr,", ");
 132                 printPtr(payloadPtr(pap,i));
 133             }
 134             fprintf(stderr,")\n");
 135             break;
 136         }
 137
 138     case IND:
 139             fprintf(stderr,"IND(");
 140             printPtr((StgPtr)stgCast(StgInd*,obj)->indirectee);
 141             fprintf(stderr,")\n");
 142             break;
 143
 144     case IND_STATIC:
 145             fprintf(stderr,"IND_STATIC(");
 146             printPtr((StgPtr)stgCast(StgInd*,obj)->indirectee);
 147             fprintf(stderr,")\n");
 148             break;
 149
 150     case IND_OLDGEN:
 151             fprintf(stderr,"IND_OLDGEN(");
 152             printPtr((StgPtr)stgCast(StgInd*,obj)->indirectee);
 153             fprintf(stderr,")\n");
 154             break;
 155
 156     case CAF_UNENTERED:
 157         {
 158             StgCAF* caf = stgCast(StgCAF*,obj);
 159             fprintf(stderr,"CAF_UNENTERED(");
 160             printPtr((StgPtr)caf->body);
 161             fprintf(stderr,", ");
 162             printPtr((StgPtr)caf->value); /* should be null */
 163             fprintf(stderr,", ");
 164             printPtr((StgPtr)caf->link);  /* should be null */
 165             fprintf(stderr,")\n");
 166             break;
 167         }
 168
 169     case CAF_ENTERED:
 170         {
 171             StgCAF* caf = stgCast(StgCAF*,obj);
 172             fprintf(stderr,"CAF_ENTERED(");
 173             printPtr((StgPtr)caf->body);
 174             fprintf(stderr,", ");
 175             printPtr((StgPtr)caf->value);
 176             fprintf(stderr,", ");
 177             printPtr((StgPtr)caf->link);
 178             fprintf(stderr,")\n");
 179             break;
 180         }
 181
 182     case CAF_BLACKHOLE:
 183             fprintf(stderr,"CAF_BH(");
 184             printPtr((StgPtr)stgCast(StgBlockingQueue*,obj)->blocking_queue);
 185             fprintf(stderr,")\n");
 186             break;
 187
 188     case SE_BLACKHOLE:
 189             fprintf(stderr,"SE_BH\n");
 190             break;
 191
 192     case SE_CAF_BLACKHOLE:
 193             fprintf(stderr,"SE_CAF_BH\n");
 194             break;
 195
 196     case BLACKHOLE:
 197             fprintf(stderr,"BH\n");
 198             break;
 199
 200     case BLACKHOLE_BQ:
 201             fprintf(stderr,"BQ(");
 202             printPtr((StgPtr)stgCast(StgBlockingQueue*,obj)->blocking_queue);
 203             fprintf(stderr,")\n");
 204             break;
 205
 206 #if defined(GRAN) || defined(PAR)
 207     case RBH:
 208       fprintf(stderr,"RBH(");
 209       printPtr((StgPtr)stgCast(StgRBH*,obj)->blocking_queue);
 210       fprintf(stderr,")\n");
 211       break;
 212 #endif
 213
 214     case CONSTR:
 215     case CONSTR_1_0: case CONSTR_0_1:
 216     case CONSTR_1_1: case CONSTR_0_2: case CONSTR_2_0:
 217     case CONSTR_INTLIKE:
 218     case CONSTR_CHARLIKE:
 219     case CONSTR_STATIC:
 220     case CONSTR_NOCAF_STATIC:
 221         {
 222             /* We can't use printStdObject because we want to print the
 223              * tag as well.
 224              */
 225             StgWord i, j;
 226             const StgInfoTable* info = get_itbl(obj);
 227             fprintf(stderr,"PACK(");
 228             printPtr((StgPtr)obj->header.info);
 229             fprintf(stderr,"(tag=%d)",info->srt_len);
 230             for (i = 0; i < info->layout.payload.ptrs; ++i) {
 231                 fprintf(stderr,", ");
 232                 printPtr(payloadPtr(obj,i));
 233             }
 234             for (j = 0; j < info->layout.payload.nptrs; ++j) {
 235                 fprintf(stderr,", %x#",payloadWord(obj,i+j));
 236             }
 237             fprintf(stderr,")\n");
 238             break;
 239         }
 240
 241     case FUN:
 242     case FUN_1_0: case FUN_0_1:
 243     case FUN_1_1: case FUN_0_2: case FUN_2_0:
 244     case FUN_STATIC:
 245             printStdObject(obj,"FUN");
 246             break;
 247
 248     case THUNK:
 249     case THUNK_1_0: case THUNK_0_1:
 250     case THUNK_1_1: case THUNK_0_2: case THUNK_2_0:
 251     case THUNK_STATIC:
 252             /* ToDo: will this work for THUNK_STATIC too? */
 253             printStdObject(obj,"THUNK");
 254             break;
 255 #if 0
 256     case ARR_WORDS:
 257         {
 258             StgWord i;
 259             fprintf(stderr,"ARR_WORDS(\"");
 260             /* ToDo: we can't safely assume that this is a string! */
 261             for (i = 0; arrWordsGetChar(obj,i); ++i) {
 262                 putchar(arrWordsGetChar(obj,i));
 263             }
 264             fprintf(stderr,"\")\n");
 265             break;
 266         }
 267 #endif
 268     case UPDATE_FRAME:
 269         {
 270             StgUpdateFrame* u = stgCast(StgUpdateFrame*,obj);
 271             fprintf(stderr,"UpdateFrame(");
 272             printPtr((StgPtr)GET_INFO(u));
 273             fprintf(stderr,",");
 274             printPtr((StgPtr)u->updatee);
 275             fprintf(stderr,",");
 276             printPtr((StgPtr)u->link);
 277             fprintf(stderr,")\n");
 278             break;
 279         }
 280
 281     case CATCH_FRAME:
 282         {
 283             StgCatchFrame* u = stgCast(StgCatchFrame*,obj);
 284             fprintf(stderr,"CatchFrame(");
 285             printPtr((StgPtr)GET_INFO(u));
 286             fprintf(stderr,",");
 287             printPtr((StgPtr)u->handler);
 288             fprintf(stderr,",");
 289             printPtr((StgPtr)u->link);
 290             fprintf(stderr,")\n");
 291             break;
 292         }
 293
 294     case SEQ_FRAME:
 295         {
 296             StgSeqFrame* u = stgCast(StgSeqFrame*,obj);
 297             fprintf(stderr,"SeqFrame(");
 298             printPtr((StgPtr)GET_INFO(u));
 299             fprintf(stderr,",");
 300             printPtr((StgPtr)u->link);
 301             fprintf(stderr,")\n");
 302             break;
 303         }
 304
 305     case STOP_FRAME:
 306         {
 307             StgStopFrame* u = stgCast(StgStopFrame*,obj);
 308             fprintf(stderr,"StopFrame(");
 309             printPtr((StgPtr)GET_INFO(u));
 310             fprintf(stderr,")\n");
 311             break;
 312         }
 313     default:
 314             //barf("printClosure %d",get_itbl(obj)->type);
 315             fprintf(stderr, "*** printClosure: unknown type %d ****\n",
 316                     get_itbl(obj)->type );
 317             return;
 318     }
 319 }
 320
 321 /*
 322 void printGraph( StgClosure *obj )
 323 {
 324  printClosure(obj);
 325 }
 326 */
 327
 328 StgPtr printStackObj( StgPtr sp )
 329 {
 330     /*fprintf(stderr,"Stack[%d] = ", &stgStack[STACK_SIZE] - sp); */
 331
 332     if (IS_ARG_TAG(*sp)) {
 333         nat i;
 334         StgWord tag = *sp++;
 335         fprintf(stderr,"Tagged{");
 336         for (i = 0; i < tag; i++) {
 337             fprintf(stderr,"0x%x#", (unsigned)(*sp++));
 338             if (i < tag-1) fprintf(stderr, ", ");
 339         }
 340         fprintf(stderr, "}\n");
 341     } else {
 342         StgClosure* c = (StgClosure*)(*sp);
 343         printPtr((StgPtr)*sp);
 344 #ifdef INTERPRETER
 345         if (c == &ret_bco_info) {
 346            fprintf(stderr, "\t\t");
 347            fprintf(stderr, "ret_bco_info\n" );
 348         } else
 349         if (IS_HUGS_CONSTR_INFO(GET_INFO(c))) {
 350            fprintf(stderr, "\t\t\t");
 351            fprintf(stderr, "ConstrInfoTable\n" );
 352         } else
 353 #endif
 354         if (get_itbl(c)->type == BCO) {
 355            fprintf(stderr, "\t\t\t");
 356            fprintf(stderr, "BCO(...)\n");
 357         }
 358         else {
 359            fprintf(stderr, "\t\t\t");
 360            printClosure ( (StgClosure*)(*sp));
 361         }
 362         sp += 1;
 363     }
 364     return sp;
 365
 366 }
 367
 368 void printStackChunk( StgPtr sp, StgPtr spBottom )
 369 {
 370     StgWord32 bitmap;
 371     const StgInfoTable *info;
 372
 373     ASSERT(sp <= spBottom);
 374     while (sp < spBottom) {
 375       if (!IS_ARG_TAG(*sp) && LOOKS_LIKE_GHC_INFO(*sp)) {
 376         info = get_itbl((StgClosure *)sp);
 377         switch (info->type) {
 378
 379         case UPDATE_FRAME:
 380             printObj( stgCast(StgClosure*,sp) );
 381             sp += sizeofW(StgUpdateFrame);
 382             continue;
 383
 384         case SEQ_FRAME:
 385             printObj( stgCast(StgClosure*,sp) );
 386             sp += sizeofW(StgSeqFrame);
 387             continue;
 388
 389         case CATCH_FRAME:
 390             printObj( stgCast(StgClosure*,sp) );
 391             sp += sizeofW(StgCatchFrame);
 392             continue;
 393
 394         case STOP_FRAME:
 395             /* not quite: ASSERT(stgCast(StgPtr,su) == spBottom); */
 396             printObj( stgCast(StgClosure*,sp) );
 397             continue;
 398
 399         case RET_DYN:
 400           fprintf(stderr, "RET_DYN (%p)\n", sp);
 401           bitmap = *++sp;
 402           ++sp;
 403           fprintf(stderr, "Bitmap: 0x%x\n", bitmap);
 404           goto small_bitmap;
 405
 406         case RET_SMALL:
 407         case RET_VEC_SMALL:
 408           fprintf(stderr, "RET_SMALL (%p)\n", sp);
 409           bitmap = info->layout.bitmap;
 410           sp++;
 411         small_bitmap:
 412           while (bitmap != 0) {
 413             fprintf(stderr,"Stack[%d] (%p) = ", spBottom-sp, sp);
 414             if ((bitmap & 1) == 0) {
 415               printPtr((P_)*sp);
 416               fprintf(stderr,"\n");
 417             } else {
 418               fprintf(stderr,"Word# %d\n", *sp++);
 419             }
 420             sp++;
 421             bitmap = bitmap >> 1;
 422             }
 423           continue;
 424
 425         case RET_BIG:
 426         case RET_VEC_BIG:
 427           barf("todo");
 428
 429         default:
 430           break;
 431         }
 432       }
 433       fprintf(stderr,"Stack[%d] (%p) = ", spBottom-sp, sp);
 434       sp = printStackObj(sp);
 435     }
 436 }
 437
 438 void printStack( StgPtr sp, StgPtr spBottom, StgUpdateFrame* su )
 439 {
 440     /* check everything down to the first update frame */
 441     printStackChunk( sp, stgCast(StgPtr,su) );
 442     while ( stgCast(StgPtr,su) < spBottom) {
 443         sp = stgCast(StgPtr,su);
 444         switch (get_itbl(su)->type) {
 445         case UPDATE_FRAME:
 446                 printObj( stgCast(StgClosure*,su) );
 447                 sp += sizeofW(StgUpdateFrame);
 448                 su = su->link;
 449                 break;
 450         case SEQ_FRAME:
 451                 printObj( stgCast(StgClosure*,su) );
 452                 sp += sizeofW(StgSeqFrame);
 453                 su = stgCast(StgSeqFrame*,su)->link;
 454                 break;
 455         case CATCH_FRAME:
 456                 printObj( stgCast(StgClosure*,su) );
 457                 sp += sizeofW(StgCatchFrame);
 458                 su = stgCast(StgCatchFrame*,su)->link;
 459                 break;
 460         case STOP_FRAME:
 461                 /* not quite: ASSERT(stgCast(StgPtr,su) == spBottom); */
 462                 printObj( stgCast(StgClosure*,su) );
 463                 return;
 464         default:
 465                 barf("printStack: weird record found on update frame list.");
 466         }
 467         printStackChunk( sp, stgCast(StgPtr,su) );
 468     }
 469     ASSERT(stgCast(StgPtr,su) == spBottom);
 470 }
 471
 472 void printTSO( StgTSO *tso )
 473 {
 474     printStack( tso->sp, tso->stack+tso->stack_size,tso->su);
 475     /* printStackChunk( tso->sp, tso->stack+tso->stack_size); */
 476 }
 477
 478
 479 /* --------------------------------------------------------------------------
 480  * Address printing code
 481  *
 482  * Uses symbol table in (unstripped executable)
 483  * ------------------------------------------------------------------------*/
 484
 485 /* --------------------------------------------------------------------------
 486  * Simple lookup table
 487  *
 488  * Current implementation is pretty dumb!
 489  * ------------------------------------------------------------------------*/
 490
 491 struct entry {
 492     nat value;
 493     const char *name;
 494 };
 495
 496 static nat max_table_size;
 497 static nat table_size;
 498 static struct entry* table;
 499
 500 static void reset_table( int size )
 501 {
 502     max_table_size = size;
 503     table_size = 0;
 504     table = (struct entry *) malloc(size * sizeof(struct entry));
 505 }
 506
 507 static void prepare_table( void )
 508 {
 509     /* Could sort it...  */
 510 }
 511
 512 static void insert( unsigned value, const char *name )
 513 {
 514     if ( table_size >= max_table_size ) {
 515         barf( "Symbol table overflow\n" );
 516     }
 517     table[table_size].value = value;
 518     table[table_size].name = name;
 519     table_size = table_size + 1;
 520 }
 521
 522
 523 #if 0
 524 static rtsBool lookup_name( char *name, unsigned *result )
 525 {
 526     int i;
 527     for( i = 0; i < table_size && strcmp(name,table[i].name) != 0; ++i ) {
 528     }
 529     if (i < table_size) {
 530         *result = table[i].value;
 531         return rtsTrue;
 532     } else {
 533         return rtsFalse;
 534     }
 535 }
 536 #endif
 537
 538 /* Code from somewhere inside GHC (circa 1994)
 539  * * Z-escapes:
 540  *     "std"++xs -> "Zstd"++xs
 541  *     char_to_c 'Z'  = "ZZ"
 542  *     char_to_c '&'  = "Za"
 543  *     char_to_c '|'  = "Zb"
 544  *     char_to_c ':'  = "Zc"
 545  *     char_to_c '/'  = "Zd"
 546  *     char_to_c '='  = "Ze"
 547  *     char_to_c '>'  = "Zg"
 548  *     char_to_c '#'  = "Zh"
 549  *     char_to_c '<'  = "Zl"
 550  *     char_to_c '-'  = "Zm"
 551  *     char_to_c '!'  = "Zn"
 552  *     char_to_c '.'  = "Zo"
 553  *     char_to_c '+'  = "Zp"
 554  *     char_to_c '\'' = "Zq"
 555  *     char_to_c '*'  = "Zt"
 556  *     char_to_c '_'  = "Zu"
 557  *     char_to_c c    = "Z" ++ show (ord c)
 558  */
 559 static char unZcode( char ch )
 560 {
 561     switch (ch) {
 562     case 'a'  : return ('&');
 563     case 'b'  : return ('|');
 564     case 'c'  : return (':');
 565     case 'd'  : return ('/');
 566     case 'e'  : return ('=');
 567     case 'g'  : return ('>');
 568     case 'h'  : return ('#');
 569     case 'l'  : return ('<');
 570     case 'm'  : return ('-');
 571     case 'n'  : return ('!');
 572     case 'o'  : return ('.');
 573     case 'p'  : return ('+');
 574     case 'q'  : return ('\'');
 575     case 't'  : return ('*');
 576     case 'u'  : return ('_');
 577     case 'Z'  :
 578     case '\0' : return ('Z');
 579     default   : return (ch);
 580     }
 581 }
 582
 583 #if 0
 584 /* Precondition: out big enough to handle output (about twice length of in) */
 585 static void enZcode( char *in, char *out )
 586 {
 587     int i, j;
 588
 589     j = 0;
 590     out[ j++ ] = '_';
 591     for( i = 0; in[i] != '\0'; ++i ) {
 592         switch (in[i]) {
 593         case 'Z'  :
 594                 out[j++] = 'Z';
 595                 out[j++] = 'Z';
 596                 break;
 597         case '&'  :
 598                 out[j++] = 'Z';
 599                 out[j++] = 'a';
 600                 break;
 601         case '|'  :
 602                 out[j++] = 'Z';
 603                 out[j++] = 'b';
 604                 break;
 605         case ':'  :
 606                 out[j++] = 'Z';
 607                 out[j++] = 'c';
 608                 break;
 609         case '/'  :
 610                 out[j++] = 'Z';
 611                 out[j++] = 'd';
 612                 break;
 613         case '='  :
 614                 out[j++] = 'Z';
 615                 out[j++] = 'e';
 616                 break;
 617         case '>'  :
 618                 out[j++] = 'Z';
 619                 out[j++] = 'g';
 620                 break;
 621         case '#'  :
 622                 out[j++] = 'Z';
 623                 out[j++] = 'h';
 624                 break;
 625         case '<'  :
 626                 out[j++] = 'Z';
 627                 out[j++] = 'l';
 628                 break;
 629         case '-'  :
 630                 out[j++] = 'Z';
 631                 out[j++] = 'm';
 632                 break;
 633         case '!'  :
 634                 out[j++] = 'Z';
 635                 out[j++] = 'n';
 636                 break;
 637         case '.'  :
 638                 out[j++] = 'Z';
 639                 out[j++] = 'o';
 640                 break;
 641         case '+'  :
 642                 out[j++] = 'Z';
 643                 out[j++] = 'p';
 644                 break;
 645         case '\'' :
 646                 out[j++] = 'Z';
 647                 out[j++] = 'q';
 648                 break;
 649         case '*'  :
 650                 out[j++] = 'Z';
 651                 out[j++] = 't';
 652                 break;
 653         case '_'  :
 654                 out[j++] = 'Z';
 655                 out[j++] = 'u';
 656                 break;
 657         default :
 658                 out[j++] = in[i];
 659                 break;
 660         }
 661     }
 662     out[j] = '\0';
 663 }
 664 #endif
 665
 666 rtsBool lookupGHCName( StgPtr addr, const char **result )
 667 {
 668     nat i;
 669     for( i = 0; i < table_size && table[i].value != (unsigned) addr; ++i ) {
 670     }
 671     if (i < table_size) {
 672         *result = table[i].name;
 673         return rtsTrue;
 674     } else {
 675         return rtsFalse;
 676     }
 677 }
 678
 679 static void printZcoded( const char *raw )
 680 {
 681     nat j = 0;
 682
 683     while ( raw[j] != '\0' ) {
 684         if (raw[j] == 'Z') {
 685             fputc(unZcode(raw[j+1]),stderr);
 686             j = j + 2;
 687         } else {
 688             fputc(raw[j],stderr);
 689             j = j + 1;
 690         }
 691     }
 692 }
 693
 694 /* --------------------------------------------------------------------------
 695  * Symbol table loading
 696  * ------------------------------------------------------------------------*/
 697
 698 /* Causing linking trouble on Win32 plats, so I'm
 699    disabling this for now.
 700 */
 701 #if defined(HAVE_BFD_H) && !defined(_WIN32) && defined(USE_BSD)
 702
 703 #include <bfd.h>
 704
 705 /* Fairly ad-hoc piece of code that seems to filter out a lot of
 706  * rubbish like the obj-splitting symbols
 707  */
 708
 709 static rtsBool isReal( flagword flags, const char *name )
 710 {
 711 #if 0
 712     /* ToDo: make this work on BFD */
 713     int tp = type & N_TYPE;
 714     if (tp == N_TEXT || tp == N_DATA) {
 715         return (name[0] == '_' && name[1] != '_');
 716     } else {
 717         return rtsFalse;
 718     }
 719 #else
 720     (void)flags;   /* keep gcc -Wall happy */
 721     if (*name == '\0'  ||
 722         (name[0] == 'g' && name[1] == 'c' && name[2] == 'c') ||
 723         (name[0] == 'c' && name[1] == 'c' && name[2] == '.')) {
 724         return rtsFalse;
 725     }
 726     return rtsTrue;
 727 #endif
 728 }
 729
 730 extern void DEBUG_LoadSymbols( char *name )
 731 {
 732     bfd* abfd;
 733     char **matching;
 734
 735     bfd_init();
 736     abfd = bfd_openr(name, "default");
 737     if (abfd == NULL) {
 738         barf("can't open executable %s to get symbol table", name);
 739     }
 740     if (!bfd_check_format_matches (abfd, bfd_object, &matching)) {
 741         barf("mismatch");
 742     }
 743
 744     {
 745         long storage_needed;
 746         asymbol **symbol_table;
 747         long number_of_symbols;
 748         long num_real_syms = 0;
 749         long i;
 750
 751         storage_needed = bfd_get_symtab_upper_bound (abfd);
 752
 753         if (storage_needed < 0) {
 754             barf("can't read symbol table");
 755         }
 756 #if 0
 757         if (storage_needed == 0) {
 758             belch("no storage needed");
 759         }
 760 #endif
 761         symbol_table = (asymbol **) stgMallocBytes(storage_needed,"DEBUG_LoadSymbols");
 762
 763         number_of_symbols = bfd_canonicalize_symtab (abfd, symbol_table);
 764
 765         if (number_of_symbols < 0) {
 766             barf("can't canonicalise symbol table");
 767         }
 768
 769         for( i = 0; i != number_of_symbols; ++i ) {
 770             symbol_info info;
 771             bfd_get_symbol_info(abfd,symbol_table[i],&info);
 772             /*fprintf(stderr,"\t%c\t0x%x      \t%s\n",info.type,(nat)info.value,info.name); */
 773             if (isReal(info.type, info.name)) {
 774                 num_real_syms += 1;
 775             }
 776         }
 777
 778         IF_DEBUG(evaluator,
 779                  fprintf(stderr,"Loaded %ld symbols. Of which %ld are real symbols\n",
 780                          number_of_symbols, num_real_syms)
 781                  );
 782
 783         reset_table( num_real_syms );
 784
 785         for( i = 0; i != number_of_symbols; ++i ) {
 786             symbol_info info;
 787             bfd_get_symbol_info(abfd,symbol_table[i],&info);
 788             if (isReal(info.type, info.name)) {
 789                 insert( info.value, info.name );
 790             }
 791         }
 792
 793         free(symbol_table);
 794     }
 795     prepare_table();
 796 }
 797
 798 #else /* HAVE_BFD_H */
 799
 800 extern void DEBUG_LoadSymbols( char *name )
 801 {
 802   /* nothing, yet */
 803 }
 804
 805 #endif /* HAVE_BFD_H */
 806
 807 #include "StoragePriv.h"
 808
 809 void
 810 findPtr(P_ p)
 811 {
 812   nat s, g;
 813   P_ q;
 814   bdescr *bd;
 815
 816   for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
 817     for (s = 0; s < generations[g].n_steps; s++) {
 818       for (bd = generations[g].steps[s].blocks; bd; bd = bd->link) {
 819         for (q = bd->start; q < bd->free; q++) {
 820           if (*q == (W_)p) {
 821             printf("%p\n", q);
 822           }
 823         }
 824       }
 825     }
 826   }
 827 }
 828
 829 #else /* DEBUG */
 830 void printPtr( StgPtr p )
 831 {
 832     fprintf(stderr, "ptr 0x%p (enable -DDEBUG for more info) " , p );
 833 }
 834
 835 void printObj( StgClosure *obj )
 836 {
 837     fprintf(stderr, "obj 0x%p (enable -DDEBUG for more info) " , obj );
 838 }
 839 #endif /* DEBUG */