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