ghc/rts/Printer.c

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