gdb/symmisc.c

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