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 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 symtab *symtab, struct ui_file *outfile)
 286 {
 287   struct objfile *objfile = SYMTAB_OBJFILE (symtab);
 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       const char *compunit_filename
 381         = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)));
 382
 383       fprintf_filtered (outfile,
 384                         "\nBlockvector same as owning compunit: %s\n\n",
 385                         compunit_filename);
 386     }
 387 }
 388
 389 static void
 390 dump_symtab (struct symtab *symtab, struct ui_file *outfile)
 391 {
 392   /* Set the current language to the language of the symtab we're dumping
 393      because certain routines used during dump_symtab() use the current
 394      language to print an image of the symbol.  We'll restore it later.
 395      But use only real languages, not placeholders.  */
 396   if (symtab->language != language_unknown
 397       && symtab->language != language_auto)
 398     {
 399       enum language saved_lang;
 400
 401       saved_lang = set_language (symtab->language);
 402
 403       dump_symtab_1 (symtab, outfile);
 404
 405       set_language (saved_lang);
 406     }
 407   else
 408     dump_symtab_1 (symtab, outfile);
 409 }
 410
 411 static void
 412 maintenance_print_symbols (char *args, int from_tty)
 413 {
 414   char **argv;
 415   struct ui_file *outfile;
 416   struct cleanup *cleanups;
 417   char *symname = NULL;
 418   char *filename = DEV_TTY;
 419   struct objfile *objfile;
 420   struct compunit_symtab *cu;
 421   struct symtab *s;
 422
 423   dont_repeat ();
 424
 425   if (args == NULL)
 426     {
 427       error (_("Arguments missing: an output file name "
 428                "and an optional symbol file name"));
 429     }
 430   argv = gdb_buildargv (args);
 431   cleanups = make_cleanup_freeargv (argv);
 432
 433   if (argv[0] != NULL)
 434     {
 435       filename = argv[0];
 436       /* If a second arg is supplied, it is a source file name to match on.  */
 437       if (argv[1] != NULL)
 438         {
 439           symname = argv[1];
 440         }
 441     }
 442
 443   filename = tilde_expand (filename);
 444   make_cleanup (xfree, filename);
 445
 446   outfile = gdb_fopen (filename, FOPEN_WT);
 447   if (outfile == 0)
 448     perror_with_name (filename);
 449   make_cleanup_ui_file_delete (outfile);
 450
 451   ALL_FILETABS (objfile, cu, s)
 452     {
 453       QUIT;
 454       if (symname == NULL
 455           || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0)
 456         dump_symtab (s, outfile);
 457     }
 458   do_cleanups (cleanups);
 459 }
 460
 461 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 462    far to indent.  ARGS is really a struct print_symbol_args *, but is
 463    declared as char * to get it past catch_errors.  Returns 0 for error,
 464    1 for success.  */
 465
 466 static int
 467 print_symbol (void *args)
 468 {
 469   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
 470   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 471   int depth = ((struct print_symbol_args *) args)->depth;
 472   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 473   struct obj_section *section;
 474
 475   if (SYMBOL_OBJFILE_OWNED (symbol))
 476     section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
 477   else
 478     section = NULL;
 479
 480   print_spaces (depth, outfile);
 481   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 482     {
 483       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 484       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 485                       outfile);
 486       if (section)
 487         fprintf_filtered (outfile, " section %s\n",
 488                           bfd_section_name (section->the_bfd_section->owner,
 489                                             section->the_bfd_section));
 490       else
 491         fprintf_filtered (outfile, "\n");
 492       return 1;
 493     }
 494   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 495     {
 496       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 497         {
 498           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 499                          &type_print_raw_options);
 500         }
 501       else
 502         {
 503           fprintf_filtered (outfile, "%s %s = ",
 504                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 505                           ? "enum"
 506                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 507                         ? "struct" : "union")),
 508                             SYMBOL_LINKAGE_NAME (symbol));
 509           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 510                          &type_print_raw_options);
 511         }
 512       fprintf_filtered (outfile, ";\n");
 513     }
 514   else
 515     {
 516       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 517         fprintf_filtered (outfile, "typedef ");
 518       if (SYMBOL_TYPE (symbol))
 519         {
 520           /* Print details of types, except for enums where it's clutter.  */
 521           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 522                          outfile,
 523                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 524                          depth,
 525                          &type_print_raw_options);
 526           fprintf_filtered (outfile, "; ");
 527         }
 528       else
 529         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 530
 531       switch (SYMBOL_CLASS (symbol))
 532         {
 533         case LOC_CONST:
 534           fprintf_filtered (outfile, "const %s (%s)",
 535                             plongest (SYMBOL_VALUE (symbol)),
 536                             hex_string (SYMBOL_VALUE (symbol)));
 537           break;
 538
 539         case LOC_CONST_BYTES:
 540           {
 541             unsigned i;
 542             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 543
 544             fprintf_filtered (outfile, "const %u hex bytes:",
 545                               TYPE_LENGTH (type));
 546             for (i = 0; i < TYPE_LENGTH (type); i++)
 547               fprintf_filtered (outfile, " %02x",
 548                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 549           }
 550           break;
 551
 552         case LOC_STATIC:
 553           fprintf_filtered (outfile, "static at ");
 554           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 555                           outfile);
 556           if (section)
 557             fprintf_filtered (outfile, " section %s",
 558                               bfd_section_name (section->the_bfd_section->owner,
 559                                                 section->the_bfd_section));
 560           break;
 561
 562         case LOC_REGISTER:
 563           if (SYMBOL_IS_ARGUMENT (symbol))
 564             fprintf_filtered (outfile, "parameter register %s",
 565                               plongest (SYMBOL_VALUE (symbol)));
 566           else
 567             fprintf_filtered (outfile, "register %s",
 568                               plongest (SYMBOL_VALUE (symbol)));
 569           break;
 570
 571         case LOC_ARG:
 572           fprintf_filtered (outfile, "arg at offset %s",
 573                             hex_string (SYMBOL_VALUE (symbol)));
 574           break;
 575
 576         case LOC_REF_ARG:
 577           fprintf_filtered (outfile, "reference arg at %s",
 578                             hex_string (SYMBOL_VALUE (symbol)));
 579           break;
 580
 581         case LOC_REGPARM_ADDR:
 582           fprintf_filtered (outfile, "address parameter register %s",
 583                             plongest (SYMBOL_VALUE (symbol)));
 584           break;
 585
 586         case LOC_LOCAL:
 587           fprintf_filtered (outfile, "local at offset %s",
 588                             hex_string (SYMBOL_VALUE (symbol)));
 589           break;
 590
 591         case LOC_TYPEDEF:
 592           break;
 593
 594         case LOC_LABEL:
 595           fprintf_filtered (outfile, "label at ");
 596           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 597                           outfile);
 598           if (section)
 599             fprintf_filtered (outfile, " section %s",
 600                               bfd_section_name (section->the_bfd_section->owner,
 601                                                 section->the_bfd_section));
 602           break;
 603
 604         case LOC_BLOCK:
 605           fprintf_filtered (outfile, "block object ");
 606           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 607           fprintf_filtered (outfile, ", ");
 608           fputs_filtered (paddress (gdbarch,
 609                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 610                           outfile);
 611           fprintf_filtered (outfile, "..");
 612           fputs_filtered (paddress (gdbarch,
 613                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 614                           outfile);
 615           if (section)
 616             fprintf_filtered (outfile, " section %s",
 617                               bfd_section_name (section->the_bfd_section->owner,
 618                                                 section->the_bfd_section));
 619           break;
 620
 621         case LOC_COMPUTED:
 622           fprintf_filtered (outfile, "computed at runtime");
 623           break;
 624
 625         case LOC_UNRESOLVED:
 626           fprintf_filtered (outfile, "unresolved");
 627           break;
 628
 629         case LOC_OPTIMIZED_OUT:
 630           fprintf_filtered (outfile, "optimized out");
 631           break;
 632
 633         default:
 634           fprintf_filtered (outfile, "botched symbol class %x",
 635                             SYMBOL_CLASS (symbol));
 636           break;
 637         }
 638     }
 639   fprintf_filtered (outfile, "\n");
 640   return 1;
 641 }
 642
 643 static void
 644 maintenance_print_msymbols (char *args, int from_tty)
 645 {
 646   char **argv;
 647   struct ui_file *outfile;
 648   struct cleanup *cleanups;
 649   char *filename = DEV_TTY;
 650   char *symname = NULL;
 651   struct program_space *pspace;
 652   struct objfile *objfile;
 653
 654   struct stat sym_st, obj_st;
 655
 656   dont_repeat ();
 657
 658   if (args == NULL)
 659     {
 660       error (_("print-msymbols takes an output file "
 661                "name and optional symbol file name"));
 662     }
 663   argv = gdb_buildargv (args);
 664   cleanups = make_cleanup_freeargv (argv);
 665
 666   if (argv[0] != NULL)
 667     {
 668       filename = argv[0];
 669       /* If a second arg is supplied, it is a source file name to match on.  */
 670       if (argv[1] != NULL)
 671         {
 672           symname = gdb_realpath (argv[1]);
 673           make_cleanup (xfree, symname);
 674           if (symname && stat (symname, &sym_st))
 675             perror_with_name (symname);
 676         }
 677     }
 678
 679   filename = tilde_expand (filename);
 680   make_cleanup (xfree, filename);
 681
 682   outfile = gdb_fopen (filename, FOPEN_WT);
 683   if (outfile == 0)
 684     perror_with_name (filename);
 685   make_cleanup_ui_file_delete (outfile);
 686
 687   ALL_PSPACES (pspace)
 688     ALL_PSPACE_OBJFILES (pspace, objfile)
 689       {
 690         QUIT;
 691         if (symname == NULL || (!stat (objfile_name (objfile), &obj_st)
 692                                 && sym_st.st_dev == obj_st.st_dev
 693                                 && sym_st.st_ino == obj_st.st_ino))
 694           dump_msymbols (objfile, outfile);
 695       }
 696   fprintf_filtered (outfile, "\n\n");
 697   do_cleanups (cleanups);
 698 }
 699
 700 static void
 701 maintenance_print_objfiles (char *regexp, int from_tty)
 702 {
 703   struct program_space *pspace;
 704   struct objfile *objfile;
 705
 706   dont_repeat ();
 707
 708   if (regexp)
 709     re_comp (regexp);
 710
 711   ALL_PSPACES (pspace)
 712     ALL_PSPACE_OBJFILES (pspace, objfile)
 713       {
 714         QUIT;
 715         if (! regexp
 716             || re_exec (objfile_name (objfile)))
 717           dump_objfile (objfile);
 718       }
 719 }
 720
 721 /* List all the symbol tables whose names match REGEXP (optional).  */
 722
 723 static void
 724 maintenance_info_symtabs (char *regexp, int from_tty)
 725 {
 726   struct program_space *pspace;
 727   struct objfile *objfile;
 728
 729   dont_repeat ();
 730
 731   if (regexp)
 732     re_comp (regexp);
 733
 734   ALL_PSPACES (pspace)
 735     ALL_PSPACE_OBJFILES (pspace, objfile)
 736     {
 737       struct compunit_symtab *cust;
 738       struct symtab *symtab;
 739
 740       /* We don't want to print anything for this objfile until we
 741          actually find a symtab whose name matches.  */
 742       int printed_objfile_start = 0;
 743
 744       ALL_OBJFILE_COMPUNITS (objfile, cust)
 745         {
 746           int printed_compunit_symtab_start = 0;
 747
 748           ALL_COMPUNIT_FILETABS (cust, symtab)
 749             {
 750               QUIT;
 751
 752               if (! regexp
 753                   || re_exec (symtab_to_filename_for_display (symtab)))
 754                 {
 755                   if (! printed_objfile_start)
 756                     {
 757                       printf_filtered ("{ objfile %s ", objfile_name (objfile));
 758                       wrap_here ("  ");
 759                       printf_filtered ("((struct objfile *) %s)\n",
 760                                        host_address_to_string (objfile));
 761                       printed_objfile_start = 1;
 762                     }
 763                   if (! printed_compunit_symtab_start)
 764                     {
 765                       printf_filtered ("  { ((struct compunit_symtab *) %s)\n",
 766                                        host_address_to_string (cust));
 767                       printf_filtered ("    debugformat %s\n",
 768                                        COMPUNIT_DEBUGFORMAT (cust));
 769                       printf_filtered ("    producer %s\n",
 770                                        COMPUNIT_PRODUCER (cust) != NULL
 771                                        ? COMPUNIT_PRODUCER (cust)
 772                                        : "(null)");
 773                       printf_filtered ("    dirname %s\n",
 774                                        COMPUNIT_DIRNAME (cust) != NULL
 775                                        ? COMPUNIT_DIRNAME (cust)
 776                                        : "(null)");
 777                       printf_filtered ("    blockvector"
 778                                        " ((struct blockvector *) %s)\n",
 779                                        host_address_to_string
 780                                          (COMPUNIT_BLOCKVECTOR (cust)));
 781                       printed_compunit_symtab_start = 1;
 782                     }
 783
 784                   printf_filtered ("\t{ symtab %s ",
 785                                    symtab_to_filename_for_display (symtab));
 786                   wrap_here ("    ");
 787                   printf_filtered ("((struct symtab *) %s)\n",
 788                                    host_address_to_string (symtab));
 789                   printf_filtered ("\t  fullname %s\n",
 790                                    symtab->fullname != NULL
 791                                    ? symtab->fullname
 792                                    : "(null)");
 793                   printf_filtered ("\t  "
 794                                    "linetable ((struct linetable *) %s)\n",
 795                                    host_address_to_string (symtab->linetable));
 796                   printf_filtered ("\t}\n");
 797                 }
 798             }
 799
 800           if (printed_compunit_symtab_start)
 801             printf_filtered ("  }\n");
 802         }
 803
 804       if (printed_objfile_start)
 805         printf_filtered ("}\n");
 806     }
 807 }
 808
 809 /* Check consistency of symtabs.
 810    An example of what this checks for is NULL blockvectors.
 811    They can happen if there's a bug during debug info reading.
 812    GDB assumes they are always non-NULL.
 813
 814    Note: This does not check for psymtab vs symtab consistency.
 815    Use "maint check-psymtabs" for that.  */
 816
 817 static void
 818 maintenance_check_symtabs (char *ignore, int from_tty)
 819 {
 820   struct program_space *pspace;
 821   struct objfile *objfile;
 822
 823   ALL_PSPACES (pspace)
 824     ALL_PSPACE_OBJFILES (pspace, objfile)
 825     {
 826       struct compunit_symtab *cust;
 827
 828       /* We don't want to print anything for this objfile until we
 829          actually find something worth printing.  */
 830       int printed_objfile_start = 0;
 831
 832       ALL_OBJFILE_COMPUNITS (objfile, cust)
 833         {
 834           int found_something = 0;
 835           struct symtab *symtab = compunit_primary_filetab (cust);
 836
 837           QUIT;
 838
 839           if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 840             found_something = 1;
 841           /* Add more checks here.  */
 842
 843           if (found_something)
 844             {
 845               if (! printed_objfile_start)
 846                 {
 847                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
 848                   wrap_here ("  ");
 849                   printf_filtered ("((struct objfile *) %s)\n",
 850                                    host_address_to_string (objfile));
 851                   printed_objfile_start = 1;
 852                 }
 853               printf_filtered ("  { symtab %s\n",
 854                                symtab_to_filename_for_display (symtab));
 855               if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 856                 printf_filtered ("    NULL blockvector\n");
 857               printf_filtered ("  }\n");
 858             }
 859         }
 860
 861       if (printed_objfile_start)
 862         printf_filtered ("}\n");
 863     }
 864 }
 865
 866 /* Helper function for maintenance_expand_symtabs.
 867    This is the name_matcher function for expand_symtabs_matching.  */
 868
 869 static int
 870 maintenance_expand_name_matcher (const char *symname, void *data)
 871 {
 872   /* Since we're not searching on symbols, just return TRUE.  */
 873   return 1;
 874 }
 875
 876 /* Helper function for maintenance_expand_symtabs.
 877    This is the file_matcher function for expand_symtabs_matching.  */
 878
 879 static int
 880 maintenance_expand_file_matcher (const char *filename, void *data,
 881                                  int basenames)
 882 {
 883   const char *regexp = (const char *) data;
 884
 885   QUIT;
 886
 887   /* KISS: Only apply the regexp to the complete file name.  */
 888   if (basenames)
 889     return 0;
 890
 891   if (regexp == NULL || re_exec (filename))
 892     return 1;
 893
 894   return 0;
 895 }
 896
 897 /* Expand all symbol tables whose name matches an optional regexp.  */
 898
 899 static void
 900 maintenance_expand_symtabs (char *args, int from_tty)
 901 {
 902   struct program_space *pspace;
 903   struct objfile *objfile;
 904   struct cleanup *cleanups;
 905   char **argv;
 906   char *regexp = NULL;
 907
 908   /* We use buildargv here so that we handle spaces in the regexp
 909      in a way that allows adding more arguments later.  */
 910   argv = gdb_buildargv (args);
 911   cleanups = make_cleanup_freeargv (argv);
 912
 913   if (argv != NULL)
 914     {
 915       if (argv[0] != NULL)
 916         {
 917           regexp = argv[0];
 918           if (argv[1] != NULL)
 919             error (_("Extra arguments after regexp."));
 920         }
 921     }
 922
 923   if (regexp)
 924     re_comp (regexp);
 925
 926   ALL_PSPACES (pspace)
 927     ALL_PSPACE_OBJFILES (pspace, objfile)
 928     {
 929       if (objfile->sf)
 930         {
 931           objfile->sf->qf->expand_symtabs_matching
 932             (objfile, maintenance_expand_file_matcher,
 933              maintenance_expand_name_matcher, NULL, ALL_DOMAIN, regexp);
 934         }
 935     }
 936
 937   do_cleanups (cleanups);
 938 }
 939 \f
 940
 941 /* Return the nexting depth of a block within other blocks in its symtab.  */
 942
 943 static int
 944 block_depth (struct block *block)
 945 {
 946   int i = 0;
 947
 948   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 949     {
 950       i++;
 951     }
 952   return i;
 953 }
 954 \f
 955
 956 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
 957    single line table.  */
 958
 959 static int
 960 maintenance_print_one_line_table (struct symtab *symtab, void *data)
 961 {
 962   struct linetable *linetable;
 963   struct objfile *objfile;
 964
 965   objfile = symtab->compunit_symtab->objfile;
 966   printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
 967                    objfile_name (objfile),
 968                    host_address_to_string (objfile));
 969   printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
 970                    host_address_to_string (symtab->compunit_symtab));
 971   printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
 972                    symtab_to_fullname (symtab),
 973                    host_address_to_string (symtab));
 974   linetable = SYMTAB_LINETABLE (symtab);
 975   printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
 976                    host_address_to_string (linetable));
 977
 978   if (linetable == NULL)
 979     printf_filtered (_("No line table.\n"));
 980   else if (linetable->nitems <= 0)
 981     printf_filtered (_("Line table has no lines.\n"));
 982   else
 983     {
 984       int i;
 985
 986       /* Leave space for 6 digits of index and line number.  After that the
 987          tables will just not format as well.  */
 988       printf_filtered (_("%-6s %6s %s\n"),
 989                        _("INDEX"), _("LINE"), _("ADDRESS"));
 990
 991       for (i = 0; i < linetable->nitems; ++i)
 992         {
 993           struct linetable_entry *item;
 994
 995           item = &linetable->item [i];
 996           printf_filtered (_("%-6d %6d %s\n"), i, item->line,
 997                            core_addr_to_string (item->pc));
 998         }
 999     }
