gdb/symmisc.c

   1 /* Do various things to symbol tables (other than lookup), for GDB.
   2
   3    Copyright (C) 1986-2015 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "gdbtypes.h"
  23 #include "bfd.h"
  24 #include "filenames.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "breakpoint.h"
  28 #include "command.h"
  29 #include "gdb_obstack.h"
  30 #include "language.h"
  31 #include "bcache.h"
  32 #include "block.h"
  33 #include "gdb_regex.h"
  34 #include <sys/stat.h>
  35 #include "dictionary.h"
  36 #include "typeprint.h"
  37 #include "gdbcmd.h"
  38 #include "source.h"
  39 #include "readline/readline.h"
  40
  41 #include "psymtab.h"
  42
  43 #ifndef DEV_TTY
  44 #define DEV_TTY "/dev/tty"
  45 #endif
  46
  47 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
  48    when calling functions that take FILE *'s from the debugger.
  49    So we make a variable which has the same value and which is accessible when
  50    debugging GDB with itself.  Because stdin et al need not be constants,
  51    we initialize them in the _initialize_symmisc function at the bottom
  52    of the file.  */
  53 FILE *std_in;
  54 FILE *std_out;
  55 FILE *std_err;
  56
  57 /* Prototypes for local functions */
  58
  59 static int block_depth (struct block *);
  60
  61 void _initialize_symmisc (void);
  62
  63 struct print_symbol_args
  64   {
  65     struct gdbarch *gdbarch;
  66     struct symbol *symbol;
  67     int depth;
  68     struct ui_file *outfile;
  69   };
  70
  71 static int print_symbol (void *);
  72 \f
  73
  74 void
  75 print_symbol_bcache_statistics (void)
  76 {
  77   struct program_space *pspace;
  78   struct objfile *objfile;
  79
  80   ALL_PSPACES (pspace)
  81     ALL_PSPACE_OBJFILES (pspace, objfile)
  82   {
  83     QUIT;
  84     printf_filtered (_("Byte cache statistics for '%s':\n"),
  85                      objfile_name (objfile));
  86     print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
  87                              "partial symbol cache");
  88     print_bcache_statistics (objfile->per_bfd->macro_cache,
  89                              "preprocessor macro cache");
  90     print_bcache_statistics (objfile->per_bfd->filename_cache,
  91                              "file name cache");
  92   }
  93 }
  94
  95 void
  96 print_objfile_statistics (void)
  97 {
  98   struct program_space *pspace;
  99   struct objfile *objfile;
 100   struct compunit_symtab *cu;
 101   struct symtab *s;
 102   int i, linetables, blockvectors;
 103
 104   ALL_PSPACES (pspace)
 105     ALL_PSPACE_OBJFILES (pspace, objfile)
 106   {
 107     QUIT;
 108     printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile));
 109     if (OBJSTAT (objfile, n_stabs) > 0)
 110       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
 111                        OBJSTAT (objfile, n_stabs));
 112     if (objfile->per_bfd->n_minsyms > 0)
 113       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
 114                        objfile->per_bfd->n_minsyms);
 115     if (OBJSTAT (objfile, n_psyms) > 0)
 116       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
 117                        OBJSTAT (objfile, n_psyms));
 118     if (OBJSTAT (objfile, n_syms) > 0)
 119       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
 120                        OBJSTAT (objfile, n_syms));
 121     if (OBJSTAT (objfile, n_types) > 0)
 122       printf_filtered (_("  Number of \"types\" defined: %d\n"),
 123                        OBJSTAT (objfile, n_types));
 124     if (objfile->sf)
 125       objfile->sf->qf->print_stats (objfile);
 126     i = linetables = blockvectors = 0;
 127     ALL_OBJFILE_FILETABS (objfile, cu, s)
 128       {
 129         i++;
 130         if (SYMTAB_LINETABLE (s) != NULL)
 131           linetables++;
 132       }
 133     ALL_OBJFILE_COMPUNITS (objfile, cu)
 134       blockvectors++;
 135     printf_filtered (_("  Number of symbol tables: %d\n"), i);
 136     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
 137                      linetables);
 138     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
 139                      blockvectors);
 140
 141     if (OBJSTAT (objfile, sz_strtab) > 0)
 142       printf_filtered (_("  Space used by a.out string tables: %d\n"),
 143                        OBJSTAT (objfile, sz_strtab));
 144     printf_filtered (_("  Total memory used for objfile obstack: %s\n"),
 145                      pulongest (obstack_memory_used (&objfile
 146                                                      ->objfile_obstack)));
 147     printf_filtered (_("  Total memory used for BFD obstack: %s\n"),
 148                      pulongest (obstack_memory_used (&objfile->per_bfd
 149                                                      ->storage_obstack)));
 150     printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
 151                      bcache_memory_used (psymbol_bcache_get_bcache
 152                                           (objfile->psymbol_cache)));
 153     printf_filtered (_("  Total memory used for macro cache: %d\n"),
 154                      bcache_memory_used (objfile->per_bfd->macro_cache));
 155     printf_filtered (_("  Total memory used for file name cache: %d\n"),
 156                      bcache_memory_used (objfile->per_bfd->filename_cache));
 157   }
 158 }
 159
 160 static void
 161 dump_objfile (struct objfile *objfile)
 162 {
 163   struct compunit_symtab *cust;
 164   struct symtab *symtab;
 165
 166   printf_filtered ("\nObject file %s:  ", objfile_name (objfile));
 167   printf_filtered ("Objfile at ");
 168   gdb_print_host_address (objfile, gdb_stdout);
 169   printf_filtered (", bfd at ");
 170   gdb_print_host_address (objfile->obfd, gdb_stdout);
 171   printf_filtered (", %d minsyms\n\n",
 172                    objfile->per_bfd->minimal_symbol_count);
 173
 174   if (objfile->sf)
 175     objfile->sf->qf->dump (objfile);
 176
 177   if (objfile->compunit_symtabs != NULL)
 178     {
 179       printf_filtered ("Symtabs:\n");
 180       ALL_OBJFILE_FILETABS (objfile, cust, symtab)
 181         {
 182           printf_filtered ("%s at ", symtab_to_filename_for_display (symtab));
 183           gdb_print_host_address (symtab, gdb_stdout);
 184           printf_filtered (", ");
 185           if (SYMTAB_OBJFILE (symtab) != objfile)
 186             {
 187               printf_filtered ("NOT ON CHAIN!  ");
 188             }
 189           wrap_here ("  ");
 190         }
 191       printf_filtered ("\n\n");
 192     }
 193 }
 194
 195 /* Print minimal symbols from this objfile.  */
 196
 197 static void
 198 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 199 {
 200   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 201   struct minimal_symbol *msymbol;
 202   int index;
 203   char ms_type;
 204
 205   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
 206   if (objfile->per_bfd->minimal_symbol_count == 0)
 207     {
 208       fprintf_filtered (outfile, "No minimal symbols found.\n");
 209       return;
 210     }
 211   index = 0;
 212   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
 213     {
 214       struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
 215
 216       switch (MSYMBOL_TYPE (msymbol))
 217         {
 218         case mst_unknown:
 219           ms_type = 'u';
 220           break;
 221         case mst_text:
 222           ms_type = 'T';
 223           break;
 224         case mst_text_gnu_ifunc:
 225           ms_type = 'i';
 226           break;
 227         case mst_solib_trampoline:
 228           ms_type = 'S';
 229           break;
 230         case mst_data:
 231           ms_type = 'D';
 232           break;
 233         case mst_bss:
 234           ms_type = 'B';
 235           break;
 236         case mst_abs:
 237           ms_type = 'A';
 238           break;
 239         case mst_file_text:
 240           ms_type = 't';
 241           break;
 242         case mst_file_data:
 243           ms_type = 'd';
 244           break;
 245         case mst_file_bss:
 246           ms_type = 'b';
 247           break;
 248         default:
 249           ms_type = '?';
 250           break;
 251         }
 252       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
 253       fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
 254                                                                 msymbol)),
 255                       outfile);
 256       fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
 257       if (section)
 258         {
 259           if (section->the_bfd_section != NULL)
 260             fprintf_filtered (outfile, " section %s",
 261                               bfd_section_name (objfile->obfd,
 262                                                 section->the_bfd_section));
 263           else
 264             fprintf_filtered (outfile, " spurious section %ld",
 265                               (long) (section - objfile->sections));
 266         }
 267       if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 268         {
 269           fprintf_filtered (outfile, "  %s", MSYMBOL_DEMANGLED_NAME (msymbol));
 270         }
 271       if (msymbol->filename)
 272         fprintf_filtered (outfile, "  %s", msymbol->filename);
 273       fputs_filtered ("\n", outfile);
 274       index++;
 275     }
 276   if (objfile->per_bfd->minimal_symbol_count != index)
 277     {
 278       warning (_("internal error:  minimal symbol count %d != %d"),
 279                objfile->per_bfd->minimal_symbol_count, index);
 280     }
 281   fprintf_filtered (outfile, "\n");
 282 }
 283
 284 static void
 285 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 286                struct ui_file *outfile)
 287 {
 288   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 289   int i;
 290   struct dict_iterator iter;
 291   int len;
 292   struct linetable *l;
 293   const struct blockvector *bv;
 294   struct symbol *sym;
 295   struct block *b;
 296   int depth;
 297
 298   fprintf_filtered (outfile, "\nSymtab for file %s\n",
 299                     symtab_to_filename_for_display (symtab));
 300   if (SYMTAB_DIRNAME (symtab) != NULL)
 301     fprintf_filtered (outfile, "Compilation directory is %s\n",
 302                       SYMTAB_DIRNAME (symtab));
 303   fprintf_filtered (outfile, "Read from object file %s (",
 304                     objfile_name (objfile));
 305   gdb_print_host_address (objfile, outfile);
 306   fprintf_filtered (outfile, ")\n");
 307   fprintf_filtered (outfile, "Language: %s\n",
 308                     language_str (symtab->language));
 309
 310   /* First print the line table.  */
 311   l = SYMTAB_LINETABLE (symtab);
 312   if (l)
 313     {
 314       fprintf_filtered (outfile, "\nLine table:\n\n");
 315       len = l->nitems;
 316       for (i = 0; i < len; i++)
 317         {
 318           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
 319           fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
 320           fprintf_filtered (outfile, "\n");
 321         }
 322     }
 323   /* Now print the block info, but only for compunit symtabs since we will
 324      print lots of duplicate info otherwise.  */
 325   if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)))
 326     {
 327       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 328       bv = SYMTAB_BLOCKVECTOR (symtab);
 329       len = BLOCKVECTOR_NBLOCKS (bv);
 330       for (i = 0; i < len; i++)
 331         {
 332           b = BLOCKVECTOR_BLOCK (bv, i);
 333           depth = block_depth (b) * 2;
 334           print_spaces (depth, outfile);
 335           fprintf_filtered (outfile, "block #%03d, object at ", i);
 336           gdb_print_host_address (b, outfile);
 337           if (BLOCK_SUPERBLOCK (b))
 338             {
 339               fprintf_filtered (outfile, " under ");
 340               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
 341             }
 342           /* drow/2002-07-10: We could save the total symbols count
 343              even if we're using a hashtable, but nothing else but this message
 344              wants it.  */
 345           fprintf_filtered (outfile, ", %d syms/buckets in ",
 346                             dict_size (BLOCK_DICT (b)));
 347           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 348           fprintf_filtered (outfile, "..");
 349           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 350           if (BLOCK_FUNCTION (b))
 351             {
 352               fprintf_filtered (outfile, ", function %s",
 353                                 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
 354               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 355                 {
 356                   fprintf_filtered (outfile, ", %s",
 357                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 358                 }
 359             }
 360           fprintf_filtered (outfile, "\n");
 361           /* Now print each symbol in this block (in no particular order, if
 362              we're using a hashtable).  Note that we only want this
 363              block, not any blocks from included symtabs.  */
 364           ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
 365             {
 366               struct print_symbol_args s;
 367
 368               s.gdbarch = gdbarch;
 369               s.symbol = sym;
 370               s.depth = depth + 1;
 371               s.outfile = outfile;
 372               catch_errors (print_symbol, &s, "Error printing symbol:\n",
 373                             RETURN_MASK_ERROR);
 374             }
 375         }
 376       fprintf_filtered (outfile, "\n");
 377     }
 378   else
 379     {
 380       fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
 381     }
 382 }
 383
 384 static void
 385 dump_symtab (struct objfile *objfile, struct symtab *symtab,
 386              struct ui_file *outfile)
 387 {
 388   /* Set the current language to the language of the symtab we're dumping
 389      because certain routines used during dump_symtab() use the current
 390      language to print an image of the symbol.  We'll restore it later.
 391      But use only real languages, not placeholders.  */
 392   if (symtab->language != language_unknown
 393       && symtab->language != language_auto)
 394     {
 395       enum language saved_lang;
 396
 397       saved_lang = set_language (symtab->language);
 398
 399       dump_symtab_1 (objfile, symtab, outfile);
 400
 401       set_language (saved_lang);
 402     }
 403   else
 404     dump_symtab_1 (objfile, symtab, outfile);
 405 }
 406
 407 static void
 408 maintenance_print_symbols (char *args, int from_tty)
 409 {
 410   char **argv;
 411   struct ui_file *outfile;
 412   struct cleanup *cleanups;
 413   char *symname = NULL;
 414   char *filename = DEV_TTY;
 415   struct objfile *objfile;
 416   struct compunit_symtab *cu;
 417   struct symtab *s;
 418
 419   dont_repeat ();
 420
 421   if (args == NULL)
 422     {
 423       error (_("Arguments missing: an output file name "
 424                "and an optional symbol file name"));
 425     }
 426   argv = gdb_buildargv (args);
 427   cleanups = make_cleanup_freeargv (argv);
 428
 429   if (argv[0] != NULL)
 430     {
 431       filename = argv[0];
 432       /* If a second arg is supplied, it is a source file name to match on.  */
 433       if (argv[1] != NULL)
 434         {
 435           symname = argv[1];
 436         }
 437     }
 438
 439   filename = tilde_expand (filename);
 440   make_cleanup (xfree, filename);
 441
 442   outfile = gdb_fopen (filename, FOPEN_WT);
 443   if (outfile == 0)
 444     perror_with_name (filename);
 445   make_cleanup_ui_file_delete (outfile);
 446
 447   ALL_FILETABS (objfile, cu, s)
 448     {
 449       QUIT;
 450       if (symname == NULL
 451           || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0)
 452         dump_symtab (objfile, s, outfile);
 453     }
 454   do_cleanups (cleanups);
 455 }
 456
 457 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 458    far to indent.  ARGS is really a struct print_symbol_args *, but is
 459    declared as char * to get it past catch_errors.  Returns 0 for error,
 460    1 for success.  */
 461
 462 static int
 463 print_symbol (void *args)
 464 {
 465   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
 466   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 467   int depth = ((struct print_symbol_args *) args)->depth;
 468   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 469   struct obj_section *section;
 470
 471   if (SYMBOL_OBJFILE_OWNED (symbol))
 472     section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
 473   else
 474     section = NULL;
 475
 476   print_spaces (depth, outfile);
 477   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 478     {
 479       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 480       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 481                       outfile);
 482       if (section)
 483         fprintf_filtered (outfile, " section %s\n",
 484                           bfd_section_name (section->the_bfd_section->owner,
 485                                             section->the_bfd_section));
 486       else
 487         fprintf_filtered (outfile, "\n");
 488       return 1;
 489     }
 490   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 491     {
 492       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 493         {
 494           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 495                          &type_print_raw_options);
 496         }
 497       else
 498         {
 499           fprintf_filtered (outfile, "%s %s = ",
 500                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 501                           ? "enum"
 502                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 503                         ? "struct" : "union")),
 504                             SYMBOL_LINKAGE_NAME (symbol));
 505           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 506                          &type_print_raw_options);
 507         }
 508       fprintf_filtered (outfile, ";\n");
 509     }
 510   else
 511     {
 512       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 513         fprintf_filtered (outfile, "typedef ");
 514       if (SYMBOL_TYPE (symbol))
 515         {
 516           /* Print details of types, except for enums where it's clutter.  */
 517           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 518                          outfile,
 519                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 520                          depth,
 521                          &type_print_raw_options);
 522           fprintf_filtered (outfile, "; ");
 523         }
 524       else
 525         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 526
 527       switch (SYMBOL_CLASS (symbol))
 528         {
 529         case LOC_CONST:
 530           fprintf_filtered (outfile, "const %s (%s)",
 531                             plongest (SYMBOL_VALUE (symbol)),
 532                             hex_string (SYMBOL_VALUE (symbol)));
 533           break;
 534
 535         case LOC_CONST_BYTES:
 536           {
 537             unsigned i;
 538             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 539
 540             fprintf_filtered (outfile, "const %u hex bytes:",
 541                               TYPE_LENGTH (type));
 542             for (i = 0; i < TYPE_LENGTH (type); i++)
 543               fprintf_filtered (outfile, " %02x",
 544                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 545           }
 546           break;
 547
 548         case LOC_STATIC:
 549           fprintf_filtered (outfile, "static at ");
 550           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 551                           outfile);
 552           if (section)
 553             fprintf_filtered (outfile, " section %s",
 554                               bfd_section_name (section->the_bfd_section->owner,
 555                                                 section->the_bfd_section));
 556           break;
 557
 558         case LOC_REGISTER:
 559           if (SYMBOL_IS_ARGUMENT (symbol))
 560             fprintf_filtered (outfile, "parameter register %s",
 561                               plongest (SYMBOL_VALUE (symbol)));
 562           else
 563             fprintf_filtered (outfile, "register %s",
 564                               plongest (SYMBOL_VALUE (symbol)));
 565           break;
 566
 567         case LOC_ARG:
 568           fprintf_filtered (outfile, "arg at offset %s",
 569                             hex_string (SYMBOL_VALUE (symbol)));
 570           break;
 571
 572         case LOC_REF_ARG:
 573           fprintf_filtered (outfile, "reference arg at %s",
 574                             hex_string (SYMBOL_VALUE (symbol)));
 575           break;
 576
 577         case LOC_REGPARM_ADDR:
 578           fprintf_filtered (outfile, "address parameter register %s",
 579                             plongest (SYMBOL_VALUE (symbol)));
 580           break;
 581
 582         case LOC_LOCAL:
 583           fprintf_filtered (outfile, "local at offset %s",
 584                             hex_string (SYMBOL_VALUE (symbol)));
 585           break;
 586
 587         case LOC_TYPEDEF:
 588           break;
 589
 590         case LOC_LABEL:
 591           fprintf_filtered (outfile, "label at ");
 592           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 593                           outfile);
 594           if (section)
 595             fprintf_filtered (outfile, " section %s",
 596                               bfd_section_name (section->the_bfd_section->owner,
 597                                                 section->the_bfd_section));
 598           break;
 599
 600         case LOC_BLOCK:
 601           fprintf_filtered (outfile, "block object ");
 602           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 603           fprintf_filtered (outfile, ", ");
 604           fputs_filtered (paddress (gdbarch,
 605                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 606                           outfile);
 607           fprintf_filtered (outfile, "..");
 608           fputs_filtered (paddress (gdbarch,
 609                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 610                           outfile);
 611           if (section)
 612             fprintf_filtered (outfile, " section %s",
 613                               bfd_section_name (section->the_bfd_section->owner,
 614                                                 section->the_bfd_section));
 615           break;
 616
 617         case LOC_COMPUTED:
 618           fprintf_filtered (outfile, "computed at runtime");
 619           break;
 620
 621         case LOC_UNRESOLVED:
 622           fprintf_filtered (outfile, "unresolved");
 623           break;
 624
 625         case LOC_OPTIMIZED_OUT:
 626           fprintf_filtered (outfile, "optimized out");
 627           break;
 628
 629         default:
 630           fprintf_filtered (outfile, "botched symbol class %x",
 631                             SYMBOL_CLASS (symbol));
 632           break;
 633         }
 634     }
 635   fprintf_filtered (outfile, "\n");
 636   return 1;
 637 }
 638
 639 static void
 640 maintenance_print_msymbols (char *args, int from_tty)
 641 {
 642   char **argv;
 643   struct ui_file *outfile;
 644   struct cleanup *cleanups;
 645   char *filename = DEV_TTY;
 646   char *symname = NULL;
 647   struct program_space *pspace;
 648   struct objfile *objfile;
 649
 650   struct stat sym_st, obj_st;
 651
 652   dont_repeat ();
 653
 654   if (args == NULL)
 655     {
 656       error (_("print-msymbols takes an output file "
 657                "name and optional symbol file name"));
 658     }
 659   argv = gdb_buildargv (args);
 660   cleanups = make_cleanup_freeargv (argv);
 661
 662   if (argv[0] != NULL)
 663     {
 664       filename = argv[0];
 665       /* If a second arg is supplied, it is a source file name to match on.  */
 666       if (argv[1] != NULL)
 667         {
 668           symname = gdb_realpath (argv[1]);
 669           make_cleanup (xfree, symname);
 670           if (symname && stat (symname, &sym_st))
 671             perror_with_name (symname);
 672         }
 673     }
 674
 675   filename = tilde_expand (filename);
 676   make_cleanup (xfree, filename);
 677
 678   outfile = gdb_fopen (filename, FOPEN_WT);
 679   if (outfile == 0)
 680     perror_with_name (filename);
 681   make_cleanup_ui_file_delete (outfile);
 682
 683   ALL_PSPACES (pspace)
 684     ALL_PSPACE_OBJFILES (pspace, objfile)
 685       {
 686         QUIT;
 687         if (symname == NULL || (!stat (objfile_name (objfile), &obj_st)
 688                                 && sym_st.st_dev == obj_st.st_dev
 689                                 && sym_st.st_ino == obj_st.st_ino))
 690           dump_msymbols (objfile, outfile);
 691       }
 692   fprintf_filtered (outfile, "\n\n");
 693   do_cleanups (cleanups);
 694 }
 695
 696 static void
 697 maintenance_print_objfiles (char *regexp, int from_tty)
 698 {
 699   struct program_space *pspace;
 700   struct objfile *objfile;
 701
 702   dont_repeat ();
 703
 704   if (regexp)
 705     re_comp (regexp);
 706
 707   ALL_PSPACES (pspace)
 708     ALL_PSPACE_OBJFILES (pspace, objfile)
 709       {
 710         QUIT;
 711         if (! regexp
 712             || re_exec (objfile_name (objfile)))
 713           dump_objfile (objfile);
 714       }
 715 }
 716
 717 /* List all the symbol tables whose names match REGEXP (optional).  */
 718
 719 static void
 720 maintenance_info_symtabs (char *regexp, int from_tty)
 721 {
 722   struct program_space *pspace;
 723   struct objfile *objfile;
 724
 725   dont_repeat ();
 726
 727   if (regexp)
 728     re_comp (regexp);
 729
 730   ALL_PSPACES (pspace)
 731     ALL_PSPACE_OBJFILES (pspace, objfile)
 732     {
 733       struct compunit_symtab *cust;
 734       struct symtab *symtab;
 735
 736       /* We don't want to print anything for this objfile until we
 737          actually find a symtab whose name matches.  */
 738       int printed_objfile_start = 0;
 739
 740       ALL_OBJFILE_COMPUNITS (objfile, cust)
 741         {
 742           int printed_compunit_symtab_start = 0;
 743
 744           ALL_COMPUNIT_FILETABS (cust, symtab)
 745             {
 746               QUIT;
 747
 748               if (! regexp
 749                   || re_exec (symtab_to_filename_for_display (symtab)))
 750                 {
 751                   if (! printed_objfile_start)
 752                     {
 753                       printf_filtered ("{ objfile %s ", objfile_name (objfile));
 754                       wrap_here ("  ");
 755                       printf_filtered ("((struct objfile *) %s)\n",
 756                                        host_address_to_string (objfile));
 757                       printed_objfile_start = 1;
 758                     }
 759                   if (! printed_compunit_symtab_start)
 760                     {
 761                       printf_filtered ("  { ((struct compunit_symtab *) %s)\n",
 762                                        host_address_to_string (cust));
 763                       printf_filtered ("    debugformat %s\n",
 764                                        COMPUNIT_DEBUGFORMAT (cust));
 765                       printf_filtered ("    producer %s\n",
 766                                        COMPUNIT_PRODUCER (cust) != NULL
 767                                        ? COMPUNIT_PRODUCER (cust)
 768                                        : "(null)");
 769                       printf_filtered ("    dirname %s\n",
 770                                        COMPUNIT_DIRNAME (cust) != NULL
 771                                        ? COMPUNIT_DIRNAME (cust)
 772                                        : "(null)");
 773                       printf_filtered ("    blockvector"
 774                                        " ((struct blockvector *) %s)\n",
 775                                        host_address_to_string
 776                                          (COMPUNIT_BLOCKVECTOR (cust)));
 777                       printed_compunit_symtab_start = 1;
 778                     }
 779
 780                   printf_filtered ("\t{ symtab %s ",
 781                                    symtab_to_filename_for_display (symtab));
 782                   wrap_here ("    ");
 783                   printf_filtered ("((struct symtab *) %s)\n",
 784                                    host_address_to_string (symtab));
 785                   printf_filtered ("\t  fullname %s\n",
 786                                    symtab->fullname != NULL
 787                                    ? symtab->fullname
 788                                    : "(null)");
 789                   printf_filtered ("\t  "
 790                                    "linetable ((struct linetable *) %s)\n",
 791                                    host_address_to_string (symtab->linetable));
 792                   printf_filtered ("\t}\n");
 793                 }
 794             }
 795
 796           if (printed_compunit_symtab_start)
 797             printf_filtered ("  }\n");
 798         }
 799
 800       if (printed_objfile_start)
 801         printf_filtered ("}\n");
 802     }
 803 }
 804
 805 /* Check consistency of symtabs.
 806    An example of what this checks for is NULL blockvectors.
 807    They can happen if there's a bug during debug info reading.
 808    GDB assumes they are always non-NULL.
 809
 810    Note: This does not check for psymtab vs symtab consistency.
 811    Use "maint check-psymtabs" for that.  */
 812
 813 static void
 814 maintenance_check_symtabs (char *ignore, int from_tty)
 815 {
 816   struct program_space *pspace;
 817   struct objfile *objfile;
 818
 819   ALL_PSPACES (pspace)
 820     ALL_PSPACE_OBJFILES (pspace, objfile)
 821     {
 822       struct compunit_symtab *cust;
 823
 824       /* We don't want to print anything for this objfile until we
 825          actually find something worth printing.  */
 826       int printed_objfile_start = 0;
 827
 828       ALL_OBJFILE_COMPUNITS (objfile, cust)
 829         {
 830           int found_something = 0;
 831           struct symtab *symtab = compunit_primary_filetab (cust);
 832
 833           QUIT;
 834
 835           if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 836             found_something = 1;
 837           /* Add more checks here.  */
 838
 839           if (found_something)
 840             {
 841               if (! printed_objfile_start)
 842                 {
 843                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
 844                   wrap_here ("  ");
 845                   printf_filtered ("((struct objfile *) %s)\n",
 846                                    host_address_to_string (objfile));
 847                   printed_objfile_start = 1;
 848                 }
 849               printf_filtered ("  { symtab %s\n",
 850                                symtab_to_filename_for_display (symtab));
 851               if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 852                 printf_filtered ("    NULL blockvector\n");
 853               printf_filtered ("  }\n");
 854             }
 855         }
 856
 857       if (printed_objfile_start)
 858         printf_filtered ("}\n");
 859     }
 860 }
 861
 862 /* Helper function for maintenance_expand_symtabs.
 863    This is the name_matcher function for expand_symtabs_matching.  */
 864
 865 static int
 866 maintenance_expand_name_matcher (const char *symname, void *data)
 867 {
 868   /* Since we're not searching on symbols, just return TRUE.  */
 869   return 1;
 870 }
 871
 872 /* Helper function for maintenance_expand_symtabs.
 873    This is the file_matcher function for expand_symtabs_matching.  */
 874
 875 static int
 876 maintenance_expand_file_matcher (const char *filename, void *data,
 877                                  int basenames)
 878 {
 879   const char *regexp = data;
 880
 881   QUIT;
 882
 883   /* KISS: Only apply the regexp to the complete file name.  */
 884   if (basenames)
 885     return 0;
 886
 887   if (regexp == NULL || re_exec (filename))
 888     return 1;
 889
 890   return 0;
 891 }
 892
 893 /* Expand all symbol tables whose name matches an optional regexp.  */
 894
 895 static void
 896 maintenance_expand_symtabs (char *args, int from_tty)
 897 {
 898   struct program_space *pspace;
 899   struct objfile *objfile;
 900   struct cleanup *cleanups;
 901   char **argv;
 902   char *regexp = NULL;
 903
 904   /* We use buildargv here so that we handle spaces in the regexp
 905      in a way that allows adding more arguments later.  */
 906   argv = gdb_buildargv (args);
 907   cleanups = make_cleanup_freeargv (argv);
 908
 909   if (argv != NULL)
 910     {
 911       if (argv[0] != NULL)
 912         {
 913           regexp = argv[0];
 914           if (argv[1] != NULL)
 915             error (_("Extra arguments after regexp."));
 916         }
 917     }
 918
 919   if (regexp)
 920     re_comp (regexp);
 921
 922   ALL_PSPACES (pspace)
 923     ALL_PSPACE_OBJFILES (pspace, objfile)
 924     {
 925       if (objfile->sf)
 926         {
 927           objfile->sf->qf->expand_symtabs_matching
 928             (objfile, maintenance_expand_file_matcher,
 929              maintenance_expand_name_matcher, ALL_DOMAIN, regexp);
 930         }
 931     }
 932
 933   do_cleanups (cleanups);
 934 }
 935 \f
 936
 937 /* Return the nexting depth of a block within other blocks in its symtab.  */
 938
 939 static int
 940 block_depth (struct block *block)
 941 {
 942   int i = 0;
 943
 944   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 945     {
 946       i++;
 947     }
 948   return i;
 949 }
 950 \f
 951
 952 /* Do early runtime initializations.  */
 953
 954 void
 955 _initialize_symmisc (void)
 956 {
 957   std_in = stdin;
 958   std_out = stdout;
 959   std_err = stderr;
 960
 961   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
 962 Print dump of current symbol definitions.\n\
 963 Entries in the full symbol table are dumped to file OUTFILE.\n\
 964 If a SOURCE file is specified, dump only that file's symbols."),
 965            &maintenanceprintlist);
 966
 967   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
 968 Print dump of current minimal symbol definitions.\n\
 969 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
 970 If a SOURCE file is specified, dump only that file's minimal symbols."),
 971            &maintenanceprintlist);
 972
 973   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
 974            _("Print dump of current object file definitions.\n\
 975 With an argument REGEXP, list the object files with matching names."),
 976            &maintenanceprintlist);
 977
 978   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
 979 List the full symbol tables for all object files.\n\
 980 This does not include information about individual symbols, blocks, or\n\
 981 linetables --- just the symbol table structures themselves.\n\
 982 With an argument REGEXP, list the symbol tables with matching names."),
 983            &maintenanceinfolist);
 984
 985   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
 986            _("\
 987 Check consistency of currently expanded symtabs."),
 988            &maintenancelist);
 989
 990   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
 991            _("Expand symbol tables.\n\
 992 With an argument REGEXP, only expand the symbol tables with matching names."),
 993            &maintenancelist);
 994 }