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    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 (objfile->psymbol_cache, "partial symbol cache");
 134     print_bcache_statistics (objfile->macro_cache, "preprocessor macro cache");
 135     print_bcache_statistics (objfile->filename_cache, "file name cache");
 136   }
 137   immediate_quit--;
 138 }
 139
 140 void
 141 print_objfile_statistics (void)
 142 {
 143   struct program_space *pspace;
 144   struct objfile *objfile;
 145   struct symtab *s;
 146   int i, linetables, blockvectors;
 147
 148   immediate_quit++;
 149   ALL_PSPACES (pspace)
 150     ALL_PSPACE_OBJFILES (pspace, objfile)
 151   {
 152     printf_filtered (_("Statistics for '%s':\n"), objfile->name);
 153     if (OBJSTAT (objfile, n_stabs) > 0)
 154       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
 155                        OBJSTAT (objfile, n_stabs));
 156     if (OBJSTAT (objfile, n_minsyms) > 0)
 157       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
 158                        OBJSTAT (objfile, n_minsyms));
 159     if (OBJSTAT (objfile, n_psyms) > 0)
 160       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
 161                        OBJSTAT (objfile, n_psyms));
 162     if (OBJSTAT (objfile, n_syms) > 0)
 163       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
 164                        OBJSTAT (objfile, n_syms));
 165     if (OBJSTAT (objfile, n_types) > 0)
 166       printf_filtered (_("  Number of \"types\" defined: %d\n"),
 167                        OBJSTAT (objfile, n_types));
 168     if (objfile->sf)
 169       objfile->sf->qf->print_stats (objfile);
 170     i = linetables = blockvectors = 0;
 171     ALL_OBJFILE_SYMTABS (objfile, s)
 172       {
 173         i++;
 174         if (s->linetable != NULL)
 175           linetables++;
 176         if (s->primary == 1)
 177           blockvectors++;
 178       }
 179     printf_filtered (_("  Number of symbol tables: %d\n"), i);
 180     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
 181                      linetables);
 182     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
 183                      blockvectors);
 184
 185     if (OBJSTAT (objfile, sz_strtab) > 0)
 186       printf_filtered (_("  Space used by a.out string tables: %d\n"),
 187                        OBJSTAT (objfile, sz_strtab));
 188     printf_filtered (_("  Total memory used for objfile obstack: %d\n"),
 189                      obstack_memory_used (&objfile->objfile_obstack));
 190     printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
 191                      bcache_memory_used (objfile->psymbol_cache));
 192     printf_filtered (_("  Total memory used for macro cache: %d\n"),
 193                      bcache_memory_used (objfile->macro_cache));
 194     printf_filtered (_("  Total memory used for file name cache: %d\n"),
 195                      bcache_memory_used (objfile->filename_cache));
 196   }
 197   immediate_quit--;
 198 }
 199
 200 static void
 201 dump_objfile (struct objfile *objfile)
 202 {
 203   struct symtab *symtab;
 204
 205   printf_filtered ("\nObject file %s:  ", objfile->name);
 206   printf_filtered ("Objfile at ");
 207   gdb_print_host_address (objfile, gdb_stdout);
 208   printf_filtered (", bfd at ");
 209   gdb_print_host_address (objfile->obfd, gdb_stdout);
 210   printf_filtered (", %d minsyms\n\n",
 211                    objfile->minimal_symbol_count);
 212
 213   if (objfile->sf)
 214     objfile->sf->qf->dump (objfile);
 215
 216   if (objfile->symtabs)
 217     {
 218       printf_filtered ("Symtabs:\n");
 219       for (symtab = objfile->symtabs;
 220            symtab != NULL;
 221            symtab = symtab->next)
 222         {
 223           printf_filtered ("%s at ", symtab->filename);
 224           gdb_print_host_address (symtab, gdb_stdout);
 225           printf_filtered (", ");
 226           if (symtab->objfile != objfile)
 227             {
 228               printf_filtered ("NOT ON CHAIN!  ");
 229             }
 230           wrap_here ("  ");
 231         }
 232       printf_filtered ("\n\n");
 233     }
 234 }
 235
 236 /* Print minimal symbols from this objfile.  */
 237
 238 static void
 239 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 240 {
 241   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 242   struct minimal_symbol *msymbol;
 243   int index;
 244   char ms_type;
 245
 246   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
 247   if (objfile->minimal_symbol_count == 0)
 248     {
 249       fprintf_filtered (outfile, "No minimal symbols found.\n");
 250       return;
 251     }
 252   index = 0;
 253   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
 254     {
 255       struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol);
 256
 257       switch (MSYMBOL_TYPE (msymbol))
 258         {
 259         case mst_unknown:
 260           ms_type = 'u';
 261           break;
 262         case mst_text:
 263           ms_type = 'T';
 264           break;
 265         case mst_solib_trampoline:
 266           ms_type = 'S';
 267           break;
 268         case mst_data:
 269           ms_type = 'D';
 270           break;
 271         case mst_bss:
 272           ms_type = 'B';
 273           break;
 274         case mst_abs:
 275           ms_type = 'A';
 276           break;
 277         case mst_file_text:
 278           ms_type = 't';
 279           break;
 280         case mst_file_data:
 281           ms_type = 'd';
 282           break;
 283         case mst_file_bss:
 284           ms_type = 'b';
 285           break;
 286         default:
 287           ms_type = '?';
 288           break;
 289         }
 290       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
 291       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)),
 292                       outfile);
 293       fprintf_filtered (outfile, " %s", SYMBOL_LINKAGE_NAME (msymbol));
 294       if (section)
 295         fprintf_filtered (outfile, " section %s",
 296                           bfd_section_name (objfile->obfd,
 297                                             section->the_bfd_section));
 298       if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 299         {
 300           fprintf_filtered (outfile, "  %s", SYMBOL_DEMANGLED_NAME (msymbol));
 301         }
 302       if (msymbol->filename)
 303         fprintf_filtered (outfile, "  %s", msymbol->filename);
 304       fputs_filtered ("\n", outfile);
 305       index++;
 306     }
 307   if (objfile->minimal_symbol_count != index)
 308     {
 309       warning (_("internal error:  minimal symbol count %d != %d"),
 310                objfile->minimal_symbol_count, index);
 311     }
 312   fprintf_filtered (outfile, "\n");
 313 }
 314
 315 static void
 316 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 317                struct ui_file *outfile)
 318 {
 319   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 320   int i;
 321   struct dict_iterator iter;
 322   int len;
 323   struct linetable *l;
 324   struct blockvector *bv;
 325   struct symbol *sym;
 326   struct block *b;
 327   int depth;
 328
 329   fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
 330   if (symtab->dirname)
 331     fprintf_filtered (outfile, "Compilation directory is %s\n",
 332                       symtab->dirname);
 333   fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
 334   gdb_print_host_address (objfile, outfile);
 335   fprintf_filtered (outfile, ")\n");
 336   fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
 337
 338   /* First print the line table.  */
 339   l = LINETABLE (symtab);
 340   if (l)
 341     {
 342       fprintf_filtered (outfile, "\nLine table:\n\n");
 343       len = l->nitems;
 344       for (i = 0; i < len; i++)
 345         {
 346           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
 347           fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
 348           fprintf_filtered (outfile, "\n");
 349         }
 350     }
 351   /* Now print the block info, but only for primary symtabs since we will
 352      print lots of duplicate info otherwise. */
 353   if (symtab->primary)
 354     {
 355       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 356       bv = BLOCKVECTOR (symtab);
 357       len = BLOCKVECTOR_NBLOCKS (bv);
 358       for (i = 0; i < len; i++)
 359         {
 360           b = BLOCKVECTOR_BLOCK (bv, i);
 361           depth = block_depth (b) * 2;
 362           print_spaces (depth, outfile);
 363           fprintf_filtered (outfile, "block #%03d, object at ", i);
 364           gdb_print_host_address (b, outfile);
 365           if (BLOCK_SUPERBLOCK (b))
 366             {
 367               fprintf_filtered (outfile, " under ");
 368               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
 369             }
 370           /* drow/2002-07-10: We could save the total symbols count
 371              even if we're using a hashtable, but nothing else but this message
 372              wants it.  */
 373           fprintf_filtered (outfile, ", %d syms/buckets in ",
 374                             dict_size (BLOCK_DICT (b)));
 375           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 376           fprintf_filtered (outfile, "..");
 377           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 378           if (BLOCK_FUNCTION (b))
 379             {
 380               fprintf_filtered (outfile, ", function %s",
 381                                 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
 382               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 383                 {
 384                   fprintf_filtered (outfile, ", %s",
 385                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 386                 }
 387             }
 388           fprintf_filtered (outfile, "\n");
 389           /* Now print each symbol in this block (in no particular order, if
 390              we're using a hashtable).  */
 391           ALL_BLOCK_SYMBOLS (b, iter, sym)
 392             {
 393               struct print_symbol_args s;
 394
 395               s.gdbarch = gdbarch;
 396               s.symbol = sym;
 397               s.depth = depth + 1;
 398               s.outfile = outfile;
 399               catch_errors (print_symbol, &s, "Error printing symbol:\n",
 400                             RETURN_MASK_ERROR);
 401             }
 402         }
 403       fprintf_filtered (outfile, "\n");
 404     }
 405   else
 406     {
 407       fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
 408     }
 409 }
 410
 411 static void
 412 dump_symtab (struct objfile *objfile, struct symtab *symtab,
 413              struct ui_file *outfile)
 414 {
 415   /* Set the current language to the language of the symtab we're dumping
 416      because certain routines used during dump_symtab() use the current
 417      language to print an image of the symbol.  We'll restore it later.
 418      But use only real languages, not placeholders.  */
 419   if (symtab->language != language_unknown
 420       && symtab->language != language_auto)
 421     {
 422       enum language saved_lang;
 423
 424       saved_lang = set_language (symtab->language);
 425
 426       dump_symtab_1 (objfile, symtab, outfile);
 427
 428       set_language (saved_lang);
 429     }
 430   else
 431     dump_symtab_1 (objfile, symtab, outfile);
 432 }
 433
 434 void
 435 maintenance_print_symbols (char *args, int from_tty)
 436 {
 437   char **argv;
 438   struct ui_file *outfile;
 439   struct cleanup *cleanups;
 440   char *symname = NULL;
 441   char *filename = DEV_TTY;
 442   struct objfile *objfile;
 443   struct symtab *s;
 444
 445   dont_repeat ();
 446
 447   if (args == NULL)
 448     {
 449       error (_("\
 450 Arguments missing: an output file name and an optional symbol file name"));
 451     }
 452   argv = gdb_buildargv (args);
 453   cleanups = make_cleanup_freeargv (argv);
 454
 455   if (argv[0] != NULL)
 456     {
 457       filename = argv[0];
 458       /* If a second arg is supplied, it is a source file name to match on */
 459       if (argv[1] != NULL)
 460         {
 461           symname = argv[1];
 462         }
 463     }
 464
 465   filename = tilde_expand (filename);
 466   make_cleanup (xfree, filename);
 467
 468   outfile = gdb_fopen (filename, FOPEN_WT);
 469   if (outfile == 0)
 470     perror_with_name (filename);
 471   make_cleanup_ui_file_delete (outfile);
 472
 473   immediate_quit++;
 474   ALL_SYMTABS (objfile, s)
 475     if (symname == NULL || strcmp (symname, s->filename) == 0)
 476     dump_symtab (objfile, s, outfile);
 477   immediate_quit--;
 478   do_cleanups (cleanups);
 479 }
 480
 481 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 482    far to indent.  ARGS is really a struct print_symbol_args *, but is
 483    declared as char * to get it past catch_errors.  Returns 0 for error,
 484    1 for success.  */
 485
 486 static int
 487 print_symbol (void *args)
 488 {
 489   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
 490   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 491   int depth = ((struct print_symbol_args *) args)->depth;
 492   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 493   struct obj_section *section = SYMBOL_OBJ_SECTION (symbol);
 494
 495   print_spaces (depth, outfile);
 496   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 497     {
 498       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 499       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 500                       outfile);
 501       if (section)
 502         fprintf_filtered (outfile, " section %s\n",
 503                           bfd_section_name (section->the_bfd_section->owner,
 504                                             section->the_bfd_section));
 505       else
 506         fprintf_filtered (outfile, "\n");
 507       return 1;
 508     }
 509   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 510     {
 511       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 512         {
 513           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 514         }
 515       else
 516         {
 517           fprintf_filtered (outfile, "%s %s = ",
 518                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 519                           ? "enum"
 520                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 521                         ? "struct" : "union")),
 522                             SYMBOL_LINKAGE_NAME (symbol));
 523           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 524         }
 525       fprintf_filtered (outfile, ";\n");
 526     }
 527   else
 528     {
 529       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 530         fprintf_filtered (outfile, "typedef ");
 531       if (SYMBOL_TYPE (symbol))
 532         {
 533           /* Print details of types, except for enums where it's clutter.  */
 534           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 535                          outfile,
 536                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 537                          depth);
 538           fprintf_filtered (outfile, "; ");
 539         }
 540       else
 541         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 542
 543       switch (SYMBOL_CLASS (symbol))
 544         {
 545         case LOC_CONST:
 546           fprintf_filtered (outfile, "const %ld (0x%lx)",
 547                             SYMBOL_VALUE (symbol),
 548                             SYMBOL_VALUE (symbol));
 549           break;
 550
 551         case LOC_CONST_BYTES:
 552           {
 553             unsigned i;
 554             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 555
 556             fprintf_filtered (outfile, "const %u hex bytes:",
 557                               TYPE_LENGTH (type));
 558             for (i = 0; i < TYPE_LENGTH (type); i++)
 559               fprintf_filtered (outfile, " %02x",
 560                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 561           }
 562           break;
 563
 564         case LOC_STATIC:
 565           fprintf_filtered (outfile, "static at ");
 566           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 567                           outfile);
 568           if (section)
 569             fprintf_filtered (outfile, " section %s",
 570                               bfd_section_name (section->the_bfd_section->owner,
 571                                                 section->the_bfd_section));
 572           break;
 573
 574         case LOC_REGISTER:
 575           if (SYMBOL_IS_ARGUMENT (symbol))
 576             fprintf_filtered (outfile, "parameter register %ld",
 577                               SYMBOL_VALUE (symbol));
 578           else
 579             fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
 580           break;
 581
 582         case LOC_ARG:
 583           fprintf_filtered (outfile, "arg at offset 0x%lx",
 584                             SYMBOL_VALUE (symbol));
 585           break;
 586
 587         case LOC_REF_ARG:
 588           fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
 589           break;
 590
 591         case LOC_REGPARM_ADDR:
 592           fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
 593           break;
 594
 595         case LOC_LOCAL:
 596           fprintf_filtered (outfile, "local at offset 0x%lx",
 597                             SYMBOL_VALUE (symbol));
 598           break;
 599
 600         case LOC_TYPEDEF:
 601           break;
 602
 603         case LOC_LABEL:
 604           fprintf_filtered (outfile, "label at ");
 605           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 606                           outfile);
 607           if (section)
 608             fprintf_filtered (outfile, " section %s",
 609                               bfd_section_name (section->the_bfd_section->owner,
 610                                                 section->the_bfd_section));
 611           break;
 612
 613         case LOC_BLOCK:
 614           fprintf_filtered (outfile, "block object ");
 615           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 616           fprintf_filtered (outfile, ", ");
 617           fputs_filtered (paddress (gdbarch,
 618                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 619                           outfile);
 620           fprintf_filtered (outfile, "..");
 621           fputs_filtered (paddress (gdbarch,
 622                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 623                           outfile);
 624           if (section)
 625             fprintf_filtered (outfile, " section %s",
 626                               bfd_section_name (section->the_bfd_section->owner,
 627                                                 section->the_bfd_section));
 628           break;
 629
 630         case LOC_COMPUTED:
 631           fprintf_filtered (outfile, "computed at runtime");
 632           break;
 633
 634         case LOC_UNRESOLVED:
 635           fprintf_filtered (outfile, "unresolved");
 636           break;
 637
 638         case LOC_OPTIMIZED_OUT:
 639           fprintf_filtered (outfile, "optimized out");
 640           break;
 641
 642         default:
 643           fprintf_filtered (outfile, "botched symbol class %x",
 644                             SYMBOL_CLASS (symbol));
 645           break;
 646         }
 647     }
 648   fprintf_filtered (outfile, "\n");
 649   return 1;
 650 }
 651
 652 void
 653 maintenance_print_msymbols (char *args, int from_tty)
 654 {
 655   char **argv;
 656   struct ui_file *outfile;
 657   struct cleanup *cleanups;
 658   char *filename = DEV_TTY;
 659   char *symname = NULL;
 660   struct program_space *pspace;
 661   struct objfile *objfile;
 662
 663   struct stat sym_st, obj_st;
 664
 665   dont_repeat ();
 666
 667   if (args == NULL)
 668     {
 669       error (_("print-msymbols takes an output file name and optional symbol file name"));
 670     }
 671   argv = gdb_buildargv (args);
 672   cleanups = make_cleanup_freeargv (argv);
 673
 674   if (argv[0] != NULL)
 675     {
 676       filename = argv[0];
 677       /* If a second arg is supplied, it is a source file name to match on */
 678       if (argv[1] != NULL)
 679         {
 680           symname = xfullpath (argv[1]);
 681           make_cleanup (xfree, symname);
 682           if (symname && stat (symname, &sym_st))
 683             perror_with_name (symname);
 684         }
 685     }
 686
 687   filename = tilde_expand (filename);
 688   make_cleanup (xfree, filename);
 689
 690   outfile = gdb_fopen (filename, FOPEN_WT);
 691   if (outfile == 0)
 692     perror_with_name (filename);
 693   make_cleanup_ui_file_delete (outfile);
 694
 695   immediate_quit++;
 696   ALL_PSPACES (pspace)
 697     ALL_PSPACE_OBJFILES (pspace, objfile)
 698       if (symname == NULL
 699           || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
 700         dump_msymbols (objfile, outfile);
 701   immediate_quit--;
 702   fprintf_filtered (outfile, "\n\n");
 703   do_cleanups (cleanups);
 704 }
 705
 706 void
 707 maintenance_print_objfiles (char *ignore, int from_tty)
 708 {
 709   struct program_space *pspace;
 710   struct objfile *objfile;
 711
 712   dont_repeat ();
 713
 714   immediate_quit++;
 715   ALL_PSPACES (pspace)
 716     ALL_PSPACE_OBJFILES (pspace, objfile)
 717       dump_objfile (objfile);
 718   immediate_quit--;
 719 }
 720
 721
 722 /* List all the symbol tables whose names match REGEXP (optional).  */
 723 void
 724 maintenance_info_symtabs (char *regexp, int from_tty)
 725 {
 726   struct program_space *pspace;
 727   struct objfile *objfile;
 728
 729   if (regexp)
 730     re_comp (regexp);
 731
 732   ALL_PSPACES (pspace)
 733     ALL_PSPACE_OBJFILES (pspace, objfile)
 734     {
 735       struct symtab *symtab;
 736
 737       /* We don't want to print anything for this objfile until we
 738          actually find a symtab whose name matches.  */
 739       int printed_objfile_start = 0;
 740
 741       ALL_OBJFILE_SYMTABS (objfile, symtab)
 742         {
 743           QUIT;
 744
 745           if (! regexp
 746               || re_exec (symtab->filename))
 747             {
 748               if (! printed_objfile_start)
 749                 {
 750                   printf_filtered ("{ objfile %s ", objfile->name);
 751                   wrap_here ("  ");
 752                   printf_filtered ("((struct objfile *) %s)\n",
 753                                    host_address_to_string (objfile));
 754                   printed_objfile_start = 1;
 755                 }
 756
 757               printf_filtered ("        { symtab %s ", symtab->filename);
 758               wrap_here ("    ");
 759               printf_filtered ("((struct symtab *) %s)\n",
 760                                host_address_to_string (symtab));
 761               printf_filtered ("          dirname %s\n",
 762                                symtab->dirname ? symtab->dirname : "(null)");
 763               printf_filtered ("          fullname %s\n",
 764                                symtab->fullname ? symtab->fullname : "(null)");
 765               printf_filtered ("          blockvector ((struct blockvector *) %s)%s\n",
 766                                host_address_to_string (symtab->blockvector),
 767                                symtab->primary ? " (primary)" : "");
 768               printf_filtered ("          linetable ((struct linetable *) %s)\n",
 769                                host_address_to_string (symtab->linetable));
 770               printf_filtered ("          debugformat %s\n", symtab->debugformat);
 771               printf_filtered ("        }\n");
 772             }
 773         }
 774
 775       if (printed_objfile_start)
 776         printf_filtered ("}\n");
 777     }
 778 }
 779 \f
 780
 781 /* Return the nexting depth of a block within other blocks in its symtab.  */
 782
 783 static int
 784 block_depth (struct block *block)
 785 {
 786   int i = 0;
 787
 788   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 789     {
 790       i++;
 791     }
 792   return i;
 793 }
 794 \f
 795
 796 /* Do early runtime initializations. */
 797 void
 798 _initialize_symmisc (void)
 799 {
 800   std_in = stdin;
 801   std_out = stdout;
 802   std_err = stderr;
 803 }