1000
1001   return 0;
1002 }
1003
1004 /* Implement the 'maint info line-table' command.  */
1005
1006 static void
1007 maintenance_info_line_tables (char *regexp, int from_tty)
1008 {
1009   struct program_space *pspace;
1010   struct objfile *objfile;
1011
1012   dont_repeat ();
1013
1014   if (regexp != NULL)
1015     re_comp (regexp);
1016
1017   ALL_PSPACES (pspace)
1018     ALL_PSPACE_OBJFILES (pspace, objfile)
1019     {
1020       struct compunit_symtab *cust;
1021       struct symtab *symtab;
1022
1023       ALL_OBJFILE_COMPUNITS (objfile, cust)
1024         {
1025           ALL_COMPUNIT_FILETABS (cust, symtab)
1026             {
1027               QUIT;
1028
1029               if (regexp == NULL
1030                   || re_exec (symtab_to_filename_for_display (symtab)))
1031                 maintenance_print_one_line_table (symtab, NULL);
1032             }
1033         }
1034     }
1035 }
1036
1037 \f
1038
1039 /* Do early runtime initializations.  */
1040
1041 void
1042 _initialize_symmisc (void)
1043 {
1044   std_in = stdin;
1045   std_out = stdout;
1046   std_err = stderr;
1047
1048   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1049 Print dump of current symbol definitions.\n\
1050 Entries in the full symbol table are dumped to file OUTFILE.\n\
1051 If a SOURCE file is specified, dump only that file's symbols."),
1052            &maintenanceprintlist);
1053
1054   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1055 Print dump of current minimal symbol definitions.\n\
1056 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
1057 If a SOURCE file is specified, dump only that file's minimal symbols."),
1058            &maintenanceprintlist);
1059
1060   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1061            _("Print dump of current object file definitions.\n\
1062 With an argument REGEXP, list the object files with matching names."),
1063            &maintenanceprintlist);
1064
1065   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1066 List the full symbol tables for all object files.\n\
1067 This does not include information about individual symbols, blocks, or\n\
1068 linetables --- just the symbol table structures themselves.\n\
1069 With an argument REGEXP, list the symbol tables with matching names."),
1070            &maintenanceinfolist);
1071
1072   add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1073 List the contents of all line tables, from all symbol tables.\n\
1074 With an argument REGEXP, list just the line tables for the symbol\n\
1075 tables with matching names."),
1076            &maintenanceinfolist);
1077
1078   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1079            _("\
1080 Check consistency of currently expanded symtabs."),
1081            &maintenancelist);
1082
1083   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1084            _("Expand symbol tables.\n\
1085 With an argument REGEXP, only expand the symbol tables with matching names."),
1086            &maintenancelist);
1087 }