gdb/symmisc.c

   1 /* Do various things to symbol tables (other than lookup), for GDB.
   2
   3    Copyright (C) 1986-2017 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 /* Unfortunately for debugging, stderr is usually a macro.  This is painful
  44    when calling functions that take FILE *'s from the debugger.
  45    So we make a variable which has the same value and which is accessible when
  46    debugging GDB with itself.  Because stdin et al need not be constants,
  47    we initialize them in the _initialize_symmisc function at the bottom
  48    of the file.  */
  49 FILE *std_in;
  50 FILE *std_out;
  51 FILE *std_err;
  52
  53 /* Prototypes for local functions */
  54
  55 static int block_depth (struct block *);
  56
  57 void _initialize_symmisc (void);
  58
  59 struct print_symbol_args
  60   {
  61     struct gdbarch *gdbarch;
  62     struct symbol *symbol;
  63     int depth;
  64     struct ui_file *outfile;
  65   };
  66
  67 static int print_symbol (void *);
  68 \f
  69
  70 void
  71 print_symbol_bcache_statistics (void)
  72 {
  73   struct program_space *pspace;
  74   struct objfile *objfile;
  75
  76   ALL_PSPACES (pspace)
  77     ALL_PSPACE_OBJFILES (pspace, objfile)
  78   {
  79     QUIT;
  80     printf_filtered (_("Byte cache statistics for '%s':\n"),
  81                      objfile_name (objfile));
  82     print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
  83                              "partial symbol cache");
  84     print_bcache_statistics (objfile->per_bfd->macro_cache,
  85                              "preprocessor macro cache");
  86     print_bcache_statistics (objfile->per_bfd->filename_cache,
  87                              "file name cache");
  88   }
  89 }
  90
  91 void
  92 print_objfile_statistics (void)
  93 {
  94   struct program_space *pspace;
  95   struct objfile *objfile;
  96   struct compunit_symtab *cu;
  97   struct symtab *s;
  98   int i, linetables, blockvectors;
  99
 100   ALL_PSPACES (pspace)
 101     ALL_PSPACE_OBJFILES (pspace, objfile)
 102   {
 103     QUIT;
 104     printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile));
 105     if (OBJSTAT (objfile, n_stabs) > 0)
 106       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
 107                        OBJSTAT (objfile, n_stabs));
 108     if (objfile->per_bfd->n_minsyms > 0)
 109       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
 110                        objfile->per_bfd->n_minsyms);
 111     if (OBJSTAT (objfile, n_psyms) > 0)
 112       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
 113                        OBJSTAT (objfile, n_psyms));
 114     if (OBJSTAT (objfile, n_syms) > 0)
 115       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
 116                        OBJSTAT (objfile, n_syms));
 117     if (OBJSTAT (objfile, n_types) > 0)
 118       printf_filtered (_("  Number of \"types\" defined: %d\n"),
 119                        OBJSTAT (objfile, n_types));
 120     if (objfile->sf)
 121       objfile->sf->qf->print_stats (objfile);
 122     i = linetables = blockvectors = 0;
 123     ALL_OBJFILE_FILETABS (objfile, cu, s)
 124       {
 125         i++;
 126         if (SYMTAB_LINETABLE (s) != NULL)
 127           linetables++;
 128       }
 129     ALL_OBJFILE_COMPUNITS (objfile, cu)
 130       blockvectors++;
 131     printf_filtered (_("  Number of symbol tables: %d\n"), i);
 132     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
 133                      linetables);
 134     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
 135                      blockvectors);
 136
 137     if (OBJSTAT (objfile, sz_strtab) > 0)
 138       printf_filtered (_("  Space used by string tables: %d\n"),
 139                        OBJSTAT (objfile, sz_strtab));
 140     printf_filtered (_("  Total memory used for objfile obstack: %s\n"),
 141                      pulongest (obstack_memory_used (&objfile
 142                                                      ->objfile_obstack)));
 143     printf_filtered (_("  Total memory used for BFD obstack: %s\n"),
 144                      pulongest (obstack_memory_used (&objfile->per_bfd
 145                                                      ->storage_obstack)));
 146     printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
 147                      bcache_memory_used (psymbol_bcache_get_bcache
 148                                           (objfile->psymbol_cache)));
 149     printf_filtered (_("  Total memory used for macro cache: %d\n"),
 150                      bcache_memory_used (objfile->per_bfd->macro_cache));
 151     printf_filtered (_("  Total memory used for file name cache: %d\n"),
 152                      bcache_memory_used (objfile->per_bfd->filename_cache));
 153   }
 154 }
 155
 156 static void
 157 dump_objfile (struct objfile *objfile)
 158 {
 159   struct compunit_symtab *cust;
 160   struct symtab *symtab;
 161
 162   printf_filtered ("\nObject file %s:  ", objfile_name (objfile));
 163   printf_filtered ("Objfile at ");
 164   gdb_print_host_address (objfile, gdb_stdout);
 165   printf_filtered (", bfd at ");
 166   gdb_print_host_address (objfile->obfd, gdb_stdout);
 167   printf_filtered (", %d minsyms\n\n",
 168                    objfile->per_bfd->minimal_symbol_count);
 169
 170   if (objfile->sf)
 171     objfile->sf->qf->dump (objfile);
 172
 173   if (objfile->compunit_symtabs != NULL)
 174     {
 175       printf_filtered ("Symtabs:\n");
 176       ALL_OBJFILE_FILETABS (objfile, cust, symtab)
 177         {
 178           printf_filtered ("%s at ", symtab_to_filename_for_display (symtab));
 179           gdb_print_host_address (symtab, gdb_stdout);
 180           printf_filtered (", ");
 181           if (SYMTAB_OBJFILE (symtab) != objfile)
 182             {
 183               printf_filtered ("NOT ON CHAIN!  ");
 184             }
 185           wrap_here ("  ");
 186         }
 187       printf_filtered ("\n\n");
 188     }
 189 }
 190
 191 /* Print minimal symbols from this objfile.  */
 192
 193 static void
 194 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
 195 {
 196   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 197   struct minimal_symbol *msymbol;
 198   int index;
 199   char ms_type;
 200
 201   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
 202   if (objfile->per_bfd->minimal_symbol_count == 0)
 203     {
 204       fprintf_filtered (outfile, "No minimal symbols found.\n");
 205       return;
 206     }
 207   index = 0;
 208   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
 209     {
 210       struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
 211
 212       switch (MSYMBOL_TYPE (msymbol))
 213         {
 214         case mst_unknown:
 215           ms_type = 'u';
 216           break;
 217         case mst_text:
 218           ms_type = 'T';
 219           break;
 220         case mst_text_gnu_ifunc:
 221           ms_type = 'i';
 222           break;
 223         case mst_solib_trampoline:
 224           ms_type = 'S';
 225           break;
 226         case mst_data:
 227           ms_type = 'D';
 228           break;
 229         case mst_bss:
 230           ms_type = 'B';
 231           break;
 232         case mst_abs:
 233           ms_type = 'A';
 234           break;
 235         case mst_file_text:
 236           ms_type = 't';
 237           break;
 238         case mst_file_data:
 239           ms_type = 'd';
 240           break;
 241         case mst_file_bss:
 242           ms_type = 'b';
 243           break;
 244         default:
 245           ms_type = '?';
 246           break;
 247         }
 248       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
 249       fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
 250                                                                 msymbol)),
 251                       outfile);
 252       fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
 253       if (section)
 254         {
 255           if (section->the_bfd_section != NULL)
 256             fprintf_filtered (outfile, " section %s",
 257                               bfd_section_name (objfile->obfd,
 258                                                 section->the_bfd_section));
 259           else
 260             fprintf_filtered (outfile, " spurious section %ld",
 261                               (long) (section - objfile->sections));
 262         }
 263       if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
 264         {
 265           fprintf_filtered (outfile, "  %s", MSYMBOL_DEMANGLED_NAME (msymbol));
 266         }
 267       if (msymbol->filename)
 268         fprintf_filtered (outfile, "  %s", msymbol->filename);
 269       fputs_filtered ("\n", outfile);
 270       index++;
 271     }
 272   if (objfile->per_bfd->minimal_symbol_count != index)
 273     {
 274       warning (_("internal error:  minimal symbol count %d != %d"),
 275                objfile->per_bfd->minimal_symbol_count, index);
 276     }
 277   fprintf_filtered (outfile, "\n");
 278 }
 279
 280 static void
 281 dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
 282 {
 283   struct objfile *objfile = SYMTAB_OBJFILE (symtab);
 284   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 285   int i;
 286   struct dict_iterator iter;
 287   int len;
 288   struct linetable *l;
 289   const struct blockvector *bv;
 290   struct symbol *sym;
 291   struct block *b;
 292   int depth;
 293
 294   fprintf_filtered (outfile, "\nSymtab for file %s\n",
 295                     symtab_to_filename_for_display (symtab));
 296   if (SYMTAB_DIRNAME (symtab) != NULL)
 297     fprintf_filtered (outfile, "Compilation directory is %s\n",
 298                       SYMTAB_DIRNAME (symtab));
 299   fprintf_filtered (outfile, "Read from object file %s (",
 300                     objfile_name (objfile));
 301   gdb_print_host_address (objfile, outfile);
 302   fprintf_filtered (outfile, ")\n");
 303   fprintf_filtered (outfile, "Language: %s\n",
 304                     language_str (symtab->language));
 305
 306   /* First print the line table.  */
 307   l = SYMTAB_LINETABLE (symtab);
 308   if (l)
 309     {
 310       fprintf_filtered (outfile, "\nLine table:\n\n");
 311       len = l->nitems;
 312       for (i = 0; i < len; i++)
 313         {
 314           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
 315           fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
 316           fprintf_filtered (outfile, "\n");
 317         }
 318     }
 319   /* Now print the block info, but only for compunit symtabs since we will
 320      print lots of duplicate info otherwise.  */
 321   if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)))
 322     {
 323       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 324       bv = SYMTAB_BLOCKVECTOR (symtab);
 325       len = BLOCKVECTOR_NBLOCKS (bv);
 326       for (i = 0; i < len; i++)
 327         {
 328           b = BLOCKVECTOR_BLOCK (bv, i);
 329           depth = block_depth (b) * 2;
 330           print_spaces (depth, outfile);
 331           fprintf_filtered (outfile, "block #%03d, object at ", i);
 332           gdb_print_host_address (b, outfile);
 333           if (BLOCK_SUPERBLOCK (b))
 334             {
 335               fprintf_filtered (outfile, " under ");
 336               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
 337             }
 338           /* drow/2002-07-10: We could save the total symbols count
 339              even if we're using a hashtable, but nothing else but this message
 340              wants it.  */
 341           fprintf_filtered (outfile, ", %d syms/buckets in ",
 342                             dict_size (BLOCK_DICT (b)));
 343           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 344           fprintf_filtered (outfile, "..");
 345           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 346           if (BLOCK_FUNCTION (b))
 347             {
 348               fprintf_filtered (outfile, ", function %s",
 349                                 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
 350               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 351                 {
 352                   fprintf_filtered (outfile, ", %s",
 353                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 354                 }
 355             }
 356           fprintf_filtered (outfile, "\n");
 357           /* Now print each symbol in this block (in no particular order, if
 358              we're using a hashtable).  Note that we only want this
 359              block, not any blocks from included symtabs.  */
 360           ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
 361             {
 362               struct print_symbol_args s;
 363
 364               s.gdbarch = gdbarch;
 365               s.symbol = sym;
 366               s.depth = depth + 1;
 367               s.outfile = outfile;
 368               catch_errors (print_symbol, &s, "Error printing symbol:\n",
 369                             RETURN_MASK_ERROR);
 370             }
 371         }
 372       fprintf_filtered (outfile, "\n");
 373     }
 374   else
 375     {
 376       const char *compunit_filename
 377         = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)));
 378
 379       fprintf_filtered (outfile,
 380                         "\nBlockvector same as owning compunit: %s\n\n",
 381                         compunit_filename);
 382     }
 383 }
 384
 385 static void
 386 dump_symtab (struct symtab *symtab, 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 (symtab, outfile);
 400
 401       set_language (saved_lang);
 402     }
 403   else
 404     dump_symtab_1 (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 = gdb_stdout;
 412   struct cleanup *cleanups;
 413   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
 414   int i, outfile_idx;
 415
 416   dont_repeat ();
 417
 418   argv = gdb_buildargv (args);
 419   cleanups = make_cleanup_freeargv (argv);
 420
 421   for (i = 0; argv[i] != NULL; ++i)
 422     {
 423       if (strcmp (argv[i], "-pc") == 0)
 424         {
 425           if (argv[i + 1] == NULL)
 426             error (_("Missing pc value"));
 427           address_arg = argv[++i];
 428         }
 429       else if (strcmp (argv[i], "-source") == 0)
 430         {
 431           if (argv[i + 1] == NULL)
 432             error (_("Missing source file"));
 433           source_arg = argv[++i];
 434         }
 435       else if (strcmp (argv[i], "-objfile") == 0)
 436         {
 437           if (argv[i + 1] == NULL)
 438             error (_("Missing objfile name"));
 439           objfile_arg = argv[++i];
 440         }
 441       else if (strcmp (argv[i], "--") == 0)
 442         {
 443           /* End of options.  */
 444           ++i;
 445           break;
 446         }
 447       else if (argv[i][0] == '-')
 448         {
 449           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
 450           error (_("Unknown option: %s"), argv[i]);
 451         }
 452       else
 453         break;
 454     }
 455   outfile_idx = i;
 456
 457   if (address_arg != NULL && source_arg != NULL)
 458     error (_("Must specify at most one of -pc and -source"));
 459
 460   if (argv[outfile_idx] != NULL)
 461     {
 462       char *outfile_name;
 463
 464       if (argv[outfile_idx + 1] != NULL)
 465         error (_("Junk at end of command"));
 466       outfile_name = tilde_expand (argv[outfile_idx]);
 467       make_cleanup (xfree, outfile_name);
 468       outfile = gdb_fopen (outfile_name, FOPEN_WT);
 469       if (outfile == NULL)
 470         perror_with_name (outfile_name);
 471       make_cleanup_ui_file_delete (outfile);
 472     }
 473
 474   if (address_arg != NULL)
 475     {
 476       CORE_ADDR pc = parse_and_eval_address (address_arg);
 477       struct symtab *s = find_pc_line_symtab (pc);
 478
 479       if (s == NULL)
 480         error (_("No symtab for address: %s"), address_arg);
 481       dump_symtab (s, outfile);
 482     }
 483   else
 484     {
 485       struct objfile *objfile;
 486       struct compunit_symtab *cu;
 487       struct symtab *s;
 488       int found = 0;
 489
 490       ALL_OBJFILES (objfile)
 491         {
 492           int print_for_objfile = 1;
 493
 494           if (objfile_arg != NULL)
 495             print_for_objfile
 496               = compare_filenames_for_search (objfile_name (objfile),
 497                                               objfile_arg);
 498           if (!print_for_objfile)
 499             continue;
 500
 501           ALL_OBJFILE_FILETABS (objfile, cu, s)
 502             {
 503               int print_for_source = 0;
 504
 505               QUIT;
 506               if (source_arg != NULL)
 507                 {
 508                   print_for_source
 509                     = compare_filenames_for_search
 510                         (symtab_to_filename_for_display (s), source_arg);
 511                   found = 1;
 512                 }
 513               if (source_arg == NULL
 514                   || print_for_source)
 515                 dump_symtab (s, outfile);
 516             }
 517         }
 518
 519       if (source_arg != NULL && !found)
 520         error (_("No symtab for source file: %s"), source_arg);
 521     }
 522
 523   do_cleanups (cleanups);
 524 }
 525
 526 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 527    far to indent.  ARGS is really a struct print_symbol_args *, but is
 528    declared as char * to get it past catch_errors.  Returns 0 for error,
 529    1 for success.  */
 530
 531 static int
 532 print_symbol (void *args)
 533 {
 534   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
 535   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 536   int depth = ((struct print_symbol_args *) args)->depth;
 537   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 538   struct obj_section *section;
 539
 540   if (SYMBOL_OBJFILE_OWNED (symbol))
 541     section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
 542   else
 543     section = NULL;
 544
 545   print_spaces (depth, outfile);
 546   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 547     {
 548       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 549       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 550                       outfile);
 551       if (section)
 552         fprintf_filtered (outfile, " section %s\n",
 553                           bfd_section_name (section->the_bfd_section->owner,
 554                                             section->the_bfd_section));
 555       else
 556         fprintf_filtered (outfile, "\n");
 557       return 1;
 558     }
 559   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 560     {
 561       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 562         {
 563           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 564                          &type_print_raw_options);
 565         }
 566       else
 567         {
 568           fprintf_filtered (outfile, "%s %s = ",
 569                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 570                           ? "enum"
 571                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 572                         ? "struct" : "union")),
 573                             SYMBOL_LINKAGE_NAME (symbol));
 574           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 575                          &type_print_raw_options);
 576         }
 577       fprintf_filtered (outfile, ";\n");
 578     }
 579   else
 580     {
 581       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 582         fprintf_filtered (outfile, "typedef ");
 583       if (SYMBOL_TYPE (symbol))
 584         {
 585           /* Print details of types, except for enums where it's clutter.  */
 586           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 587                          outfile,
 588                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 589                          depth,
 590                          &type_print_raw_options);
 591           fprintf_filtered (outfile, "; ");
 592         }
 593       else
 594         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 595
 596       switch (SYMBOL_CLASS (symbol))
 597         {
 598         case LOC_CONST:
 599           fprintf_filtered (outfile, "const %s (%s)",
 600                             plongest (SYMBOL_VALUE (symbol)),
 601                             hex_string (SYMBOL_VALUE (symbol)));
 602           break;
 603
 604         case LOC_CONST_BYTES:
 605           {
 606             unsigned i;
 607             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 608
 609             fprintf_filtered (outfile, "const %u hex bytes:",
 610                               TYPE_LENGTH (type));
 611             for (i = 0; i < TYPE_LENGTH (type); i++)
 612               fprintf_filtered (outfile, " %02x",
 613                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 614           }
 615           break;
 616
 617         case LOC_STATIC:
 618           fprintf_filtered (outfile, "static at ");
 619           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 620                           outfile);
 621           if (section)
 622             fprintf_filtered (outfile, " section %s",
 623                               bfd_section_name (section->the_bfd_section->owner,
 624                                                 section->the_bfd_section));
 625           break;
 626
 627         case LOC_REGISTER:
 628           if (SYMBOL_IS_ARGUMENT (symbol))
 629             fprintf_filtered (outfile, "parameter register %s",
 630                               plongest (SYMBOL_VALUE (symbol)));
 631           else
 632             fprintf_filtered (outfile, "register %s",
 633                               plongest (SYMBOL_VALUE (symbol)));
 634           break;
 635
 636         case LOC_ARG:
 637           fprintf_filtered (outfile, "arg at offset %s",
 638                             hex_string (SYMBOL_VALUE (symbol)));
 639           break;
 640
 641         case LOC_REF_ARG:
 642           fprintf_filtered (outfile, "reference arg at %s",
 643                             hex_string (SYMBOL_VALUE (symbol)));
 644           break;
 645
 646         case LOC_REGPARM_ADDR:
 647           fprintf_filtered (outfile, "address parameter register %s",
 648                             plongest (SYMBOL_VALUE (symbol)));
 649           break;
 650
 651         case LOC_LOCAL:
 652           fprintf_filtered (outfile, "local at offset %s",
 653                             hex_string (SYMBOL_VALUE (symbol)));
 654           break;
 655
 656         case LOC_TYPEDEF:
 657           break;
 658
 659         case LOC_LABEL:
 660           fprintf_filtered (outfile, "label at ");
 661           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 662                           outfile);
 663           if (section)
 664             fprintf_filtered (outfile, " section %s",
 665                               bfd_section_name (section->the_bfd_section->owner,
 666                                                 section->the_bfd_section));
 667           break;
 668
 669         case LOC_BLOCK:
 670           fprintf_filtered (outfile, "block object ");
 671           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 672           fprintf_filtered (outfile, ", ");
 673           fputs_filtered (paddress (gdbarch,
 674                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 675                           outfile);
 676           fprintf_filtered (outfile, "..");
 677           fputs_filtered (paddress (gdbarch,
 678                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 679                           outfile);
 680           if (section)
 681             fprintf_filtered (outfile, " section %s",
 682                               bfd_section_name (section->the_bfd_section->owner,
 683                                                 section->the_bfd_section));
 684           break;
 685
 686         case LOC_COMPUTED:
 687           fprintf_filtered (outfile, "computed at runtime");
 688           break;
 689
 690         case LOC_UNRESOLVED:
 691           fprintf_filtered (outfile, "unresolved");
 692           break;
 693
 694         case LOC_OPTIMIZED_OUT:
 695           fprintf_filtered (outfile, "optimized out");
 696           break;
 697
 698         default:
 699           fprintf_filtered (outfile, "botched symbol class %x",
 700                             SYMBOL_CLASS (symbol));
 701           break;
 702         }
 703     }
 704   fprintf_filtered (outfile, "\n");
 705   return 1;
 706 }
 707
 708 static void
 709 maintenance_print_msymbols (char *args, int from_tty)
 710 {
 711   char **argv;
 712   struct ui_file *outfile = gdb_stdout;
 713   struct cleanup *cleanups;
 714   char *objfile_arg = NULL;
 715   struct objfile *objfile;
 716   int i, outfile_idx;
 717
 718   dont_repeat ();
 719
 720   argv = gdb_buildargv (args);
 721   cleanups = make_cleanup_freeargv (argv);
 722
 723   for (i = 0; argv[i] != NULL; ++i)
 724     {
 725       if (strcmp (argv[i], "-objfile") == 0)
 726         {
 727           if (argv[i + 1] == NULL)
 728             error (_("Missing objfile name"));
 729           objfile_arg = argv[++i];
 730         }
 731       else if (strcmp (argv[i], "--") == 0)
 732         {
 733           /* End of options.  */
 734           ++i;
 735           break;
 736         }
 737       else if (argv[i][0] == '-')
 738         {
 739           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
 740           error (_("Unknown option: %s"), argv[i]);
 741         }
 742       else
 743         break;
 744     }
 745   outfile_idx = i;
 746
 747   if (argv[outfile_idx] != NULL)
 748     {
 749       char *outfile_name;
 750
 751       if (argv[outfile_idx + 1] != NULL)
 752         error (_("Junk at end of command"));
 753       outfile_name = tilde_expand (argv[outfile_idx]);
 754       make_cleanup (xfree, outfile_name);
 755       outfile = gdb_fopen (outfile_name, FOPEN_WT);
 756       if (outfile == NULL)
 757         perror_with_name (outfile_name);
 758       make_cleanup_ui_file_delete (outfile);
 759     }
 760
 761   ALL_OBJFILES (objfile)
 762   {
 763     QUIT;
 764     if (objfile_arg == NULL
 765         || compare_filenames_for_search (objfile_name (objfile), objfile_arg))
 766       dump_msymbols (objfile, outfile);
 767   }
 768
 769   do_cleanups (cleanups);
 770 }
 771
 772 static void
 773 maintenance_print_objfiles (char *regexp, int from_tty)
 774 {
 775   struct program_space *pspace;
 776   struct objfile *objfile;
 777
 778   dont_repeat ();
 779
 780   if (regexp)
 781     re_comp (regexp);
 782
 783   ALL_PSPACES (pspace)
 784     ALL_PSPACE_OBJFILES (pspace, objfile)
 785       {
 786         QUIT;
 787         if (! regexp
 788             || re_exec (objfile_name (objfile)))
 789           dump_objfile (objfile);
 790       }
 791 }
 792
 793 /* List all the symbol tables whose names match REGEXP (optional).  */
 794
 795 static void
 796 maintenance_info_symtabs (char *regexp, int from_tty)
 797 {
 798   struct program_space *pspace;
 799   struct objfile *objfile;
 800
 801   dont_repeat ();
 802
 803   if (regexp)
 804     re_comp (regexp);
 805
 806   ALL_PSPACES (pspace)
 807     ALL_PSPACE_OBJFILES (pspace, objfile)
 808     {
 809       struct compunit_symtab *cust;
 810       struct symtab *symtab;
 811
 812       /* We don't want to print anything for this objfile until we
 813          actually find a symtab whose name matches.  */
 814       int printed_objfile_start = 0;
 815
 816       ALL_OBJFILE_COMPUNITS (objfile, cust)
 817         {
 818           int printed_compunit_symtab_start = 0;
 819
 820           ALL_COMPUNIT_FILETABS (cust, symtab)
 821             {
 822               QUIT;
 823
 824               if (! regexp
 825                   || re_exec (symtab_to_filename_for_display (symtab)))
 826                 {
 827                   if (! printed_objfile_start)
 828                     {
 829                       printf_filtered ("{ objfile %s ", objfile_name (objfile));
 830                       wrap_here ("  ");
 831                       printf_filtered ("((struct objfile *) %s)\n",
 832                                        host_address_to_string (objfile));
 833                       printed_objfile_start = 1;
 834                     }
 835                   if (! printed_compunit_symtab_start)
 836                     {
 837                       printf_filtered ("  { ((struct compunit_symtab *) %s)\n",
 838                                        host_address_to_string (cust));
 839                       printf_filtered ("    debugformat %s\n",
 840                                        COMPUNIT_DEBUGFORMAT (cust));
 841                       printf_filtered ("    producer %s\n",
 842                                        COMPUNIT_PRODUCER (cust) != NULL
 843                                        ? COMPUNIT_PRODUCER (cust)
 844                                        : "(null)");
 845                       printf_filtered ("    dirname %s\n",
 846                                        COMPUNIT_DIRNAME (cust) != NULL
 847                                        ? COMPUNIT_DIRNAME (cust)
 848                                        : "(null)");
 849                       printf_filtered ("    blockvector"
 850                                        " ((struct blockvector *) %s)\n",
 851                                        host_address_to_string
 852                                          (COMPUNIT_BLOCKVECTOR (cust)));
 853                       printed_compunit_symtab_start = 1;
 854                     }
 855
 856                   printf_filtered ("\t{ symtab %s ",
 857                                    symtab_to_filename_for_display (symtab));
 858                   wrap_here ("    ");
 859                   printf_filtered ("((struct symtab *) %s)\n",
 860                                    host_address_to_string (symtab));
 861                   printf_filtered ("\t  fullname %s\n",
 862                                    symtab->fullname != NULL
 863                                    ? symtab->fullname
 864                                    : "(null)");
 865                   printf_filtered ("\t  "
 866                                    "linetable ((struct linetable *) %s)\n",
 867                                    host_address_to_string (symtab->linetable));
 868                   printf_filtered ("\t}\n");
 869                 }
 870             }
 871
 872           if (printed_compunit_symtab_start)
 873             printf_filtered ("  }\n");
 874         }
 875
 876       if (printed_objfile_start)
 877         printf_filtered ("}\n");
 878     }
 879 }
 880
 881 /* Check consistency of symtabs.
 882    An example of what this checks for is NULL blockvectors.
 883    They can happen if there's a bug during debug info reading.
 884    GDB assumes they are always non-NULL.
 885
 886    Note: This does not check for psymtab vs symtab consistency.
 887    Use "maint check-psymtabs" for that.  */
 888
 889 static void
 890 maintenance_check_symtabs (char *ignore, int from_tty)
 891 {
 892   struct program_space *pspace;
 893   struct objfile *objfile;
 894
 895   ALL_PSPACES (pspace)
 896     ALL_PSPACE_OBJFILES (pspace, objfile)
 897     {
 898       struct compunit_symtab *cust;
 899
 900       /* We don't want to print anything for this objfile until we
 901          actually find something worth printing.  */
 902       int printed_objfile_start = 0;
 903
 904       ALL_OBJFILE_COMPUNITS (objfile, cust)
 905         {
 906           int found_something = 0;
 907           struct symtab *symtab = compunit_primary_filetab (cust);
 908
 909           QUIT;
 910
 911           if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 912             found_something = 1;
 913           /* Add more checks here.  */
 914
 915           if (found_something)
 916             {
 917               if (! printed_objfile_start)
 918                 {
 919                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
 920                   wrap_here ("  ");
 921                   printf_filtered ("((struct objfile *) %s)\n",
 922                                    host_address_to_string (objfile));
 923                   printed_objfile_start = 1;
 924                 }
 925               printf_filtered ("  { symtab %s\n",
 926                                symtab_to_filename_for_display (symtab));
 927               if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 928                 printf_filtered ("    NULL blockvector\n");
 929               printf_filtered ("  }\n");
 930             }
 931         }
 932
 933       if (printed_objfile_start)
 934         printf_filtered ("}\n");
 935     }
 936 }
 937
 938 /* Helper function for maintenance_expand_symtabs.
 939    This is the name_matcher function for expand_symtabs_matching.  */
 940
 941 static int
 942 maintenance_expand_name_matcher (const char *symname, void *data)
 943 {
 944   /* Since we're not searching on symbols, just return TRUE.  */
 945   return 1;
 946 }
 947
 948 /* Helper function for maintenance_expand_symtabs.
 949    This is the file_matcher function for expand_symtabs_matching.  */
 950
 951 static int
 952 maintenance_expand_file_matcher (const char *filename, void *data,
 953                                  int basenames)
 954 {
 955   const char *regexp = (const char *) data;
 956
 957   QUIT;
 958
 959   /* KISS: Only apply the regexp to the complete file name.  */
 960   if (basenames)
 961     return 0;
 962
 963   if (regexp == NULL || re_exec (filename))
 964     return 1;
 965
 966   return 0;
 967 }
 968
 969 /* Expand all symbol tables whose name matches an optional regexp.  */
 970
 971 static void
 972 maintenance_expand_symtabs (char *args, int from_tty)
 973 {
 974   struct program_space *pspace;
 975   struct objfile *objfile;
 976   struct cleanup *cleanups;
 977   char **argv;
 978   char *regexp = NULL;
 979
 980   /* We use buildargv here so that we handle spaces in the regexp
 981      in a way that allows adding more arguments later.  */
 982   argv = gdb_buildargv (args);
 983   cleanups = make_cleanup_freeargv (argv);
 984
 985   if (argv != NULL)
 986     {
 987       if (argv[0] != NULL)
 988         {
 989           regexp = argv[0];
 990           if (argv[1] != NULL)
 991             error (_("Extra arguments after regexp."));
 992         }
 993     }
 994
 995   if (regexp)
 996     re_comp (regexp);
 997
 998   ALL_PSPACES (pspace)
 999     ALL_PSPACE_OBJFILES (pspace, objfile)
1000     {
1001       if (objfile->sf)
1002         {
1003           objfile->sf->qf->expand_symtabs_matching
1004             (objfile, maintenance_expand_file_matcher,
1005              maintenance_expand_name_matcher, NULL, ALL_DOMAIN, regexp);
1006         }
1007     }
1008
1009   do_cleanups (cleanups);
1010 }
1011 \f
1012
1013 /* Return the nexting depth of a block within other blocks in its symtab.  */
1014
1015 static int
1016 block_depth (struct block *block)
1017 {
1018   int i = 0;
1019
1020   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1021     {
1022       i++;
1023     }
1024   return i;
1025 }
1026 \f
1027
1028 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
1029    single line table.  */
1030
1031 static int
1032 maintenance_print_one_line_table (struct symtab *symtab, void *data)
1033 {
1034   struct linetable *linetable;
1035   struct objfile *objfile;
1036
1037   objfile = symtab->compunit_symtab->objfile;
1038   printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
1039                    objfile_name (objfile),
1040                    host_address_to_string (objfile));
1041   printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
1042                    host_address_to_string (symtab->compunit_symtab));
1043   printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
1044                    symtab_to_fullname (symtab),
1045                    host_address_to_string (symtab));
1046   linetable = SYMTAB_LINETABLE (symtab);
1047   printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
1048                    host_address_to_string (linetable));
1049
1050   if (linetable == NULL)
1051     printf_filtered (_("No line table.\n"));
1052   else if (linetable->nitems <= 0)
1053     printf_filtered (_("Line table has no lines.\n"));
1054   else
1055     {
1056       int i;
1057
1058       /* Leave space for 6 digits of index and line number.  After that the
1059          tables will just not format as well.  */
1060       printf_filtered (_("%-6s %6s %s\n"),
1061                        _("INDEX"), _("LINE"), _("ADDRESS"));
1062
1063       for (i = 0; i < linetable->nitems; ++i)
1064         {
1065           struct linetable_entry *item;
1066
1067           item = &linetable->item [i];
1068           printf_filtered (_("%-6d %6d %s\n"), i, item->line,
1069                            core_addr_to_string (item->pc));
1070         }
1071     }
1072
1073   return 0;
1074 }
1075
1076 /* Implement the 'maint info line-table' command.  */
1077
1078 static void
1079 maintenance_info_line_tables (char *regexp, int from_tty)
1080 {
1081   struct program_space *pspace;
1082   struct objfile *objfile;
1083
1084   dont_repeat ();
1085
1086   if (regexp != NULL)
1087     re_comp (regexp);
1088
1089   ALL_PSPACES (pspace)
1090     ALL_PSPACE_OBJFILES (pspace, objfile)
1091     {
1092       struct compunit_symtab *cust;
1093       struct symtab *symtab;
1094
1095       ALL_OBJFILE_COMPUNITS (objfile, cust)
1096         {
1097           ALL_COMPUNIT_FILETABS (cust, symtab)
1098             {
1099               QUIT;
1100
1101               if (regexp == NULL
1102                   || re_exec (symtab_to_filename_for_display (symtab)))
1103                 maintenance_print_one_line_table (symtab, NULL);
1104             }
1105         }
1106     }
1107 }
1108
1109 \f
1110
1111 /* Do early runtime initializations.  */
1112
1113 void
1114 _initialize_symmisc (void)
1115 {
1116   std_in = stdin;
1117   std_out = stdout;
1118   std_err = stderr;
1119
1120   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1121 Print dump of current symbol definitions.\n\
1122 Usage: mt print symbols [-pc address] [--] [outfile]\n\
1123        mt print symbols [-objfile objfile] [-source source] [--] [outfile]\n\
1124 Entries in the full symbol table are dumped to file OUTFILE,\n\
1125 or the terminal if OUTFILE is unspecified.\n\
1126 If ADDRESS is provided, dump only the file for that address.\n\
1127 If SOURCE is provided, dump only that file's symbols.\n\
1128 If OBJFILE is provided, dump only that file's minimal symbols."),
1129            &maintenanceprintlist);
1130
1131   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1132 Print dump of current minimal symbol definitions.\n\
1133 Usage: mt print msymbols [-objfile objfile] [--] [outfile]\n\
1134 Entries in the minimal symbol table are dumped to file OUTFILE,\n\
1135 or the terminal if OUTFILE is unspecified.\n\
1136 If OBJFILE is provided, dump only that file's minimal symbols."),
1137            &maintenanceprintlist);
1138
1139   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1140            _("Print dump of current object file definitions.\n\
1141 With an argument REGEXP, list the object files with matching names."),
1142            &maintenanceprintlist);
1143
1144   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1145 List the full symbol tables for all object files.\n\
1146 This does not include information about individual symbols, blocks, or\n\
1147 linetables --- just the symbol table structures themselves.\n\
1148 With an argument REGEXP, list the symbol tables with matching names."),
1149            &maintenanceinfolist);
1150
1151   add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1152 List the contents of all line tables, from all symbol tables.\n\
1153 With an argument REGEXP, list just the line tables for the symbol\n\
1154 tables with matching names."),
1155            &maintenanceinfolist);
1156
1157   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1158            _("\
1159 Check consistency of currently expanded symtabs."),
1160            &maintenancelist);
1161
1162   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1163            _("Expand symbol tables.\n\
1164 With an argument REGEXP, only expand the symbol tables with matching names."),
1165            &maintenancelist);
1166 }