gdb/symmisc.c

   1 /* Do various things to symbol tables (other than lookup), for GDB.
   2    Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "bfd.h"
  24 #include "symfile.h"
  25 #include "objfiles.h"
  26 #include "breakpoint.h"
  27 #include "command.h"
  28 #include "obstack.h"
  29 #include "language.h"
  30
  31 #include <string.h>
  32
  33 #ifndef DEV_TTY
  34 #define DEV_TTY "/dev/tty"
  35 #endif
  36
  37 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
  38    when calling functions that take FILE *'s from the debugger.
  39    So we make a variable which has the same value and which is accessible when
  40    debugging GDB with itself.  Because stdin et al need not be constants,
  41    we initialize them in the _initialize_symmisc function at the bottom
  42    of the file.  */
  43 FILE *std_in;
  44 FILE *std_out;
  45 FILE *std_err;
  46
  47 /* Prototypes for local functions */
  48
  49 static void
  50 dump_symtab PARAMS ((struct objfile *, struct symtab *, FILE *));
  51
  52 static void
  53 dump_psymtab PARAMS ((struct objfile *, struct partial_symtab *, FILE *));
  54
  55 static void
  56 dump_msymbols PARAMS ((struct objfile *, FILE *));
  57
  58 static void
  59 dump_objfile PARAMS ((struct objfile *));
  60
  61 static int
  62 block_depth PARAMS ((struct block *));
  63
  64 static void
  65 print_partial_symbol PARAMS ((struct partial_symbol *, int, char *, FILE *));
  66
  67 struct print_symbol_args {
  68   struct symbol *symbol;
  69   int depth;
  70   FILE *outfile;
  71 };
  72
  73 static int print_symbol PARAMS ((char *));
  74
  75 static void
  76 free_symtab_block PARAMS ((struct objfile *, struct block *));
  77
  78 \f
  79 /* Free a struct block <- B and all the symbols defined in that block.  */
  80
  81 static void
  82 free_symtab_block (objfile, b)
  83      struct objfile *objfile;
  84      struct block *b;
  85 {
  86   register int i, n;
  87   n = BLOCK_NSYMS (b);
  88   for (i = 0; i < n; i++)
  89     {
  90       mfree (objfile -> md, SYMBOL_NAME (BLOCK_SYM (b, i)));
  91       mfree (objfile -> md, (PTR) BLOCK_SYM (b, i));
  92     }
  93   mfree (objfile -> md, (PTR) b);
  94 }
  95
  96 /* Free all the storage associated with the struct symtab <- S.
  97    Note that some symtabs have contents malloc'ed structure by structure,
  98    while some have contents that all live inside one big block of memory,
  99    and some share the contents of another symbol table and so you should
 100    not free the contents on their behalf (except sometimes the linetable,
 101    which maybe per symtab even when the rest is not).
 102    It is s->free_code that says which alternative to use.  */
 103
 104 void
 105 free_symtab (s)
 106      register struct symtab *s;
 107 {
 108   register int i, n;
 109   register struct blockvector *bv;
 110
 111   switch (s->free_code)
 112     {
 113     case free_nothing:
 114       /* All the contents are part of a big block of memory (an obstack),
 115          and some other symtab is in charge of freeing that block.
 116          Therefore, do nothing.  */
 117       break;
 118
 119     case free_contents:
 120       /* Here all the contents were malloc'ed structure by structure
 121          and must be freed that way.  */
 122       /* First free the blocks (and their symbols.  */
 123       bv = BLOCKVECTOR (s);
 124       n = BLOCKVECTOR_NBLOCKS (bv);
 125       for (i = 0; i < n; i++)
 126         free_symtab_block (s -> objfile, BLOCKVECTOR_BLOCK (bv, i));
 127       /* Free the blockvector itself.  */
 128       mfree (s -> objfile -> md, (PTR) bv);
 129       /* Also free the linetable.  */
 130
 131     case free_linetable:
 132       /* Everything will be freed either by our `free_ptr'
 133          or by some other symtab, except for our linetable.
 134          Free that now.  */
 135       if (LINETABLE (s))
 136         mfree (s -> objfile -> md, (PTR) LINETABLE (s));
 137       break;
 138     }
 139
 140   /* If there is a single block of memory to free, free it.  */
 141   if (s -> free_ptr != NULL)
 142     mfree (s -> objfile -> md, s -> free_ptr);
 143
 144   /* Free source-related stuff */
 145   if (s -> line_charpos != NULL)
 146     mfree (s -> objfile -> md, (PTR) s -> line_charpos);
 147   if (s -> fullname != NULL)
 148     mfree (s -> objfile -> md, s -> fullname);
 149   mfree (s -> objfile -> md, (PTR) s);
 150 }
 151
 152 #if MAINTENANCE_CMDS
 153
 154 static void
 155 dump_objfile (objfile)
 156      struct objfile *objfile;
 157 {
 158   struct symtab *symtab;
 159   struct partial_symtab *psymtab;
 160
 161   printf_filtered ("\nObject file %s:  ", objfile -> name);
 162   printf_filtered ("Objfile at %x, bfd at %x, %d minsyms\n\n",
 163                    objfile, objfile -> obfd, objfile->minimal_symbol_count);
 164
 165   if (objfile -> psymtabs)
 166     {
 167       printf_filtered ("Psymtabs:\n");
 168       for (psymtab = objfile -> psymtabs;
 169            psymtab != NULL;
 170            psymtab = psymtab -> next)
 171         {
 172           printf_filtered ("%s at %x, ", psymtab -> filename, psymtab);
 173           if (psymtab -> objfile != objfile)
 174             {
 175               printf_filtered ("NOT ON CHAIN!  ");
 176             }
 177           wrap_here ("  ");
 178         }
 179       printf_filtered ("\n\n");
 180     }
 181
 182   if (objfile -> symtabs)
 183     {
 184       printf_filtered ("Symtabs:\n");
 185       for (symtab = objfile -> symtabs;
 186            symtab != NULL;
 187            symtab = symtab->next)
 188         {
 189           printf_filtered ("%s at %x, ", symtab -> filename, symtab);
 190           if (symtab -> objfile != objfile)
 191             {
 192               printf_filtered ("NOT ON CHAIN!  ");
 193             }
 194           wrap_here ("  ");
 195         }
 196       printf_filtered ("\n\n");
 197     }
 198 }
 199
 200 /* Print minimal symbols from this objfile.  */
 201
 202 static void
 203 dump_msymbols (objfile, outfile)
 204      struct objfile *objfile;
 205      FILE *outfile;
 206 {
 207   struct minimal_symbol *msymbol;
 208   int index;
 209   char ms_type;
 210
 211   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile -> name);
 212   if (objfile -> minimal_symbol_count == 0)
 213     {
 214       fprintf_filtered (outfile, "No minimal symbols found.\n");
 215       return;
 216     }
 217   for (index = 0, msymbol = objfile -> msymbols;
 218        SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
 219     {
 220       switch (msymbol -> type)
 221         {
 222           case mst_unknown:
 223             ms_type = 'u';
 224             break;
 225           case mst_text:
 226             ms_type = 'T';
 227             break;
 228           case mst_data:
 229             ms_type = 'D';
 230             break;
 231           case mst_bss:
 232             ms_type = 'B';
 233             break;
 234           case mst_abs:
 235             ms_type = 'A';
 236             break;
 237           case mst_file_text:
 238             ms_type = 't';
 239             break;
 240           case mst_file_data:
 241             ms_type = 'd';
 242             break;
 243           case mst_file_bss:
 244             ms_type = 'b';
 245             break;
 246           default:
 247             ms_type = '?';
 248             break;
 249         }
 250       fprintf_filtered (outfile, "[%2d] %c %#10x %s", index, ms_type,
 251                         SYMBOL_VALUE_ADDRESS (msymbol), SYMBOL_NAME (msymbol));
 252       if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 253         {
 254           fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
 255         }
 256       fputs_filtered ("\n", outfile);
 257     }
 258   if (objfile -> minimal_symbol_count != index)
 259     {
 260       warning ("internal error:  minimal symbol count %d != %d",
 261                objfile -> minimal_symbol_count, index);
 262     }
 263   fprintf_filtered (outfile, "\n");
 264 }
 265
 266 static void
 267 dump_psymtab (objfile, psymtab, outfile)
 268      struct objfile *objfile;
 269      struct partial_symtab *psymtab;
 270      FILE *outfile;
 271 {
 272   int i;
 273
 274   fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
 275                     psymtab -> filename);
 276   fprintf_filtered (outfile, "(object 0x%x)\n\n", psymtab);
 277   fprintf (outfile, "  Read from object file %s (0x%x)\n",
 278            objfile -> name, (unsigned int) objfile);
 279
 280   if (psymtab -> readin)
 281     {
 282       fprintf_filtered (outfile,
 283                 "  Full symtab was read (at 0x%x by function at 0x%x)\n",
 284                         psymtab -> symtab, psymtab -> read_symtab);
 285     }
 286
 287   /* FIXME, we need to be able to print the relocation stuff. */
 288   /* This prints some garbage for anything but stabs right now.  FIXME.  */
 289   if (psymtab->section_offsets)
 290     fprintf_filtered (outfile, "  Relocate symbols by 0x%x, 0x%x, 0x%x, 0x%x.\n",
 291                       ANOFFSET (psymtab->section_offsets, 0),
 292                       ANOFFSET (psymtab->section_offsets, 1),
 293                       ANOFFSET (psymtab->section_offsets, 2),
 294                       ANOFFSET (psymtab->section_offsets, 3));
 295
 296   fprintf_filtered (outfile, "  Symbols cover text addresses 0x%x-0x%x\n",
 297                     psymtab -> textlow, psymtab -> texthigh);
 298   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
 299                     psymtab -> number_of_dependencies);
 300   for (i = 0; i < psymtab -> number_of_dependencies; i++)
 301     {
 302       fprintf_filtered (outfile, "    %d 0x%lx %s\n", i,
 303                         (unsigned long) psymtab -> dependencies[i],
 304                         psymtab -> dependencies[i] -> filename);
 305     }
 306   if (psymtab -> n_global_syms > 0)
 307     {
 308       print_partial_symbol (objfile -> global_psymbols.list
 309                             + psymtab -> globals_offset,
 310                             psymtab -> n_global_syms, "Global", outfile);
 311     }
 312   if (psymtab -> n_static_syms > 0)
 313     {
 314       print_partial_symbol (objfile -> static_psymbols.list
 315                             + psymtab -> statics_offset,
 316                             psymtab -> n_static_syms, "Static", outfile);
 317     }
 318   fprintf_filtered (outfile, "\n");
 319 }
 320
 321 static void
 322 dump_symtab (objfile, symtab, outfile)
 323      struct objfile *objfile;
 324      struct symtab *symtab;
 325      FILE *outfile;
 326 {
 327   register int i, j;
 328   int len, blen;
 329   register struct linetable *l;
 330   struct blockvector *bv;
 331   register struct block *b;
 332   int depth;
 333
 334   fprintf (outfile, "\nSymtab for file %s\n", symtab->filename);
 335   fprintf (outfile, "Read from object file %s (%x)\n", objfile->name,
 336            (unsigned int) objfile);
 337   fprintf (outfile, "Language: %s\n", language_str (symtab -> language));
 338
 339   /* First print the line table.  */
 340   l = LINETABLE (symtab);
 341   if (l) {
 342     fprintf (outfile, "\nLine table:\n\n");
 343     len = l->nitems;
 344     for (i = 0; i < len; i++)
 345       fprintf (outfile, " line %d at %x\n", l->item[i].line,
 346                l->item[i].pc);
 347   }
 348   /* Now print the block info.  */
 349   fprintf (outfile, "\nBlockvector:\n\n");
 350   bv = BLOCKVECTOR (symtab);
 351   len = BLOCKVECTOR_NBLOCKS (bv);
 352   for (i = 0; i < len; i++)
 353     {
 354       b = BLOCKVECTOR_BLOCK (bv, i);
 355       depth = block_depth (b) * 2;
 356       print_spaces (depth, outfile);
 357       fprintf (outfile, "block #%03d (object 0x%x) ", i, (unsigned int) b);
 358       fprintf (outfile, "[0x%x..0x%x]", BLOCK_START (b), BLOCK_END (b));
 359       if (BLOCK_SUPERBLOCK (b))
 360         fprintf (outfile, " (under 0x%x)", (unsigned int) BLOCK_SUPERBLOCK (b));
 361       if (BLOCK_FUNCTION (b))
 362         {
 363           fprintf (outfile, " %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
 364           if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 365             {
 366               fprintf (outfile, " %s",
 367                        SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 368             }
 369         }
 370       if (BLOCK_GCC_COMPILED(b))
 371         fprintf (outfile, " gcc%d compiled", BLOCK_GCC_COMPILED(b));
 372       fputc ('\n', outfile);
 373       blen = BLOCK_NSYMS (b);
 374       for (j = 0; j < blen; j++)
 375         {
 376           struct print_symbol_args s;
 377           s.symbol = BLOCK_SYM (b, j);
 378           s.depth = depth + 1;
 379           s.outfile = outfile;
 380           catch_errors (print_symbol, &s, "Error printing symbol:\n",
 381                         RETURN_MASK_ERROR);
 382         }
 383     }
 384   fprintf (outfile, "\n");
 385 }
 386
 387 void
 388 maintenance_print_symbols (args, from_tty)
 389      char *args;
 390      int from_tty;
 391 {
 392   char **argv;
 393   FILE *outfile;
 394   struct cleanup *cleanups;
 395   char *symname = NULL;
 396   char *filename = DEV_TTY;
 397   struct objfile *objfile;
 398   struct symtab *s;
 399
 400   dont_repeat ();
 401
 402   if (args == NULL)
 403     {
 404       error ("print-symbols takes an output file name and optional symbol file name");
 405     }
 406   else if ((argv = buildargv (args)) == NULL)
 407     {
 408       nomem (0);
 409     }
 410   cleanups = make_cleanup (freeargv, (char *) argv);
 411
 412   if (argv[0] != NULL)
 413     {
 414       filename = argv[0];
 415       /* If a second arg is supplied, it is a source file name to match on */
 416       if (argv[1] != NULL)
 417         {
 418           symname = argv[1];
 419         }
 420     }
 421
 422   filename = tilde_expand (filename);
 423   make_cleanup (free, filename);
 424
 425   outfile = fopen (filename, FOPEN_WT);
 426   if (outfile == 0)
 427     perror_with_name (filename);
 428   make_cleanup (fclose, (char *) outfile);
 429
 430   immediate_quit++;
 431   ALL_SYMTABS (objfile, s)
 432     if (symname == NULL || (STREQ (symname, s -> filename)))
 433       dump_symtab (objfile, s, outfile);
 434   immediate_quit--;
 435   do_cleanups (cleanups);
 436 }
 437
 438 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 439    far to indent.  ARGS is really a struct print_symbol_args *, but is
 440    declared as char * to get it past catch_errors.  */
 441
 442 static int
 443 print_symbol (args)
 444      char *args;
 445 {
 446   struct symbol *symbol = ((struct print_symbol_args *)args)->symbol;
 447   int depth = ((struct print_symbol_args *)args)->depth;
 448   FILE *outfile = ((struct print_symbol_args *)args)->outfile;
 449
 450   print_spaces (depth, outfile);
 451   if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
 452     {
 453       fprintf (outfile, "label %s at 0x%x\n", SYMBOL_SOURCE_NAME (symbol),
 454                SYMBOL_VALUE_ADDRESS (symbol));
 455       return;
 456     }
 457   if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
 458     {
 459       if (TYPE_NAME (SYMBOL_TYPE (symbol)))
 460         {
 461           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 462         }
 463       else
 464         {
 465           fprintf (outfile, "%s %s = ",
 466                (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 467                 ? "enum"
 468                 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 469                    ? "struct" : "union")),
 470                SYMBOL_NAME (symbol));
 471           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 472         }
 473       fprintf (outfile, ";\n");
 474     }
 475   else
 476     {
 477       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 478         fprintf (outfile, "typedef ");
 479       if (SYMBOL_TYPE (symbol))
 480         {
 481           /* Print details of types, except for enums where it's clutter.  */
 482           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_SOURCE_NAME (symbol),
 483                          outfile,
 484                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 485                          depth);
 486           fprintf (outfile, "; ");
 487         }
 488       else
 489         fprintf (outfile, "%s ", SYMBOL_SOURCE_NAME (symbol));
 490
 491       switch (SYMBOL_CLASS (symbol))
 492         {
 493         case LOC_CONST:
 494           fprintf (outfile, "const %ld (0x%lx),",
 495                    SYMBOL_VALUE (symbol), SYMBOL_VALUE (symbol));
 496           break;
 497
 498         case LOC_CONST_BYTES:
 499           fprintf (outfile, "const %u hex bytes:",
 500                    TYPE_LENGTH (SYMBOL_TYPE (symbol)));
 501           {
 502             unsigned i;
 503             for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (symbol)); i++)
 504               fprintf (outfile, " %2x",
 505                          (unsigned)SYMBOL_VALUE_BYTES (symbol) [i]);
 506             fprintf (outfile, ",");
 507           }
 508           break;
 509
 510         case LOC_STATIC:
 511           fprintf (outfile, "static at 0x%x,", SYMBOL_VALUE_ADDRESS (symbol));
 512           break;
 513
 514         case LOC_REGISTER:
 515           fprintf (outfile, "register %ld,", SYMBOL_VALUE (symbol));
 516           break;
 517
 518         case LOC_ARG:
 519           fprintf (outfile, "arg at 0x%lx,", SYMBOL_VALUE (symbol));
 520           break;
 521
 522         case LOC_LOCAL_ARG:
 523           fprintf (outfile, "arg at offset 0x%lx from fp,",
 524                    SYMBOL_VALUE (symbol));
 525           break;
 526
 527         case LOC_REF_ARG:
 528           fprintf (outfile, "reference arg at 0x%lx,", SYMBOL_VALUE (symbol));
 529           break;
 530
 531         case LOC_REGPARM:
 532           fprintf (outfile, "parameter register %ld,", SYMBOL_VALUE (symbol));
 533           break;
 534
 535         case LOC_REGPARM_ADDR:
 536           fprintf (outfile, "address parameter register %ld,", SYMBOL_VALUE (symbol));
 537           break;
 538
 539         case LOC_LOCAL:
 540           fprintf (outfile, "local at 0x%lx,", SYMBOL_VALUE (symbol));
 541           break;
 542
 543         case LOC_BASEREG:
 544           fprintf (outfile, "local at 0x%lx from register %d",
 545                    SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
 546           break;
 547
 548         case LOC_BASEREG_ARG:
 549           fprintf (outfile, "arg at 0x%lx from register %d,",
 550                    SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
 551           break;
 552
 553         case LOC_TYPEDEF:
 554           break;
 555
 556         case LOC_LABEL:
 557           fprintf (outfile, "label at 0x%lx", SYMBOL_VALUE_ADDRESS (symbol));
 558           break;
 559
 560         case LOC_BLOCK:
 561           fprintf (outfile, "block (object 0x%x) starting at 0x%x,",
 562                    (unsigned int) SYMBOL_BLOCK_VALUE (symbol),
 563                    BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)));
 564           break;
 565
 566         case LOC_OPTIMIZED_OUT:
 567           fprintf (outfile, "optimized out");
 568           break;
 569
 570         default:
 571           fprintf (outfile, "botched symbol class %x", SYMBOL_CLASS (symbol));
 572           break;
 573         }
 574     }
 575   fprintf (outfile, "\n");
 576 }
 577
 578 void
 579 maintenance_print_psymbols (args, from_tty)
 580      char *args;
 581      int from_tty;
 582 {
 583   char **argv;
 584   FILE *outfile;
 585   struct cleanup *cleanups;
 586   char *symname = NULL;
 587   char *filename = DEV_TTY;
 588   struct objfile *objfile;
 589   struct partial_symtab *ps;
 590
 591   dont_repeat ();
 592
 593   if (args == NULL)
 594     {
 595       error ("print-psymbols takes an output file name and optional symbol file name");
 596     }
 597   else if ((argv = buildargv (args)) == NULL)
 598     {
 599       nomem (0);
 600     }
 601   cleanups = make_cleanup (freeargv, (char *) argv);
 602
 603   if (argv[0] != NULL)
 604     {
 605       filename = argv[0];
 606       /* If a second arg is supplied, it is a source file name to match on */
 607       if (argv[1] != NULL)
 608         {
 609           symname = argv[1];
 610         }
 611     }
 612
 613   filename = tilde_expand (filename);
 614   make_cleanup (free, filename);
 615
 616   outfile = fopen (filename, FOPEN_WT);
 617   if (outfile == 0)
 618     perror_with_name (filename);
 619   make_cleanup (fclose, outfile);
 620
 621   immediate_quit++;
 622   ALL_PSYMTABS (objfile, ps)
 623     if (symname == NULL || (STREQ (symname, ps -> filename)))
 624       dump_psymtab (objfile, ps, outfile);
 625   immediate_quit--;
 626   do_cleanups (cleanups);
 627 }
 628
 629 static void
 630 print_partial_symbol (p, count, what, outfile)
 631      struct partial_symbol *p;
 632      int count;
 633      char *what;
 634      FILE *outfile;
 635 {
 636
 637   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
 638   while (count-- > 0)
 639     {
 640       fprintf_filtered (outfile, "    `%s'", SYMBOL_NAME(p));
 641       if (SYMBOL_DEMANGLED_NAME (p) != NULL)
 642         {
 643           fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (p));
 644         }
 645       fputs_filtered (", ", outfile);
 646       switch (SYMBOL_NAMESPACE (p))
 647         {
 648         case UNDEF_NAMESPACE:
 649           fputs_filtered ("undefined namespace, ", outfile);
 650           break;
 651         case VAR_NAMESPACE:
 652           /* This is the usual thing -- don't print it */
 653           break;
 654         case STRUCT_NAMESPACE:
 655           fputs_filtered ("struct namespace, ", outfile);
 656           break;
 657         case LABEL_NAMESPACE:
 658           fputs_filtered ("label namespace, ", outfile);
 659           break;
 660         default:
 661           fputs_filtered ("<invalid namespace>, ", outfile);
 662           break;
 663         }
 664       switch (SYMBOL_CLASS (p))
 665         {
 666         case LOC_UNDEF:
 667           fputs_filtered ("undefined", outfile);
 668           break;
 669         case LOC_CONST:
 670           fputs_filtered ("constant int", outfile);
 671           break;
 672         case LOC_STATIC:
 673           fputs_filtered ("static", outfile);
 674           break;
 675         case LOC_REGISTER:
 676           fputs_filtered ("register", outfile);
 677           break;
 678         case LOC_ARG:
 679           fputs_filtered ("pass by value", outfile);
 680           break;
 681         case LOC_REF_ARG:
 682           fputs_filtered ("pass by reference", outfile);
 683           break;
 684         case LOC_REGPARM:
 685           fputs_filtered ("register parameter", outfile);
 686           break;
 687         case LOC_REGPARM_ADDR:
 688           fputs_filtered ("register address parameter", outfile);
 689           break;
 690         case LOC_LOCAL:
 691           fputs_filtered ("stack parameter", outfile);
 692           break;
 693         case LOC_TYPEDEF:
 694           fputs_filtered ("type", outfile);
 695           break;
 696         case LOC_LABEL:
 697           fputs_filtered ("label", outfile);
 698           break;
 699         case LOC_BLOCK:
 700           fputs_filtered ("function", outfile);
 701           break;
 702         case LOC_CONST_BYTES:
 703           fputs_filtered ("constant bytes", outfile);
 704           break;
 705         case LOC_LOCAL_ARG:
 706           fputs_filtered ("shuffled arg", outfile);
 707           break;
 708         case LOC_OPTIMIZED_OUT:
 709           fputs_filtered ("optimized out", outfile);
 710           break;
 711         default:
 712           fputs_filtered ("<invalid location>", outfile);
 713           break;
 714         }
 715       fputs_filtered (", ", outfile);
 716       fprintf_filtered (outfile, "0x%x\n", SYMBOL_VALUE (p));
 717       p++;
 718     }
 719 }
 720
 721 void
 722 maintenance_print_msymbols (args, from_tty)
 723      char *args;
 724      int from_tty;
 725 {
 726   char **argv;
 727   FILE *outfile;
 728   struct cleanup *cleanups;
 729   char *filename = DEV_TTY;
 730   char *symname = NULL;
 731   struct objfile *objfile;
 732
 733   dont_repeat ();
 734
 735   if (args == NULL)
 736     {
 737       error ("print-msymbols takes an output file name and optional symbol file name");
 738     }
 739   else if ((argv = buildargv (args)) == NULL)
 740     {
 741       nomem (0);
 742     }
 743   cleanups = make_cleanup (freeargv, argv);
 744
 745   if (argv[0] != NULL)
 746     {
 747       filename = argv[0];
 748       /* If a second arg is supplied, it is a source file name to match on */
 749       if (argv[1] != NULL)
 750         {
 751           symname = argv[1];
 752         }
 753     }
 754
 755   filename = tilde_expand (filename);
 756   make_cleanup (free, filename);
 757
 758   outfile = fopen (filename, FOPEN_WT);
 759   if (outfile == 0)
 760     perror_with_name (filename);
 761   make_cleanup (fclose, outfile);
 762
 763   immediate_quit++;
 764   ALL_OBJFILES (objfile)
 765     if (symname == NULL || (STREQ (symname, objfile -> name)))
 766       dump_msymbols (objfile, outfile);
 767   immediate_quit--;
 768   fprintf_filtered (outfile, "\n\n");
 769   do_cleanups (cleanups);
 770 }
 771
 772 void
 773 maintenance_print_objfiles (ignore, from_tty)
 774      char *ignore;
 775      int from_tty;
 776 {
 777   struct objfile *objfile;
 778
 779   dont_repeat ();
 780
 781   immediate_quit++;
 782   ALL_OBJFILES (objfile)
 783     dump_objfile (objfile);
 784   immediate_quit--;
 785 }
 786
 787 \f
 788 /* Return the nexting depth of a block within other blocks in its symtab.  */
 789
 790 static int
 791 block_depth (block)
 792      struct block *block;
 793 {
 794   register int i = 0;
 795   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 796     {
 797       i++;
 798     }
 799   return i;
 800 }
 801
 802 #endif  /* MAINTENANCE_CMDS */
 803
 804 \f
 805 /* Increase the space allocated for LISTP, which is probably
 806    global_psymbol_list or static_psymbol_list. This space will eventually
 807    be freed in free_objfile().  */
 808
 809 void
 810 extend_psymbol_list (listp, objfile)
 811      register struct psymbol_allocation_list *listp;
 812      struct objfile *objfile;
 813 {
 814   int new_size;
 815   if (listp->size == 0)
 816     {
 817       new_size = 255;
 818       listp->list = (struct partial_symbol *)
 819         xmmalloc (objfile -> md, new_size * sizeof (struct partial_symbol));
 820     }
 821   else
 822     {
 823       new_size = listp->size * 2;
 824       listp->list = (struct partial_symbol *)
 825         xmrealloc (objfile -> md, (char *) listp->list,
 826                    new_size * sizeof (struct partial_symbol));
 827     }
 828   /* Next assumes we only went one over.  Should be good if
 829      program works correctly */
 830   listp->next = listp->list + listp->size;
 831   listp->size = new_size;
 832 }
 833
 834
 835 /* Do early runtime initializations. */
 836 void
 837 _initialize_symmisc ()
 838 {
 839   std_in  = stdin;
 840   std_out = stdout;
 841   std_err = stderr;
 842 }