gdb/symmisc.c

   1 /* Do various things to symbol tables (other than lookup), for GDB.
   2
   3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007, 2008, 2009, 2010,
   5    2011 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "bfd.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "breakpoint.h"
  29 #include "command.h"
  30 #include "gdb_obstack.h"
  31 #include "exceptions.h"
  32 #include "language.h"
  33 #include "bcache.h"
  34 #include "block.h"
  35 #include "gdb_regex.h"
  36 #include "gdb_stat.h"
  37 #include "dictionary.h"
  38
  39 #include "gdb_string.h"
  40 #include "readline/readline.h"
  41
  42 #include "psymtab.h"
  43
  44 #ifndef DEV_TTY
  45 #define DEV_TTY "/dev/tty"
  46 #endif
  47
  48 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
  49    when calling functions that take FILE *'s from the debugger.
  50    So we make a variable which has the same value and which is accessible when
  51    debugging GDB with itself.  Because stdin et al need not be constants,
  52    we initialize them in the _initialize_symmisc function at the bottom
  53    of the file.  */
  54 FILE *std_in;
  55 FILE *std_out;
  56 FILE *std_err;
  57
  58 /* Prototypes for local functions */
  59
  60 static void dump_symtab (struct objfile *, struct symtab *,
  61                          struct ui_file *);
  62
  63 static void dump_msymbols (struct objfile *, struct ui_file *);
  64
  65 static void dump_objfile (struct objfile *);
  66
  67 static int block_depth (struct block *);
  68
  69 void _initialize_symmisc (void);
  70
  71 struct print_symbol_args
  72   {
  73     struct gdbarch *gdbarch;
  74     struct symbol *symbol;
  75     int depth;
  76     struct ui_file *outfile;
  77   };
  78
  79 static int print_symbol (void *);
  80 \f
  81 /* Free all the storage associated with the struct symtab <- S.
  82    Note that some symtabs have contents that all live inside one big block of
  83    memory, and some share the contents of another symbol table and so you
  84    should not free the contents on their behalf (except sometimes the
  85    linetable, which maybe per symtab even when the rest is not).
  86    It is s->free_code that says which alternative to use.  */
  87
  88 void
  89 free_symtab (struct symtab *s)
  90 {
  91   switch (s->free_code)
  92     {
  93     case free_nothing:
  94       /* All the contents are part of a big block of memory (an obstack),
  95          and some other symtab is in charge of freeing that block.
  96          Therefore, do nothing.  */
  97       break;
  98
  99     case free_linetable:
 100       /* Everything will be freed either by our `free_func'
 101          or by some other symtab, except for our linetable.
 102          Free that now.  */
 103       if (LINETABLE (s))
 104         xfree (LINETABLE (s));
 105       break;
 106     }
 107
 108   /* If there is a single block of memory to free, free it.  */
 109   if (s->free_func != NULL)
 110     s->free_func (s);
 111
 112   /* Free source-related stuff */
 113   if (s->line_charpos != NULL)
 114     xfree (s->line_charpos);
 115   if (s->fullname != NULL)
 116     xfree (s->fullname);
 117   if (s->debugformat != NULL)
 118     xfree (s->debugformat);
 119   xfree (s);
 120 }
 121
 122 void
 123 print_symbol_bcache_statistics (void)
 124 {
 125   struct program_space *pspace;
 126   struct objfile *objfile;
 127
 128   immediate_quit++;
 129   ALL_PSPACES (pspace)
 130     ALL_PSPACE_OBJFILES (pspace, objfile)
 131   {
 132     printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
 133     print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
 134                              "partial symbol cache");
 135     print_bcache_statistics (objfile->macro_cache, "preprocessor macro cache");
 136     print_bcache_statistics (objfile->filename_cache, "file name cache");
 137   }
 138   immediate_quit--;
 139 }
 140
 141 void
 142 print_objfile_statistics (void)
 143 {
 144   struct program_space *pspace;
 145   struct objfile *objfile;
 146   struct symtab *s;
 147   int i, linetables, blockvectors;
 148
 149   immediate_quit++;
 150   ALL_PSPACES (pspace)
 151     ALL_PSPACE_OBJFILES (pspace, objfile)
 152   {
 153     printf_filtered (_("Statistics for '%s':\n"), objfile->name);
 154     if (OBJSTAT (objfile, n_stabs) > 0)
 155       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
 156                        OBJSTAT (objfile, n_stabs));
 157     if (OBJSTAT (objfile, n_minsyms) > 0)
 158       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
 159                        OBJSTAT (objfile, n_minsyms));
 160     if (OBJSTAT (objfile, n_psyms) > 0)
 161       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
 162                        OBJSTAT (objfile, n_psyms));
 163     if (OBJSTAT (objfile, n_syms) > 0)
 164       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
 165                        OBJSTAT (objfile, n_syms));
 166     if (OBJSTAT (objfile, n_types) > 0)
 167       printf_filtered (_("  Number of \"types\" defined: %d\n"),
 168                        OBJSTAT (objfile, n_types));
 169     if (objfile->sf)
 170       objfile->sf->qf->print_stats (objfile);
 171     i = linetables = blockvectors = 0;
 172     ALL_OBJFILE_SYMTABS (objfile, s)
 173       {
 174         i++;
 175         if (s->linetable != NULL)
 176           linetables++;
 177         if (s->primary == 1)
 178           blockvectors++;
 179       }
 180     printf_filtered (_("  Number of symbol tables: %d\n"), i);
 181     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
 182                      linetables);
 183     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
 184                      blockvectors);
 185
 186     if (OBJSTAT (objfile, sz_strtab) > 0)
 187       printf_filtered (_("  Space used by a.out string tables: %d\n"),
 188                        OBJSTAT (objfile, sz_strtab));
 189     printf_filtered (_("  Total memory used for objfile obstack: %d\n"),
 190                      obstack_memory_used (&objfile->objfile_obstack));
 191     printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
 192                      bcache_memory_used (psymbol_bcache_get_bcache
 193                                           (objfile->psymbol_cache)));
 194     printf_filtered (_("  Total memory used for macro cache: %d\n"),
 195                      bcache_memory_used (objfile->macro_cache));
 196     printf_filtered (_("  Total memory used for file name cache: %d\n"),
 197                      bcache_memory_used (objfile->filename_cache));
 198   }
 199   immediate_quit--;
 200 }
 201
 202 static void
 203 dump_objfile (struct objfile *objfile)
 204 {
 205   struct symtab *symtab;
 206
 207   printf_filtered ("\nObject file %s:  ", objfile->name);
 208   printf_filtered ("Objfile at ");
 209   gdb_print_host_address (objfile, gdb_stdout);
 210   printf_filtered (", bfd at ");
 211   gdb_print_host_address (objfile->obfd, gdb_stdout);
 212   printf_filtered (", %d minsyms\n\n",
 213                    objfile->minimal_symbol_count);
 214
 215   if (objfile->sf)
 216     objfile->sf->qf->dump (objfile);
 217
 218   if (objfile->symtabs)
 219     {
 220       printf_filtered ("Symtabs:\n");
 221       for (symtab = objfile->symtabs;
 222            symtab != NULL;
 223            symtab = symtab->next)
 224         {
 225           printf_filtered ("%s at ", symtab->filename);
 226           gdb_print_host_address (symtab, gdb_stdout);
 227           printf_filtered (", ");
 228           if (symtab->objfile != objfile)
 229             {
 230               printf_filtered ("NOT ON CHAIN!  ");
 231             }
 232           wrap_here ("  ");
 233         }
 234       printf_filtered ("\n\n");
 235     }
 236 }
 237
 238 /* Print minimal symbols from this objfile.  */
 239
 240 static void
 241 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 242 {
 243   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 244   struct minimal_symbol *msymbol;
 245   int index;
 246   char ms_type;
 247
 248   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
 249   if (objfile->minimal_symbol_count == 0)
 250     {
 251       fprintf_filtered (outfile, "No minimal symbols found.\n");
 252       return;
 253     }
 254   index = 0;
 255   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
 256     {
 257       struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
 258
 259       switch (MSYMBOL_TYPE (msymbol))
 260         {
 261         case mst_unknown:
 262           ms_type = 'u';
 263           break;
 264         case mst_text:
 265           ms_type = 'T';
 266           break;
 267         case mst_solib_trampoline:
 268           ms_type = 'S';
 269           break;
 270         case mst_data:
 271           ms_type = 'D';
 272           break;
 273         case mst_bss:
 274           ms_type = 'B';
 275           break;
 276         case mst_abs:
 277           ms_type = 'A';
 278           break;
 279         case mst_file_text:
 280           ms_type = 't';
 281           break;
 282         case mst_file_data:
 283           ms_type = 'd';
 284           break;
 285         case mst_file_bss:
 286           ms_type = 'b';
 287           break;
 288         default:
 289           ms_type = '?';
 290           break;
 291         }
 292       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
 293       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)),
 294                       outfile);
 295       fprintf_filtered (outfile, " %s", SYMBOL_LINKAGE_NAME (msymbol));
 296       if (section)
 297         fprintf_filtered (outfile, " section %s",
 298                           bfd_section_name (objfile->obfd,
 299                                             section->the_bfd_section));
 300       if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 301         {
 302           fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
 303         }
 304       if (msymbol->filename)
 305         fprintf_filtered (outfile, "  %s", msymbol->filename);
 306       fputs_filtered ("\n", outfile);
 307       index++;
 308     }
 309   if (objfile->minimal_symbol_count != index)
 310     {
 311       warning (_("internal error:  minimal symbol count %d != %d"),
 312                objfile->minimal_symbol_count, index);
 313     }
 314   fprintf_filtered (outfile, "\n");
 315 }
 316
 317 static void
 318 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 319                struct ui_file *outfile)
 320 {
 321   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 322   int i;
 323   struct dict_iterator iter;
 324   int len;
 325   struct linetable *l;
 326   struct blockvector *bv;
 327   struct symbol *sym;
 328   struct block *b;
 329   int depth;
 330
 331   fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
 332   if (symtab->dirname)
 333     fprintf_filtered (outfile, "Compilation directory is %s\n",
 334                       symtab->dirname);
 335   fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
 336   gdb_print_host_address (objfile, outfile);
 337   fprintf_filtered (outfile, ")\n");
 338   fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
 339
 340   /* First print the line table.  */
 341   l = LINETABLE (symtab);
 342   if (l)
 343     {
 344       fprintf_filtered (outfile, "\nLine table:\n\n");
 345       len = l->nitems;
 346       for (i = 0; i < len; i++)
 347         {
 348           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
 349           fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
 350           fprintf_filtered (outfile, "\n");
 351         }
 352     }
 353   /* Now print the block info, but only for primary symtabs since we will
 354      print lots of duplicate info otherwise. */
 355   if (symtab->primary)
 356     {
 357       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 358       bv = BLOCKVECTOR (symtab);
 359       len = BLOCKVECTOR_NBLOCKS (bv);
 360       for (i = 0; i < len; i++)
 361         {
 362           b = BLOCKVECTOR_BLOCK (bv, i);
 363           depth = block_depth (b) * 2;
 364           print_spaces (depth, outfile);
 365           fprintf_filtered (outfile, "block #%03d, object at ", i);
 366           gdb_print_host_address (b, outfile);
 367           if (BLOCK_SUPERBLOCK (b))
 368             {
 369               fprintf_filtered (outfile, " under ");
 370               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
 371             }
 372           /* drow/2002-07-10: We could save the total symbols count
 373              even if we're using a hashtable, but nothing else but this message
 374              wants it.  */
 375           fprintf_filtered (outfile, ", %d syms/buckets in ",
 376                             dict_size (BLOCK_DICT (b)));
 377           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 378           fprintf_filtered (outfile, "..");
 379           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 380           if (BLOCK_FUNCTION (b))
 381             {
 382               fprintf_filtered (outfile, ", function %s",
 383                                 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
 384               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 385                 {
 386                   fprintf_filtered (outfile, ", %s",
 387                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 388                 }
 389             }
 390           fprintf_filtered (outfile, "\n");
 391           /* Now print each symbol in this block (in no particular order, if
 392              we're using a hashtable).  */
 393           ALL_BLOCK_SYMBOLS (b, iter, sym)
 394             {
 395               struct print_symbol_args s;
 396
 397               s.gdbarch = gdbarch;
 398               s.symbol = sym;
 399               s.depth = depth + 1;
 400               s.outfile = outfile;
 401               catch_errors (print_symbol, &s, "Error printing symbol:\n",
 402                             RETURN_MASK_ERROR);
 403             }
 404         }
 405       fprintf_filtered (outfile, "\n");
 406     }
 407   else
 408     {
 409       fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
 410     }
 411 }
 412
 413 static void
 414 dump_symtab (struct objfile *objfile, struct symtab *symtab,
 415              struct ui_file *outfile)
 416 {
 417   /* Set the current language to the language of the symtab we're dumping
 418      because certain routines used during dump_symtab() use the current
 419      language to print an image of the symbol.  We'll restore it later.
 420      But use only real languages, not placeholders.  */
 421   if (symtab->language != language_unknown
 422       && symtab->language != language_auto)
 423     {
 424       enum language saved_lang;
 425
 426       saved_lang = set_language (symtab->language);
 427
 428       dump_symtab_1 (objfile, symtab, outfile);
 429
 430       set_language (saved_lang);
 431     }
 432   else
 433     dump_symtab_1 (objfile, symtab, outfile);
 434 }
 435
 436 void
 437 maintenance_print_symbols (char *args, int from_tty)
 438 {
 439   char **argv;
 440   struct ui_file *outfile;
 441   struct cleanup *cleanups;
 442   char *symname = NULL;
 443   char *filename = DEV_TTY;
 444   struct objfile *objfile;
 445   struct symtab *s;
 446
 447   dont_repeat ();
 448
 449   if (args == NULL)
 450     {
 451       error (_("\
 452 Arguments missing: an output file name and an optional symbol file name"));
 453     }
 454   argv = gdb_buildargv (args);
 455   cleanups = make_cleanup_freeargv (argv);
 456
 457   if (argv[0] != NULL)
 458     {
 459       filename = argv[0];
 460       /* If a second arg is supplied, it is a source file name to match on */
 461       if (argv[1] != NULL)
 462         {
 463           symname = argv[1];
 464         }
 465     }
 466
 467   filename = tilde_expand (filename);
 468   make_cleanup (xfree, filename);
 469
 470   outfile = gdb_fopen (filename, FOPEN_WT);
 471   if (outfile == 0)
 472     perror_with_name (filename);
 473   make_cleanup_ui_file_delete (outfile);
 474
 475   immediate_quit++;
 476   ALL_SYMTABS (objfile, s)
 477     if (symname == NULL || strcmp (symname, s->filename) == 0)
 478     dump_symtab (objfile, s, outfile);
 479   immediate_quit--;
 480   do_cleanups (cleanups);
 481 }
 482
 483 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 484    far to indent.  ARGS is really a struct print_symbol_args *, but is
 485    declared as char * to get it past catch_errors.  Returns 0 for error,
 486    1 for success.  */
 487
 488 static int
 489 print_symbol (void *args)
 490 {
 491   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
 492   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 493   int depth = ((struct print_symbol_args *) args)->depth;
 494   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 495   struct obj_section *section = SYMBOL_OBJ_SECTION (symbol);
 496
 497   print_spaces (depth, outfile);
 498   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 499     {
 500       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 501       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 502                       outfile);
 503       if (section)
 504         fprintf_filtered (outfile, " section %s\n",
 505                           bfd_section_name (section->the_bfd_section->owner,
 506                                             section->the_bfd_section));
 507       else
 508         fprintf_filtered (outfile, "\n");
 509       return 1;
 510     }
 511   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 512     {
 513       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 514         {
 515           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 516         }
 517       else
 518         {
 519           fprintf_filtered (outfile, "%s %s = ",
 520                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 521                           ? "enum"
 522                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 523                         ? "struct" : "union")),
 524                             SYMBOL_LINKAGE_NAME (symbol));
 525           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 526         }
 527       fprintf_filtered (outfile, ";\n");
 528     }
 529   else
 530     {
 531       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 532         fprintf_filtered (outfile, "typedef ");
 533       if (SYMBOL_TYPE (symbol))
 534         {
 535           /* Print details of types, except for enums where it's clutter.  */
 536           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 537                          outfile,
 538                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 539                          depth);
 540           fprintf_filtered (outfile, "; ");
 541         }
 542       else
 543         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 544
 545       switch (SYMBOL_CLASS (symbol))
 546         {
 547         case LOC_CONST:
 548           fprintf_filtered (outfile, "const %ld (0x%lx)",
 549                             SYMBOL_VALUE (symbol),
 550                             SYMBOL_VALUE (symbol));
 551           break;
 552
 553         case LOC_CONST_BYTES:
 554           {
 555             unsigned i;
 556             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 557
 558             fprintf_filtered (outfile, "const %u hex bytes:",
 559                               TYPE_LENGTH (type));
 560             for (i = 0; i < TYPE_LENGTH (type); i++)
 561               fprintf_filtered (outfile, " %02x",
 562                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 563           }
 564           break;
 565
 566         case LOC_STATIC:
 567           fprintf_filtered (outfile, "static at ");
 568           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 569                           outfile);
 570           if (section)
 571             fprintf_filtered (outfile, " section %s",
 572                               bfd_section_name (section->the_bfd_section->owner,
 573                                                 section->the_bfd_section));
 574           break;
 575
 576         case LOC_REGISTER:
 577           if (SYMBOL_IS_ARGUMENT (symbol))
 578             fprintf_filtered (outfile, "parameter register %ld",
 579                               SYMBOL_VALUE (symbol));
 580           else
 581             fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
 582           break;
 583
 584         case LOC_ARG:
 585           fprintf_filtered (outfile, "arg at offset 0x%lx",
 586                             SYMBOL_VALUE (symbol));
 587           break;
 588
 589         case LOC_REF_ARG:
 590           fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
 591           break;
 592
 593         case LOC_REGPARM_ADDR:
 594           fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
 595           break;
 596
 597         case LOC_LOCAL:
 598           fprintf_filtered (outfile, "local at offset 0x%lx",
 599                             SYMBOL_VALUE (symbol));
 600           break;
 601
 602         case LOC_TYPEDEF:
 603           break;
 604
 605         case LOC_LABEL:
 606           fprintf_filtered (outfile, "label at ");
 607           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 608                           outfile);
 609           if (section)
 610             fprintf_filtered (outfile, " section %s",
 611                               bfd_section_name (section->the_bfd_section->owner,
 612                                                 section->the_bfd_section));
 613           break;
 614
 615         case LOC_BLOCK:
 616           fprintf_filtered (outfile, "block object ");
 617           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 618           fprintf_filtered (outfile, ", ");
 619           fputs_filtered (paddress (gdbarch,
 620                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 621                           outfile);
 622           fprintf_filtered (outfile, "..");
 623           fputs_filtered (paddress (gdbarch,
 624                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 625                           outfile);
 626           if (section)
 627             fprintf_filtered (outfile, " section %s",
 628                               bfd_section_name (section->the_bfd_section->owner,
 629                                                 section->the_bfd_section));
 630           break;
 631
 632         case LOC_COMPUTED:
 633           fprintf_filtered (outfile, "computed at runtime");
 634           break;
 635
 636         case LOC_UNRESOLVED:
 637           fprintf_filtered (outfile, "unresolved");
 638           break;
 639
 640         case LOC_OPTIMIZED_OUT:
 641           fprintf_filtered (outfile, "optimized out");
 642           break;
 643
 644         default:
 645           fprintf_filtered (outfile, "botched symbol class %x",
 646                             SYMBOL_CLASS (symbol));
 647           break;
 648         }
 649     }
 650   fprintf_filtered (outfile, "\n");
 651   return 1;
 652 }
 653
 654 void
 655 maintenance_print_msymbols (char *args, int from_tty)
 656 {
 657   char **argv;
 658   struct ui_file *outfile;
 659   struct cleanup *cleanups;
 660   char *filename = DEV_TTY;
 661   char *symname = NULL;
 662   struct program_space *pspace;
 663   struct objfile *objfile;
 664
 665   struct stat sym_st, obj_st;
 666
 667   dont_repeat ();
 668
 669   if (args == NULL)
 670     {
 671       error (_("print-msymbols takes an output file name and optional symbol file name"));
 672     }
 673   argv = gdb_buildargv (args);
 674   cleanups = make_cleanup_freeargv (argv);
 675
 676   if (argv[0] != NULL)
 677     {
 678       filename = argv[0];
 679       /* If a second arg is supplied, it is a source file name to match on */
 680       if (argv[1] != NULL)
 681         {
 682           symname = xfullpath (argv[1]);
 683           make_cleanup (xfree, symname);
 684           if (symname && stat (symname, &sym_st))
 685             perror_with_name (symname);
 686         }
 687     }
 688
 689   filename = tilde_expand (filename);
 690   make_cleanup (xfree, filename);
 691
 692   outfile = gdb_fopen (filename, FOPEN_WT);
 693   if (outfile == 0)
 694     perror_with_name (filename);
 695   make_cleanup_ui_file_delete (outfile);
 696
 697   immediate_quit++;
 698   ALL_PSPACES (pspace)
 699     ALL_PSPACE_OBJFILES (pspace, objfile)
 700       if (symname == NULL
 701           || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
 702         dump_msymbols (objfile, outfile);
 703   immediate_quit--;
 704   fprintf_filtered (outfile, "\n\n");
 705   do_cleanups (cleanups);
 706 }
 707
 708 void
 709 maintenance_print_objfiles (char *ignore, int from_tty)
 710 {
 711   struct program_space *pspace;
 712   struct objfile *objfile;
 713
 714   dont_repeat ();
 715
 716   immediate_quit++;
 717   ALL_PSPACES (pspace)
 718     ALL_PSPACE_OBJFILES (pspace, objfile)
 719       dump_objfile (objfile);
 720   immediate_quit--;
 721 }
 722
 723
 724 /* List all the symbol tables whose names match REGEXP (optional).  */
 725 void
 726 maintenance_info_symtabs (char *regexp, int from_tty)
 727 {
 728   struct program_space *pspace;
 729   struct objfile *objfile;
 730
 731   if (regexp)
 732     re_comp (regexp);
 733
 734   ALL_PSPACES (pspace)
 735     ALL_PSPACE_OBJFILES (pspace, objfile)
 736     {
 737       struct symtab *symtab;
 738
 739       /* We don't want to print anything for this objfile until we
 740          actually find a symtab whose name matches.  */
 741       int printed_objfile_start = 0;
 742
 743       ALL_OBJFILE_SYMTABS (objfile, symtab)
 744         {
 745           QUIT;
 746
 747           if (! regexp
 748               || re_exec (symtab->filename))
 749             {
 750               if (! printed_objfile_start)
 751                 {
 752                   printf_filtered ("{ objfile %s ", objfile->name);
 753                   wrap_here ("  ");
 754                   printf_filtered ("((struct objfile *) %s)\n",
 755                                    host_address_to_string (objfile));
 756                   printed_objfile_start = 1;
 757                 }
 758
 759               printf_filtered ("        { symtab %s ", symtab->filename);
 760               wrap_here ("    ");
 761               printf_filtered ("((struct symtab *) %s)\n",
 762                                host_address_to_string (symtab));
 763               printf_filtered ("          dirname %s\n",
 764                                symtab->dirname ? symtab->dirname : "(null)");
 765               printf_filtered ("          fullname %s\n",
 766                                symtab->fullname ? symtab->fullname : "(null)");
 767               printf_filtered ("          blockvector ((struct blockvector *) %s)%s\n",
 768                                host_address_to_string (symtab->blockvector),
 769                                symtab->primary ? " (primary)" : "");
 770               printf_filtered ("          linetable ((struct linetable *) %s)\n",
 771                                host_address_to_string (symtab->linetable));
 772               printf_filtered ("          debugformat %s\n", symtab->debugformat);
 773               printf_filtered ("        }\n");
 774             }
 775         }
 776
 777       if (printed_objfile_start)
 778         printf_filtered ("}\n");
 779     }
 780 }
 781 \f
 782
 783 /* Return the nexting depth of a block within other blocks in its symtab.  */
 784
 785 static int
 786 block_depth (struct block *block)
 787 {
 788   int i = 0;
 789
 790   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 791     {
 792       i++;
 793     }
 794   return i;
 795 }
 796 \f
 797
 798 /* Do early runtime initializations. */
 799 void
 800 _initialize_symmisc (void)
 801 {
 802   std_in = stdin;
 803   std_out = stdout;
 804   std_err = stderr;
 805 }