gdb/symmisc.c

   1 /* Do various things to symbol tables (other than lookup), for GDB.
   2
   3    Copyright (C) 1986-2016 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 = (const char *) 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, NULL, 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 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
 953    single line table.  */
 954
 955 static int
 956 maintenance_print_one_line_table (struct symtab *symtab, void *data)
 957 {
 958   struct linetable *linetable;
 959   struct objfile *objfile;
 960
 961   objfile = symtab->compunit_symtab->objfile;
 962   printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
 963                    objfile_name (objfile),
 964                    host_address_to_string (objfile));
 965   printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
 966                    host_address_to_string (symtab->compunit_symtab));
 967   printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
 968                    symtab_to_fullname (symtab),
 969                    host_address_to_string (symtab));
 970   linetable = SYMTAB_LINETABLE (symtab);
 971   printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
 972                    host_address_to_string (linetable));
 973
 974   if (linetable == NULL)
 975     printf_filtered (_("No line table.\n"));
 976   else if (linetable->nitems <= 0)
 977     printf_filtered (_("Line table has no lines.\n"));
 978   else
 979     {
 980       int i;
 981
 982       /* Leave space for 6 digits of index and line number.  After that the
 983          tables will just not format as well.  */
 984       printf_filtered (_("%-6s %6s %s\n"),
 985                        _("INDEX"), _("LINE"), _("ADDRESS"));
 986
 987       for (i = 0; i < linetable->nitems; ++i)
 988         {
 989           struct linetable_entry *item;
 990           struct cleanup *row_cleanup;
 991
 992           item = &linetable->item [i];
 993           printf_filtered (_("%-6d %6d %s\n"), i, item->line,
 994                            core_addr_to_string (item->pc));
 995         }
 996     }
 997
 998   return 0;
 999 }
1000
1001 /* Implement the 'maint info line-table' command.  */
1002
1003 static void
1004 maintenance_info_line_tables (char *regexp, int from_tty)
1005 {
1006   struct program_space *pspace;
1007   struct objfile *objfile;
1008
1009   dont_repeat ();
1010
1011   if (regexp != NULL)
1012     re_comp (regexp);
1013
1014   ALL_PSPACES (pspace)
1015     ALL_PSPACE_OBJFILES (pspace, objfile)
1016     {
1017       struct compunit_symtab *cust;
1018       struct symtab *symtab;
1019
1020       ALL_OBJFILE_COMPUNITS (objfile, cust)
1021         {
1022           ALL_COMPUNIT_FILETABS (cust, symtab)
1023             {
1024               QUIT;
1025
1026               if (regexp == NULL
1027                   || re_exec (symtab_to_filename_for_display (symtab)))
1028                 maintenance_print_one_line_table (symtab, NULL);
1029             }
1030         }
1031     }
1032 }
1033
1034 \f
1035
1036 /* Do early runtime initializations.  */
1037
1038 void
1039 _initialize_symmisc (void)
1040 {
1041   std_in = stdin;
1042   std_out = stdout;
1043   std_err = stderr;
1044
1045   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1046 Print dump of current symbol definitions.\n\
1047 Entries in the full symbol table are dumped to file OUTFILE.\n\
1048 If a SOURCE file is specified, dump only that file's symbols."),
1049            &maintenanceprintlist);
1050
1051   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1052 Print dump of current minimal symbol definitions.\n\
1053 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
1054 If a SOURCE file is specified, dump only that file's minimal symbols."),
1055            &maintenanceprintlist);
1056
1057   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1058            _("Print dump of current object file definitions.\n\
1059 With an argument REGEXP, list the object files with matching names."),
1060            &maintenanceprintlist);
1061
1062   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1063 List the full symbol tables for all object files.\n\
1064 This does not include information about individual symbols, blocks, or\n\
1065 linetables --- just the symbol table structures themselves.\n\
1066 With an argument REGEXP, list the symbol tables with matching names."),
1067            &maintenanceinfolist);
1068
1069   add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1070 List the contents of all line tables, from all symbol tables.\n\
1071 With an argument REGEXP, list just the line tables for the symbol\n\
1072 tables with matching names."),
1073            &maintenanceinfolist);
1074
1075   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1076            _("\
1077 Check consistency of currently expanded symtabs."),
1078            &maintenancelist);
1079
1080   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1081            _("Expand symbol tables.\n\
1082 With an argument REGEXP, only expand the symbol tables with matching names."),
1083            &maintenancelist);
1084 }