gdb/symmisc.c

   1 /* Do various things to symbol tables (other than lookup), for GDB.
   2
   3    Copyright (C) 1986-2013 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 "exceptions.h"
  31 #include "language.h"
  32 #include "bcache.h"
  33 #include "block.h"
  34 #include "gdb_regex.h"
  35 #include <sys/stat.h>
  36 #include "dictionary.h"
  37 #include "typeprint.h"
  38 #include "gdbcmd.h"
  39 #include "source.h"
  40
  41 #include <string.h>
  42 #include "readline/readline.h"
  43
  44 #include "psymtab.h"
  45
  46 #ifndef DEV_TTY
  47 #define DEV_TTY "/dev/tty"
  48 #endif
  49
  50 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
  51    when calling functions that take FILE *'s from the debugger.
  52    So we make a variable which has the same value and which is accessible when
  53    debugging GDB with itself.  Because stdin et al need not be constants,
  54    we initialize them in the _initialize_symmisc function at the bottom
  55    of the file.  */
  56 FILE *std_in;
  57 FILE *std_out;
  58 FILE *std_err;
  59
  60 /* Prototypes for local functions */
  61
  62 static int block_depth (struct block *);
  63
  64 void _initialize_symmisc (void);
  65
  66 struct print_symbol_args
  67   {
  68     struct gdbarch *gdbarch;
  69     struct symbol *symbol;
  70     int depth;
  71     struct ui_file *outfile;
  72   };
  73
  74 static int print_symbol (void *);
  75 \f
  76
  77 void
  78 print_symbol_bcache_statistics (void)
  79 {
  80   struct program_space *pspace;
  81   struct objfile *objfile;
  82
  83   ALL_PSPACES (pspace)
  84     ALL_PSPACE_OBJFILES (pspace, objfile)
  85   {
  86     QUIT;
  87     printf_filtered (_("Byte cache statistics for '%s':\n"),
  88                      objfile_name (objfile));
  89     print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
  90                              "partial symbol cache");
  91     print_bcache_statistics (objfile->per_bfd->macro_cache,
  92                              "preprocessor macro cache");
  93     print_bcache_statistics (objfile->per_bfd->filename_cache,
  94                              "file name cache");
  95   }
  96 }
  97
  98 void
  99 print_objfile_statistics (void)
 100 {
 101   struct program_space *pspace;
 102   struct objfile *objfile;
 103   struct symtab *s;
 104   int i, linetables, blockvectors;
 105
 106   ALL_PSPACES (pspace)
 107     ALL_PSPACE_OBJFILES (pspace, objfile)
 108   {
 109     QUIT;
 110     printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile));
 111     if (OBJSTAT (objfile, n_stabs) > 0)
 112       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
 113                        OBJSTAT (objfile, n_stabs));
 114     if (OBJSTAT (objfile, n_minsyms) > 0)
 115       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
 116                        OBJSTAT (objfile, n_minsyms));
 117     if (OBJSTAT (objfile, n_psyms) > 0)
 118       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
 119                        OBJSTAT (objfile, n_psyms));
 120     if (OBJSTAT (objfile, n_syms) > 0)
 121       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
 122                        OBJSTAT (objfile, n_syms));
 123     if (OBJSTAT (objfile, n_types) > 0)
 124       printf_filtered (_("  Number of \"types\" defined: %d\n"),
 125                        OBJSTAT (objfile, n_types));
 126     if (objfile->sf)
 127       objfile->sf->qf->print_stats (objfile);
 128     i = linetables = blockvectors = 0;
 129     ALL_OBJFILE_SYMTABS (objfile, s)
 130       {
 131         i++;
 132         if (s->linetable != NULL)
 133           linetables++;
 134         if (s->primary == 1)
 135           blockvectors++;
 136       }
 137     printf_filtered (_("  Number of symbol tables: %d\n"), i);
 138     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
 139                      linetables);
 140     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
 141                      blockvectors);
 142
 143     if (OBJSTAT (objfile, sz_strtab) > 0)
 144       printf_filtered (_("  Space used by a.out string tables: %d\n"),
 145                        OBJSTAT (objfile, sz_strtab));
 146     printf_filtered (_("  Total memory used for objfile obstack: %d\n"),
 147                      obstack_memory_used (&objfile->objfile_obstack));
 148     printf_filtered (_("  Total memory used for BFD obstack: %d\n"),
 149                      obstack_memory_used (&objfile->per_bfd->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 symtab *symtab;
 164
 165   printf_filtered ("\nObject file %s:  ", objfile_name (objfile));
 166   printf_filtered ("Objfile at ");
 167   gdb_print_host_address (objfile, gdb_stdout);
 168   printf_filtered (", bfd at ");
 169   gdb_print_host_address (objfile->obfd, gdb_stdout);
 170   printf_filtered (", %d minsyms\n\n",
 171                    objfile->minimal_symbol_count);
 172
 173   if (objfile->sf)
 174     objfile->sf->qf->dump (objfile);
 175
 176   if (objfile->symtabs)
 177     {
 178       printf_filtered ("Symtabs:\n");
 179       for (symtab = objfile->symtabs;
 180            symtab != NULL;
 181            symtab = symtab->next)
 182         {
 183           printf_filtered ("%s at ", symtab_to_filename_for_display (symtab));
 184           gdb_print_host_address (symtab, gdb_stdout);
 185           printf_filtered (", ");
 186           if (symtab->objfile != objfile)
 187             {
 188               printf_filtered ("NOT ON CHAIN!  ");
 189             }
 190           wrap_here ("  ");
 191         }
 192       printf_filtered ("\n\n");
 193     }
 194 }
 195
 196 /* Print minimal symbols from this objfile.  */
 197
 198 static void
 199 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 200 {
 201   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 202   struct minimal_symbol *msymbol;
 203   int index;
 204   char ms_type;
 205
 206   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
 207   if (objfile->minimal_symbol_count == 0)
 208     {
 209       fprintf_filtered (outfile, "No minimal symbols found.\n");
 210       return;
 211     }
 212   index = 0;
 213   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
 214     {
 215       struct obj_section *section = SYMBOL_OBJ_SECTION (objfile, msymbol);
 216
 217       switch (MSYMBOL_TYPE (msymbol))
 218         {
 219         case mst_unknown:
 220           ms_type = 'u';
 221           break;
 222         case mst_text:
 223           ms_type = 'T';
 224           break;
 225         case mst_text_gnu_ifunc:
 226           ms_type = 'i';
 227           break;
 228         case mst_solib_trampoline:
 229           ms_type = 'S';
 230           break;
 231         case mst_data:
 232           ms_type = 'D';
 233           break;
 234         case mst_bss:
 235           ms_type = 'B';
 236           break;
 237         case mst_abs:
 238           ms_type = 'A';
 239           break;
 240         case mst_file_text:
 241           ms_type = 't';
 242           break;
 243         case mst_file_data:
 244           ms_type = 'd';
 245           break;
 246         case mst_file_bss:
 247           ms_type = 'b';
 248           break;
 249         default:
 250           ms_type = '?';
 251           break;
 252         }
 253       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
 254       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)),
 255                       outfile);
 256       fprintf_filtered (outfile, " %s", SYMBOL_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 (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 268         {
 269           fprintf_filtered (outfile, "  %s", SYMBOL_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->minimal_symbol_count != index)
 277     {
 278       warning (_("internal error:  minimal symbol count %d != %d"),
 279                objfile->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   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)
 301     fprintf_filtered (outfile, "Compilation directory is %s\n",
 302                       symtab->dirname);
 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 = 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 primary symtabs since we will
 324      print lots of duplicate info otherwise.  */
 325   if (symtab->primary)
 326     {
 327       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 328       bv = 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 symtab *s;
 417
 418   dont_repeat ();
 419
 420   if (args == NULL)
 421     {
 422       error (_("Arguments missing: an output file name "
 423                "and an optional symbol file name"));
 424     }
 425   argv = gdb_buildargv (args);
 426   cleanups = make_cleanup_freeargv (argv);
 427
 428   if (argv[0] != NULL)
 429     {
 430       filename = argv[0];
 431       /* If a second arg is supplied, it is a source file name to match on.  */
 432       if (argv[1] != NULL)
 433         {
 434           symname = argv[1];
 435         }
 436     }
 437
 438   filename = tilde_expand (filename);
 439   make_cleanup (xfree, filename);
 440
 441   outfile = gdb_fopen (filename, FOPEN_WT);
 442   if (outfile == 0)
 443     perror_with_name (filename);
 444   make_cleanup_ui_file_delete (outfile);
 445
 446   ALL_SYMTABS (objfile, s)
 447     {
 448       QUIT;
 449       if (symname == NULL
 450           || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0)
 451         dump_symtab (objfile, s, outfile);
 452     }
 453   do_cleanups (cleanups);
 454 }
 455
 456 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 457    far to indent.  ARGS is really a struct print_symbol_args *, but is
 458    declared as char * to get it past catch_errors.  Returns 0 for error,
 459    1 for success.  */
 460
 461 static int
 462 print_symbol (void *args)
 463 {
 464   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
 465   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 466   int depth = ((struct print_symbol_args *) args)->depth;
 467   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 468   struct obj_section *section = SYMBOL_OBJ_SECTION (SYMBOL_OBJFILE (symbol),
 469                                                     symbol);
 470
 471   print_spaces (depth, outfile);
 472   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 473     {
 474       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 475       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 476                       outfile);
 477       if (section)
 478         fprintf_filtered (outfile, " section %s\n",
 479                           bfd_section_name (section->the_bfd_section->owner,
 480                                             section->the_bfd_section));
 481       else
 482         fprintf_filtered (outfile, "\n");
 483       return 1;
 484     }
 485   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 486     {
 487       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 488         {
 489           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 490                          &type_print_raw_options);
 491         }
 492       else
 493         {
 494           fprintf_filtered (outfile, "%s %s = ",
 495                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 496                           ? "enum"
 497                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 498                         ? "struct" : "union")),
 499                             SYMBOL_LINKAGE_NAME (symbol));
 500           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 501                          &type_print_raw_options);
 502         }
 503       fprintf_filtered (outfile, ";\n");
 504     }
 505   else
 506     {
 507       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 508         fprintf_filtered (outfile, "typedef ");
 509       if (SYMBOL_TYPE (symbol))
 510         {
 511           /* Print details of types, except for enums where it's clutter.  */
 512           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 513                          outfile,
 514                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 515                          depth,
 516                          &type_print_raw_options);
 517           fprintf_filtered (outfile, "; ");
 518         }
 519       else
 520         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 521
 522       switch (SYMBOL_CLASS (symbol))
 523         {
 524         case LOC_CONST:
 525           fprintf_filtered (outfile, "const %s (%s)",
 526                             plongest (SYMBOL_VALUE (symbol)),
 527                             hex_string (SYMBOL_VALUE (symbol)));
 528           break;
 529
 530         case LOC_CONST_BYTES:
 531           {
 532             unsigned i;
 533             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 534
 535             fprintf_filtered (outfile, "const %u hex bytes:",
 536                               TYPE_LENGTH (type));
 537             for (i = 0; i < TYPE_LENGTH (type); i++)
 538               fprintf_filtered (outfile, " %02x",
 539                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 540           }
 541           break;
 542
 543         case LOC_STATIC:
 544           fprintf_filtered (outfile, "static at ");
 545           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 546                           outfile);
 547           if (section)
 548             fprintf_filtered (outfile, " section %s",
 549                               bfd_section_name (section->the_bfd_section->owner,
 550                                                 section->the_bfd_section));
 551           break;
 552
 553         case LOC_REGISTER:
 554           if (SYMBOL_IS_ARGUMENT (symbol))
 555             fprintf_filtered (outfile, "parameter register %s",
 556                               plongest (SYMBOL_VALUE (symbol)));
 557           else
 558             fprintf_filtered (outfile, "register %s",
 559                               plongest (SYMBOL_VALUE (symbol)));
 560           break;
 561
 562         case LOC_ARG:
 563           fprintf_filtered (outfile, "arg at offset %s",
 564                             hex_string (SYMBOL_VALUE (symbol)));
 565           break;
 566
 567         case LOC_REF_ARG:
 568           fprintf_filtered (outfile, "reference arg at %s",
 569                             hex_string (SYMBOL_VALUE (symbol)));
 570           break;
 571
 572         case LOC_REGPARM_ADDR:
 573           fprintf_filtered (outfile, "address parameter register %s",
 574                             plongest (SYMBOL_VALUE (symbol)));
 575           break;
 576
 577         case LOC_LOCAL:
 578           fprintf_filtered (outfile, "local at offset %s",
 579                             hex_string (SYMBOL_VALUE (symbol)));
 580           break;
 581
 582         case LOC_TYPEDEF:
 583           break;
 584
 585         case LOC_LABEL:
 586           fprintf_filtered (outfile, "label at ");
 587           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 588                           outfile);
 589           if (section)
 590             fprintf_filtered (outfile, " section %s",
 591                               bfd_section_name (section->the_bfd_section->owner,
 592                                                 section->the_bfd_section));
 593           break;
 594
 595         case LOC_BLOCK:
 596           fprintf_filtered (outfile, "block object ");
 597           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 598           fprintf_filtered (outfile, ", ");
 599           fputs_filtered (paddress (gdbarch,
 600                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 601                           outfile);
 602           fprintf_filtered (outfile, "..");
 603           fputs_filtered (paddress (gdbarch,
 604                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 605                           outfile);
 606           if (section)
 607             fprintf_filtered (outfile, " section %s",
 608                               bfd_section_name (section->the_bfd_section->owner,
 609                                                 section->the_bfd_section));
 610           break;
 611
 612         case LOC_COMPUTED:
 613           fprintf_filtered (outfile, "computed at runtime");
 614           break;
 615
 616         case LOC_UNRESOLVED:
 617           fprintf_filtered (outfile, "unresolved");
 618           break;
 619
 620         case LOC_OPTIMIZED_OUT:
 621           fprintf_filtered (outfile, "optimized out");
 622           break;
 623
 624         default:
 625           fprintf_filtered (outfile, "botched symbol class %x",
 626                             SYMBOL_CLASS (symbol));
 627           break;
 628         }
 629     }
 630   fprintf_filtered (outfile, "\n");
 631   return 1;
 632 }
 633
 634 static void
 635 maintenance_print_msymbols (char *args, int from_tty)
 636 {
 637   char **argv;
 638   struct ui_file *outfile;
 639   struct cleanup *cleanups;
 640   char *filename = DEV_TTY;
 641   char *symname = NULL;
 642   struct program_space *pspace;
 643   struct objfile *objfile;
 644
 645   struct stat sym_st, obj_st;
 646
 647   dont_repeat ();
 648
 649   if (args == NULL)
 650     {
 651       error (_("print-msymbols takes an output file "
 652                "name and optional symbol file name"));
 653     }
 654   argv = gdb_buildargv (args);
 655   cleanups = make_cleanup_freeargv (argv);
 656
 657   if (argv[0] != NULL)
 658     {
 659       filename = argv[0];
 660       /* If a second arg is supplied, it is a source file name to match on.  */
 661       if (argv[1] != NULL)
 662         {
 663           symname = gdb_realpath (argv[1]);
 664           make_cleanup (xfree, symname);
 665           if (symname && stat (symname, &sym_st))
 666             perror_with_name (symname);
 667         }
 668     }
 669
 670   filename = tilde_expand (filename);
 671   make_cleanup (xfree, filename);
 672
 673   outfile = gdb_fopen (filename, FOPEN_WT);
 674   if (outfile == 0)
 675     perror_with_name (filename);
 676   make_cleanup_ui_file_delete (outfile);
 677
 678   ALL_PSPACES (pspace)
 679     ALL_PSPACE_OBJFILES (pspace, objfile)
 680       {
 681         QUIT;
 682         if (symname == NULL || (!stat (objfile_name (objfile), &obj_st)
 683                                 && sym_st.st_dev == obj_st.st_dev
 684                                 && sym_st.st_ino == obj_st.st_ino))
 685           dump_msymbols (objfile, outfile);
 686       }
 687   fprintf_filtered (outfile, "\n\n");
 688   do_cleanups (cleanups);
 689 }
 690
 691 static void
 692 maintenance_print_objfiles (char *regexp, int from_tty)
 693 {
 694   struct program_space *pspace;
 695   struct objfile *objfile;
 696
 697   dont_repeat ();
 698
 699   if (regexp)
 700     re_comp (regexp);
 701
 702   ALL_PSPACES (pspace)
 703     ALL_PSPACE_OBJFILES (pspace, objfile)
 704       {
 705         QUIT;
 706         if (! regexp
 707             || re_exec (objfile_name (objfile)))
 708           dump_objfile (objfile);
 709       }
 710 }
 711
 712 /* List all the symbol tables whose names match REGEXP (optional).  */
 713
 714 static void
 715 maintenance_info_symtabs (char *regexp, int from_tty)
 716 {
 717   struct program_space *pspace;
 718   struct objfile *objfile;
 719
 720   dont_repeat ();
 721
 722   if (regexp)
 723     re_comp (regexp);
 724
 725   ALL_PSPACES (pspace)
 726     ALL_PSPACE_OBJFILES (pspace, objfile)
 727     {
 728       struct symtab *symtab;
 729
 730       /* We don't want to print anything for this objfile until we
 731          actually find a symtab whose name matches.  */
 732       int printed_objfile_start = 0;
 733
 734       ALL_OBJFILE_SYMTABS (objfile, symtab)
 735         {
 736           QUIT;
 737
 738           if (! regexp
 739               || re_exec (symtab_to_filename_for_display (symtab)))
 740             {
 741               if (! printed_objfile_start)
 742                 {
 743                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
 744                   wrap_here ("  ");
 745                   printf_filtered ("((struct objfile *) %s)\n",
 746                                    host_address_to_string (objfile));
 747                   printed_objfile_start = 1;
 748                 }
 749
 750               printf_filtered ("        { symtab %s ",
 751                                symtab_to_filename_for_display (symtab));
 752               wrap_here ("    ");
 753               printf_filtered ("((struct symtab *) %s)\n",
 754                                host_address_to_string (symtab));
 755               printf_filtered ("          dirname %s\n",
 756                                symtab->dirname ? symtab->dirname : "(null)");
 757               printf_filtered ("          fullname %s\n",
 758                                symtab->fullname ? symtab->fullname : "(null)");
 759               printf_filtered ("          "
 760                                "blockvector ((struct blockvector *) %s)%s\n",
 761                                host_address_to_string (symtab->blockvector),
 762                                symtab->primary ? " (primary)" : "");
 763               printf_filtered ("          "
 764                                "linetable ((struct linetable *) %s)\n",
 765                                host_address_to_string (symtab->linetable));
 766               printf_filtered ("          debugformat %s\n",
 767                                symtab->debugformat);
 768               printf_filtered ("        }\n");
 769             }
 770         }
 771
 772       if (printed_objfile_start)
 773         printf_filtered ("}\n");
 774     }
 775 }
 776
 777 /* Check consistency of symtabs.
 778    An example of what this checks for is NULL blockvectors.
 779    They can happen if there's a bug during debug info reading.
 780    GDB assumes they are always non-NULL.
 781
 782    Note: This does not check for psymtab vs symtab consistency.
 783    Use "maint check-psymtabs" for that.  */
 784
 785 static void
 786 maintenance_check_symtabs (char *ignore, int from_tty)
 787 {
 788   struct program_space *pspace;
 789   struct objfile *objfile;
 790
 791   ALL_PSPACES (pspace)
 792     ALL_PSPACE_OBJFILES (pspace, objfile)
 793     {
 794       struct symtab *symtab;
 795
 796       /* We don't want to print anything for this objfile until we
 797          actually find something worth printing.  */
 798       int printed_objfile_start = 0;
 799
 800       ALL_OBJFILE_SYMTABS (objfile, symtab)
 801         {
 802           int found_something = 0;
 803
 804           QUIT;
 805
 806           if (symtab->blockvector == NULL)
 807             found_something = 1;
 808           /* Add more checks here.  */
 809
 810           if (found_something)
 811             {
 812               if (! printed_objfile_start)
 813                 {
 814                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
 815                   wrap_here ("  ");
 816                   printf_filtered ("((struct objfile *) %s)\n",
 817                                    host_address_to_string (objfile));
 818                   printed_objfile_start = 1;
 819                 }
 820               printf_filtered ("  { symtab %s\n",
 821                                symtab_to_filename_for_display (symtab));
 822               if (symtab->blockvector == NULL)
 823                 printf_filtered ("    NULL blockvector\n");
 824               printf_filtered ("  }\n");
 825             }
 826         }
 827
 828       if (printed_objfile_start)
 829         printf_filtered ("}\n");
 830     }
 831 }
 832
 833 /* Helper function for maintenance_expand_symtabs.
 834    This is the name_matcher function for expand_symtabs_matching.  */
 835
 836 static int
 837 maintenance_expand_name_matcher (const char *symname, void *data)
 838 {
 839   /* Since we're not searching on symbols, just return TRUE.  */
 840   return 1;
 841 }
 842
 843 /* Helper function for maintenance_expand_symtabs.
 844    This is the file_matcher function for expand_symtabs_matching.  */
 845
 846 static int
 847 maintenance_expand_file_matcher (const char *filename, void *data,
 848                                  int basenames)
 849 {
 850   const char *regexp = data;
 851
 852   QUIT;
 853
 854   /* KISS: Only apply the regexp to the complete file name.  */
 855   if (basenames)
 856     return 0;
 857
 858   if (regexp == NULL || re_exec (filename))
 859     return 1;
 860
 861   return 0;
 862 }
 863
 864 /* Expand all symbol tables whose name matches an optional regexp.  */
 865
 866 static void
 867 maintenance_expand_symtabs (char *args, int from_tty)
 868 {
 869   struct program_space *pspace;
 870   struct objfile *objfile;
 871   struct cleanup *cleanups;
 872   char **argv;
 873   char *regexp = NULL;
 874
 875   /* We use buildargv here so that we handle spaces in the regexp
 876      in a way that allows adding more arguments later.  */
 877   argv = gdb_buildargv (args);
 878   cleanups = make_cleanup_freeargv (argv);
 879
 880   if (argv != NULL)
 881     {
 882       if (argv[0] != NULL)
 883         {
 884           regexp = argv[0];
 885           if (argv[1] != NULL)
 886             error (_("Extra arguments after regexp."));
 887         }
 888     }
 889
 890   if (regexp)
 891     re_comp (regexp);
 892
 893   ALL_PSPACES (pspace)
 894     ALL_PSPACE_OBJFILES (pspace, objfile)
 895     {
 896       if (objfile->sf)
 897         {
 898           objfile->sf->qf->expand_symtabs_matching
 899             (objfile, maintenance_expand_file_matcher,
 900              maintenance_expand_name_matcher, ALL_DOMAIN, regexp);
 901         }
 902     }
 903
 904   do_cleanups (cleanups);
 905 }
 906 \f
 907
 908 /* Return the nexting depth of a block within other blocks in its symtab.  */
 909
 910 static int
 911 block_depth (struct block *block)
 912 {
 913   int i = 0;
 914
 915   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 916     {
 917       i++;
 918     }
 919   return i;
 920 }
 921 \f
 922
 923 /* Do early runtime initializations.  */
 924
 925 void
 926 _initialize_symmisc (void)
 927 {
 928   std_in = stdin;
 929   std_out = stdout;
 930   std_err = stderr;
 931
 932   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
 933 Print dump of current symbol definitions.\n\
 934 Entries in the full symbol table are dumped to file OUTFILE.\n\
 935 If a SOURCE file is specified, dump only that file's symbols."),
 936            &maintenanceprintlist);
 937
 938   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
 939 Print dump of current minimal symbol definitions.\n\
 940 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
 941 If a SOURCE file is specified, dump only that file's minimal symbols."),
 942            &maintenanceprintlist);
 943
 944   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
 945            _("Print dump of current object file definitions.\n\
 946 With an argument REGEXP, list the object files with matching names."),
 947            &maintenanceprintlist);
 948
 949   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
 950 List the full symbol tables for all object files.\n\
 951 This does not include information about individual symbols, blocks, or\n\
 952 linetables --- just the symbol table structures themselves.\n\
 953 With an argument REGEXP, list the symbol tables with matching names."),
 954            &maintenanceinfolist);
 955
 956   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
 957            _("\
 958 Check consistency of currently expanded symtabs."),
 959            &maintenancelist);
 960
 961   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
 962            _("Expand symbol tables.\n\
 963 With an argument REGEXP, only expand the symbol tables with matching names."),
 964            &maintenancelist);
 965 }