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 *, GDB_FILE *));
  51
  52 static void
  53 dump_psymtab PARAMS ((struct objfile *, struct partial_symtab *, GDB_FILE *));
  54
  55 static void
  56 dump_msymbols PARAMS ((struct objfile *, GDB_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 *, GDB_FILE *));
  66
  67 struct print_symbol_args {
  68   struct symbol *symbol;
  69   int depth;
  70   GDB_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 ");
 163   gdb_print_address (objfile, gdb_stdout);
 164   printf_filtered (", bfd at ");
 165   gdb_print_address (objfile->obfd, gdb_stdout);
 166   printf_filtered (", %d minsyms\n\n",
 167                    objfile->minimal_symbol_count);
 168
 169   if (objfile -> psymtabs)
 170     {
 171       printf_filtered ("Psymtabs:\n");
 172       for (psymtab = objfile -> psymtabs;
 173            psymtab != NULL;
 174            psymtab = psymtab -> next)
 175         {
 176           printf_filtered ("%s at ",
 177                            psymtab -> filename);
 178           gdb_print_address (psymtab);
 179           printf_filtered (", ");
 180           if (psymtab -> objfile != objfile)
 181             {
 182               printf_filtered ("NOT ON CHAIN!  ");
 183             }
 184           wrap_here ("  ");
 185         }
 186       printf_filtered ("\n\n");
 187     }
 188
 189   if (objfile -> symtabs)
 190     {
 191       printf_filtered ("Symtabs:\n");
 192       for (symtab = objfile -> symtabs;
 193            symtab != NULL;
 194            symtab = symtab->next)
 195         {
 196           printf_filtered ("%s at ", symtab -> filename);
 197           gdb_print_address (symtab);
 198           printf_filtered (", ");
 199           if (symtab -> objfile != objfile)
 200             {
 201               printf_filtered ("NOT ON CHAIN!  ");
 202             }
 203           wrap_here ("  ");
 204         }
 205       printf_filtered ("\n\n");
 206     }
 207 }
 208
 209 /* Print minimal symbols from this objfile.  */
 210
 211 static void
 212 dump_msymbols (objfile, outfile)
 213      struct objfile *objfile;
 214      GDB_FILE *outfile;
 215 {
 216   struct minimal_symbol *msymbol;
 217   int index;
 218   char ms_type;
 219
 220   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile -> name);
 221   if (objfile -> minimal_symbol_count == 0)
 222     {
 223       fprintf_filtered (outfile, "No minimal symbols found.\n");
 224       return;
 225     }
 226   for (index = 0, msymbol = objfile -> msymbols;
 227        SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
 228     {
 229       switch (msymbol -> type)
 230         {
 231           case mst_unknown:
 232             ms_type = 'u';
 233             break;
 234           case mst_text:
 235             ms_type = 'T';
 236             break;
 237           case mst_data:
 238             ms_type = 'D';
 239             break;
 240           case mst_bss:
 241             ms_type = 'B';
 242             break;
 243           case mst_abs:
 244             ms_type = 'A';
 245             break;
 246           case mst_file_text:
 247             ms_type = 't';
 248             break;
 249           case mst_file_data:
 250             ms_type = 'd';
 251             break;
 252           case mst_file_bss:
 253             ms_type = 'b';
 254             break;
 255           default:
 256             ms_type = '?';
 257             break;
 258         }
 259       fprintf_filtered (outfile, "[%2d] %c %#10lx %s", index, ms_type,
 260                         SYMBOL_VALUE_ADDRESS (msymbol), SYMBOL_NAME (msymbol));
 261       if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 262         {
 263           fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
 264         }
 265       fputs_filtered ("\n", outfile);
 266     }
 267   if (objfile -> minimal_symbol_count != index)
 268     {
 269       warning ("internal error:  minimal symbol count %d != %d",
 270                objfile -> minimal_symbol_count, index);
 271     }
 272   fprintf_filtered (outfile, "\n");
 273 }
 274
 275 static void
 276 dump_psymtab (objfile, psymtab, outfile)
 277      struct objfile *objfile;
 278      struct partial_symtab *psymtab;
 279      GDB_FILE *outfile;
 280 {
 281   int i;
 282
 283   fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
 284                     psymtab -> filename);
 285   fprintf_filtered (outfile, "(object )");
 286   gdb_print_address (psymtab, outfile);
 287   fprintf_filtered (outfile, ")\n\n");
 288   fprintf_unfiltered (outfile, "  Read from object file %s (",
 289                       objfile -> name);
 290   gdb_print_address (objfile, outfile);
 291   fprintf_unfiltered (outfile, ")\n");
 292
 293   if (psymtab -> readin)
 294     {
 295       fprintf_filtered (outfile,
 296                 "  Full symtab was read (at ");
 297       gdb_print_address (psymtab->symtab, outfile);
 298       fprintf_filtered (outfile, " by function at ");
 299       gdb_print_address (psymtab->read_symtab, outfile);
 300       fprintf_filtered (outfile, ")\n");
 301     }
 302
 303   fprintf_filtered (outfile, "  Relocate symbols by ");
 304   for (i = 0; i < psymtab->objfile->num_sections; ++i)
 305     {
 306       wrap_here ("    ");
 307       print_address_numeric (ANOFFSET (psymtab->section_offsets, i), outfile);
 308       fprintf_filtered (outfile, ", ");
 309     }
 310
 311   fprintf_filtered (outfile, "  Symbols cover text addresses ");
 312   print_address_numeric (psymtab->textlow, outfile);
 313   fprintf_filtered (outfile, "-");
 314   print_address_numeric (psymtab->texthigh, outfile);
 315   fprintf_filtered (outfile, "\n");
 316   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
 317                     psymtab -> number_of_dependencies);
 318   for (i = 0; i < psymtab -> number_of_dependencies; i++)
 319     {
 320       fprintf_filtered (outfile, "    %d ", i);
 321       gdb_print_address (psymtab -> dependencies[i], outfile);
 322       fprintf_filtered (outfile, " %s\n",
 323                         psymtab -> dependencies[i] -> filename);
 324     }
 325   if (psymtab -> n_global_syms > 0)
 326     {
 327       print_partial_symbol (objfile -> global_psymbols.list
 328                             + psymtab -> globals_offset,
 329                             psymtab -> n_global_syms, "Global", outfile);
 330     }
 331   if (psymtab -> n_static_syms > 0)
 332     {
 333       print_partial_symbol (objfile -> static_psymbols.list
 334                             + psymtab -> statics_offset,
 335                             psymtab -> n_static_syms, "Static", outfile);
 336     }
 337   fprintf_filtered (outfile, "\n");
 338 }
 339
 340 static void
 341 dump_symtab (objfile, symtab, outfile)
 342      struct objfile *objfile;
 343      struct symtab *symtab;
 344      GDB_FILE *outfile;
 345 {
 346   register int i, j;
 347   int len, blen;
 348   register struct linetable *l;
 349   struct blockvector *bv;
 350   register struct block *b;
 351   int depth;
 352
 353   fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
 354   fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
 355   gdb_print_address (objfile, outfile);
 356   fprintf_filtered (outfile, ")\n");
 357   fprintf_filtered (outfile, "Language: %s\n", language_str (symtab -> language));
 358
 359   /* First print the line table.  */
 360   l = LINETABLE (symtab);
 361   if (l)
 362     {
 363       fprintf_filtered (outfile, "\nLine table:\n\n");
 364       len = l->nitems;
 365       for (i = 0; i < len; i++)
 366         {
 367           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
 368           print_address_numeric (l->item[i].pc, outfile);
 369           fprintf_filtered (outfile, "\n");
 370         }
 371     }
 372   /* Now print the block info.  */
 373   fprintf_filtered (outfile, "\nBlockvector:\n\n");
 374   bv = BLOCKVECTOR (symtab);
 375   len = BLOCKVECTOR_NBLOCKS (bv);
 376   for (i = 0; i < len; i++)
 377     {
 378       b = BLOCKVECTOR_BLOCK (bv, i);
 379       depth = block_depth (b) * 2;
 380       print_spaces (depth, outfile);
 381       fprintf_filtered (outfile, "block #%03d (object ", i);
 382       gdb_print_address (b, outfile);
 383       fprintf_filtered (outfile, ") ");
 384       fprintf_filtered (outfile, "[");
 385       print_address_numeric (BLOCK_START (b), outfile);
 386       fprintf_filtered (outfile, "..");
 387       print_address_numeric (BLOCK_END (b), outfile);
 388       fprintf_filtered (outfile, "]");
 389       if (BLOCK_SUPERBLOCK (b))
 390         {
 391           fprintf_filtered (outfile, " (under ");
 392           gdb_print_address (BLOCK_SUPERBLOCK (b), outfile);
 393           fprintf_filtered (outfile, ")");
 394         }
 395       if (BLOCK_FUNCTION (b))
 396         {
 397           fprintf_filtered (outfile, " %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
 398           if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 399             {
 400               fprintf_filtered (outfile, " %s",
 401                        SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 402             }
 403         }
 404       if (BLOCK_GCC_COMPILED(b))
 405         fprintf_filtered (outfile, " gcc%d compiled", BLOCK_GCC_COMPILED(b));
 406       fputc_filtered ('\n', outfile);
 407       blen = BLOCK_NSYMS (b);
 408       for (j = 0; j < blen; j++)
 409         {
 410           struct print_symbol_args s;
 411           s.symbol = BLOCK_SYM (b, j);
 412           s.depth = depth + 1;
 413           s.outfile = outfile;
 414           catch_errors (print_symbol, &s, "Error printing symbol:\n",
 415                         RETURN_MASK_ERROR);
 416         }
 417     }
 418   fprintf_filtered (outfile, "\n");
 419 }
 420
 421 void
 422 maintenance_print_symbols (args, from_tty)
 423      char *args;
 424      int from_tty;
 425 {
 426   char **argv;
 427   GDB_FILE *outfile;
 428   struct cleanup *cleanups;
 429   char *symname = NULL;
 430   char *filename = DEV_TTY;
 431   struct objfile *objfile;
 432   struct symtab *s;
 433
 434   dont_repeat ();
 435
 436   if (args == NULL)
 437     {
 438       error ("print-symbols takes an output file name and optional symbol file name");
 439     }
 440   else if ((argv = buildargv (args)) == NULL)
 441     {
 442       nomem (0);
 443     }
 444   cleanups = make_cleanup (freeargv, (char *) argv);
 445
 446   if (argv[0] != NULL)
 447     {
 448       filename = argv[0];
 449       /* If a second arg is supplied, it is a source file name to match on */
 450       if (argv[1] != NULL)
 451         {
 452           symname = argv[1];
 453         }
 454     }
 455
 456   filename = tilde_expand (filename);
 457   make_cleanup (free, filename);
 458
 459   outfile = gdb_fopen (filename, FOPEN_WT);
 460   if (outfile == 0)
 461     perror_with_name (filename);
 462   make_cleanup (fclose, (char *) outfile);
 463
 464   immediate_quit++;
 465   ALL_SYMTABS (objfile, s)
 466     if (symname == NULL || (STREQ (symname, s -> filename)))
 467       dump_symtab (objfile, s, outfile);
 468   immediate_quit--;
 469   do_cleanups (cleanups);
 470 }
 471
 472 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 473    far to indent.  ARGS is really a struct print_symbol_args *, but is
 474    declared as char * to get it past catch_errors.  Returns 0 for error,
 475    1 for success.  */
 476
 477 static int
 478 print_symbol (args)
 479      char *args;
 480 {
 481   struct symbol *symbol = ((struct print_symbol_args *)args)->symbol;
 482   int depth = ((struct print_symbol_args *)args)->depth;
 483   GDB_FILE *outfile = ((struct print_symbol_args *)args)->outfile;
 484
 485   print_spaces (depth, outfile);
 486   if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
 487     {
 488       fprintf_filtered (outfile, "label %s at ", SYMBOL_SOURCE_NAME (symbol));
 489       print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), outfile);
 490       fprintf_filtered (outfile, "\n");
 491       return 1;
 492     }
 493   if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
 494     {
 495       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 496         {
 497           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 498         }
 499       else
 500         {
 501           fprintf_filtered (outfile, "%s %s = ",
 502                (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 503                 ? "enum"
 504                 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 505                    ? "struct" : "union")),
 506                SYMBOL_NAME (symbol));
 507           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 508         }
 509       fprintf_filtered (outfile, ";\n");
 510     }
 511   else
 512     {
 513       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 514         fprintf_filtered (outfile, "typedef ");
 515       if (SYMBOL_TYPE (symbol))
 516         {
 517           /* Print details of types, except for enums where it's clutter.  */
 518           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_SOURCE_NAME (symbol),
 519                          outfile,
 520                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 521                          depth);
 522           fprintf_filtered (outfile, "; ");
 523         }
 524       else
 525         fprintf_filtered (outfile, "%s ", SYMBOL_SOURCE_NAME (symbol));
 526
 527       switch (SYMBOL_CLASS (symbol))
 528         {
 529         case LOC_CONST:
 530           fprintf_filtered (outfile, "const %ld (0x%lx),",
 531                             SYMBOL_VALUE (symbol),
 532                             SYMBOL_VALUE (symbol));
 533           break;
 534
 535         case LOC_CONST_BYTES:
 536           fprintf_filtered (outfile, "const %u hex bytes:",
 537                    TYPE_LENGTH (SYMBOL_TYPE (symbol)));
 538           {
 539             unsigned i;
 540             for (i = 0; i < TYPE_LENGTH (SYMBOL_TYPE (symbol)); i++)
 541               fprintf_filtered (outfile, " %02x",
 542                          (unsigned)SYMBOL_VALUE_BYTES (symbol) [i]);
 543             fprintf_filtered (outfile, ",");
 544           }
 545           break;
 546
 547         case LOC_STATIC:
 548           fprintf_filtered (outfile, "static at ");
 549           print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), outfile);
 550           fprintf_filtered (outfile, ",");
 551           break;
 552
 553         case LOC_REGISTER:
 554           fprintf_filtered (outfile, "register %ld,", SYMBOL_VALUE (symbol));
 555           break;
 556
 557         case LOC_ARG:
 558           fprintf_filtered (outfile, "arg at offset 0x%lx,",
 559                             SYMBOL_VALUE (symbol));
 560           break;
 561
 562         case LOC_LOCAL_ARG:
 563           fprintf_filtered (outfile, "arg at offset 0x%lx from fp,",
 564                    SYMBOL_VALUE (symbol));
 565           break;
 566
 567         case LOC_REF_ARG:
 568           fprintf_filtered (outfile, "reference arg at 0x%lx,", SYMBOL_VALUE (symbol));
 569           break;
 570
 571         case LOC_REGPARM:
 572           fprintf_filtered (outfile, "parameter register %ld,", SYMBOL_VALUE (symbol));
 573           break;
 574
 575         case LOC_REGPARM_ADDR:
 576           fprintf_filtered (outfile, "address parameter register %ld,", SYMBOL_VALUE (symbol));
 577           break;
 578
 579         case LOC_LOCAL:
 580           fprintf_filtered (outfile, "local at offset 0x%lx,",
 581                             SYMBOL_VALUE (symbol));
 582           break;
 583
 584         case LOC_BASEREG:
 585           fprintf_filtered (outfile, "local at 0x%lx from register %d",
 586                    SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
 587           break;
 588
 589         case LOC_BASEREG_ARG:
 590           fprintf_filtered (outfile, "arg at 0x%lx from register %d,",
 591                    SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
 592           break;
 593
 594         case LOC_TYPEDEF:
 595           break;
 596
 597         case LOC_LABEL:
 598           fprintf_filtered (outfile, "label at ");
 599           print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), outfile);
 600           break;
 601
 602         case LOC_BLOCK:
 603           fprintf_filtered (outfile, "block (object ");
 604           gdb_print_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 605           fprintf_filtered (outfile, ") starting at ");
 606           print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
 607                                  outfile);
 608           fprintf_filtered (outfile, ",");
 609           break;
 610
 611         case LOC_OPTIMIZED_OUT:
 612           fprintf_filtered (outfile, "optimized out");
 613           break;
 614
 615         default:
 616           fprintf_filtered (outfile, "botched symbol class %x",
 617                             SYMBOL_CLASS (symbol));
 618           break;
 619         }
 620     }
 621   fprintf_filtered (outfile, "\n");
 622   return 1;
 623 }
 624
 625 void
 626 maintenance_print_psymbols (args, from_tty)
 627      char *args;
 628      int from_tty;
 629 {
 630   char **argv;
 631   GDB_FILE *outfile;
 632   struct cleanup *cleanups;
 633   char *symname = NULL;
 634   char *filename = DEV_TTY;
 635   struct objfile *objfile;
 636   struct partial_symtab *ps;
 637
 638   dont_repeat ();
 639
 640   if (args == NULL)
 641     {
 642       error ("print-psymbols takes an output file name and optional symbol file name");
 643     }
 644   else if ((argv = buildargv (args)) == NULL)
 645     {
 646       nomem (0);
 647     }
 648   cleanups = make_cleanup (freeargv, (char *) argv);
 649
 650   if (argv[0] != NULL)
 651     {
 652       filename = argv[0];
 653       /* If a second arg is supplied, it is a source file name to match on */
 654       if (argv[1] != NULL)
 655         {
 656           symname = argv[1];
 657         }
 658     }
 659
 660   filename = tilde_expand (filename);
 661   make_cleanup (free, filename);
 662
 663   outfile = gdb_fopen (filename, FOPEN_WT);
 664   if (outfile == 0)
 665     perror_with_name (filename);
 666   make_cleanup (fclose, outfile);
 667
 668   immediate_quit++;
 669   ALL_PSYMTABS (objfile, ps)
 670     if (symname == NULL || (STREQ (symname, ps -> filename)))
 671       dump_psymtab (objfile, ps, outfile);
 672   immediate_quit--;
 673   do_cleanups (cleanups);
 674 }
 675
 676 static void
 677 print_partial_symbol (p, count, what, outfile)
 678      struct partial_symbol *p;
 679      int count;
 680      char *what;
 681      GDB_FILE *outfile;
 682 {
 683
 684   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
 685   while (count-- > 0)
 686     {
 687       fprintf_filtered (outfile, "    `%s'", SYMBOL_NAME(p));
 688       if (SYMBOL_DEMANGLED_NAME (p) != NULL)
 689         {
 690           fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (p));
 691         }
 692       fputs_filtered (", ", outfile);
 693       switch (SYMBOL_NAMESPACE (p))
 694         {
 695         case UNDEF_NAMESPACE:
 696           fputs_filtered ("undefined namespace, ", outfile);
 697           break;
 698         case VAR_NAMESPACE:
 699           /* This is the usual thing -- don't print it */
 700           break;
 701         case STRUCT_NAMESPACE:
 702           fputs_filtered ("struct namespace, ", outfile);
 703           break;
 704         case LABEL_NAMESPACE:
 705           fputs_filtered ("label namespace, ", outfile);
 706           break;
 707         default:
 708           fputs_filtered ("<invalid namespace>, ", outfile);
 709           break;
 710         }
 711       switch (SYMBOL_CLASS (p))
 712         {
 713         case LOC_UNDEF:
 714           fputs_filtered ("undefined", outfile);
 715           break;
 716         case LOC_CONST:
 717           fputs_filtered ("constant int", outfile);
 718           break;
 719         case LOC_STATIC:
 720           fputs_filtered ("static", outfile);
 721           break;
 722         case LOC_REGISTER:
 723           fputs_filtered ("register", outfile);
 724           break;
 725         case LOC_ARG:
 726           fputs_filtered ("pass by value", outfile);
 727           break;
 728         case LOC_REF_ARG:
 729           fputs_filtered ("pass by reference", outfile);
 730           break;
 731         case LOC_REGPARM:
 732           fputs_filtered ("register parameter", outfile);
 733           break;
 734         case LOC_REGPARM_ADDR:
 735           fputs_filtered ("register address parameter", outfile);
 736           break;
 737         case LOC_LOCAL:
 738           fputs_filtered ("stack parameter", outfile);
 739           break;
 740         case LOC_TYPEDEF:
 741           fputs_filtered ("type", outfile);
 742           break;
 743         case LOC_LABEL:
 744           fputs_filtered ("label", outfile);
 745           break;
 746         case LOC_BLOCK:
 747           fputs_filtered ("function", outfile);
 748           break;
 749         case LOC_CONST_BYTES:
 750           fputs_filtered ("constant bytes", outfile);
 751           break;
 752         case LOC_LOCAL_ARG:
 753           fputs_filtered ("shuffled arg", outfile);
 754           break;
 755         case LOC_OPTIMIZED_OUT:
 756           fputs_filtered ("optimized out", outfile);
 757           break;
 758         default:
 759           fputs_filtered ("<invalid location>", outfile);
 760           break;
 761         }
 762       fputs_filtered (", ", outfile);
 763       /* FIXME-32x64: Need to use SYMBOL_VALUE_ADDRESS, etc.; this
 764          could be 32 bits when some of the other fields in the union
 765          are 64.  */
 766       fprintf_filtered (outfile, "0x%lx\n", SYMBOL_VALUE (p));
 767       p++;
 768     }
 769 }
 770
 771 void
 772 maintenance_print_msymbols (args, from_tty)
 773      char *args;
 774      int from_tty;
 775 {
 776   char **argv;
 777   GDB_FILE *outfile;
 778   struct cleanup *cleanups;
 779   char *filename = DEV_TTY;
 780   char *symname = NULL;
 781   struct objfile *objfile;
 782
 783   dont_repeat ();
 784
 785   if (args == NULL)
 786     {
 787       error ("print-msymbols takes an output file name and optional symbol file name");
 788     }
 789   else if ((argv = buildargv (args)) == NULL)
 790     {
 791       nomem (0);
 792     }
 793   cleanups = make_cleanup (freeargv, argv);
 794
 795   if (argv[0] != NULL)
 796     {
 797       filename = argv[0];
 798       /* If a second arg is supplied, it is a source file name to match on */
 799       if (argv[1] != NULL)
 800         {
 801           symname = argv[1];
 802         }
 803     }
 804
 805   filename = tilde_expand (filename);
 806   make_cleanup (free, filename);
 807
 808   outfile = gdb_fopen (filename, FOPEN_WT);
 809   if (outfile == 0)
 810     perror_with_name (filename);
 811   make_cleanup (fclose, outfile);
 812
 813   immediate_quit++;
 814   ALL_OBJFILES (objfile)
 815     if (symname == NULL || (STREQ (symname, objfile -> name)))
 816       dump_msymbols (objfile, outfile);
 817   immediate_quit--;
 818   fprintf_filtered (outfile, "\n\n");
 819   do_cleanups (cleanups);
 820 }
 821
 822 void
 823 maintenance_print_objfiles (ignore, from_tty)
 824      char *ignore;
 825      int from_tty;
 826 {
 827   struct objfile *objfile;
 828
 829   dont_repeat ();
 830
 831   immediate_quit++;
 832   ALL_OBJFILES (objfile)
 833     dump_objfile (objfile);
 834   immediate_quit--;
 835 }
 836
 837 \f
 838 /* Return the nexting depth of a block within other blocks in its symtab.  */
 839
 840 static int
 841 block_depth (block)
 842      struct block *block;
 843 {
 844   register int i = 0;
 845   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 846     {
 847       i++;
 848     }
 849   return i;
 850 }
 851
 852 #endif  /* MAINTENANCE_CMDS */
 853
 854 \f
 855 /* Increase the space allocated for LISTP, which is probably
 856    global_psymbol_list or static_psymbol_list. This space will eventually
 857    be freed in free_objfile().  */
 858
 859 void
 860 extend_psymbol_list (listp, objfile)
 861      register struct psymbol_allocation_list *listp;
 862      struct objfile *objfile;
 863 {
 864   int new_size;
 865   if (listp->size == 0)
 866     {
 867       new_size = 255;
 868       listp->list = (struct partial_symbol *)
 869         xmmalloc (objfile -> md, new_size * sizeof (struct partial_symbol));
 870     }
 871   else
 872     {
 873       new_size = listp->size * 2;
 874       listp->list = (struct partial_symbol *)
 875         xmrealloc (objfile -> md, (char *) listp->list,
 876                    new_size * sizeof (struct partial_symbol));
 877     }
 878   /* Next assumes we only went one over.  Should be good if
 879      program works correctly */
 880   listp->next = listp->list + listp->size;
 881   listp->size = new_size;
 882 }
 883
 884
 885 /* Do early runtime initializations. */
 886 void
 887 _initialize_symmisc ()
 888 {
 889   std_in  = stdin;
 890   std_out = stdout;
 891   std_err = stderr;
 892 }