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