gdb/symmisc.c

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