gdb/symmisc.c

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