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           if (l->item[i].is_stmt)
 305             fprintf_filtered (outfile, "\t(stmt)");
 306           fprintf_filtered (outfile, "\n");
 307         }
 308     }
 309   /* Now print the block info, but only for compunit symtabs since we will
 310      print lots of duplicate info otherwise.  */
 311   if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)))
 312     {
 313       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 314       bv = SYMTAB_BLOCKVECTOR (symtab);
 315       len = BLOCKVECTOR_NBLOCKS (bv);
 316       for (i = 0; i < len; i++)
 317         {
 318           b = BLOCKVECTOR_BLOCK (bv, i);
 319           depth = block_depth (b) * 2;
 320           print_spaces (depth, outfile);
 321           fprintf_filtered (outfile, "block #%03d, object at ", i);
 322           gdb_print_host_address (b, outfile);
 323           if (BLOCK_SUPERBLOCK (b))
 324             {
 325               fprintf_filtered (outfile, " under ");
 326               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
 327             }
 328           /* drow/2002-07-10: We could save the total symbols count
 329              even if we're using a hashtable, but nothing else but this message
 330              wants it.  */
 331           fprintf_filtered (outfile, ", %d syms/buckets in ",
 332                             mdict_size (BLOCK_MULTIDICT (b)));
 333           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
 334           fprintf_filtered (outfile, "..");
 335           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
 336           if (BLOCK_FUNCTION (b))
 337             {
 338               fprintf_filtered (outfile, ", function %s",
 339                                 BLOCK_FUNCTION (b)->linkage_name ());
 340               if (BLOCK_FUNCTION (b)->demangled_name () != NULL)
 341                 {
 342                   fprintf_filtered (outfile, ", %s",
 343                                 BLOCK_FUNCTION (b)->demangled_name ());
 344                 }
 345             }
 346           fprintf_filtered (outfile, "\n");
 347           /* Now print each symbol in this block (in no particular order, if
 348              we're using a hashtable).  Note that we only want this
 349              block, not any blocks from included symtabs.  */
 350           ALL_DICT_SYMBOLS (BLOCK_MULTIDICT (b), miter, sym)
 351             {
 352               try
 353                 {
 354                   print_symbol (gdbarch, sym, depth + 1, outfile);
 355                 }
 356               catch (const gdb_exception_error &ex)
 357                 {
 358                   exception_fprintf (gdb_stderr, ex,
 359                                      "Error printing symbol:\n");
 360                 }
 361             }
 362         }
 363       fprintf_filtered (outfile, "\n");
 364     }
 365   else
 366     {
 367       const char *compunit_filename
 368         = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)));
 369
 370       fprintf_filtered (outfile,
 371                         "\nBlockvector same as owning compunit: %s\n\n",
 372                         compunit_filename);
 373     }
 374 }
 375
 376 static void
 377 dump_symtab (struct symtab *symtab, struct ui_file *outfile)
 378 {
 379   /* Set the current language to the language of the symtab we're dumping
 380      because certain routines used during dump_symtab() use the current
 381      language to print an image of the symbol.  We'll restore it later.
 382      But use only real languages, not placeholders.  */
 383   if (symtab->language != language_unknown
 384       && symtab->language != language_auto)
 385     {
 386       scoped_restore_current_language save_lang;
 387       set_language (symtab->language);
 388       dump_symtab_1 (symtab, outfile);
 389     }
 390   else
 391     dump_symtab_1 (symtab, outfile);
 392 }
 393
 394 static void
 395 maintenance_print_symbols (const char *args, int from_tty)
 396 {
 397   struct ui_file *outfile = gdb_stdout;
 398   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
 399   int i, outfile_idx;
 400
 401   dont_repeat ();
 402
 403   gdb_argv argv (args);
 404
 405   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
 406     {
 407       if (strcmp (argv[i], "-pc") == 0)
 408         {
 409           if (argv[i + 1] == NULL)
 410             error (_("Missing pc value"));
 411           address_arg = argv[++i];
 412         }
 413       else if (strcmp (argv[i], "-source") == 0)
 414         {
 415           if (argv[i + 1] == NULL)
 416             error (_("Missing source file"));
 417           source_arg = argv[++i];
 418         }
 419       else if (strcmp (argv[i], "-objfile") == 0)
 420         {
 421           if (argv[i + 1] == NULL)
 422             error (_("Missing objfile name"));
 423           objfile_arg = argv[++i];
 424         }
 425       else if (strcmp (argv[i], "--") == 0)
 426         {
 427           /* End of options.  */
 428           ++i;
 429           break;
 430         }
 431       else if (argv[i][0] == '-')
 432         {
 433           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
 434           error (_("Unknown option: %s"), argv[i]);
 435         }
 436       else
 437         break;
 438     }
 439   outfile_idx = i;
 440
 441   if (address_arg != NULL && source_arg != NULL)
 442     error (_("Must specify at most one of -pc and -source"));
 443
 444   stdio_file arg_outfile;
 445
 446   if (argv != NULL && argv[outfile_idx] != NULL)
 447     {
 448       if (argv[outfile_idx + 1] != NULL)
 449         error (_("Junk at end of command"));
 450       gdb::unique_xmalloc_ptr<char> outfile_name
 451         (tilde_expand (argv[outfile_idx]));
 452       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
 453         perror_with_name (outfile_name.get ());
 454       outfile = &arg_outfile;
 455     }
 456
 457   if (address_arg != NULL)
 458     {
 459       CORE_ADDR pc = parse_and_eval_address (address_arg);
 460       struct symtab *s = find_pc_line_symtab (pc);
 461
 462       if (s == NULL)
 463         error (_("No symtab for address: %s"), address_arg);
 464       dump_symtab (s, outfile);
 465     }
 466   else
 467     {
 468       int found = 0;
 469
 470       for (objfile *objfile : current_program_space->objfiles ())
 471         {
 472           int print_for_objfile = 1;
 473
 474           if (objfile_arg != NULL)
 475             print_for_objfile
 476               = compare_filenames_for_search (objfile_name (objfile),
 477                                               objfile_arg);
 478           if (!print_for_objfile)
 479             continue;
 480
 481           for (compunit_symtab *cu : objfile->compunits ())
 482             {
 483               for (symtab *s : compunit_filetabs (cu))
 484                 {
 485                   int print_for_source = 0;
 486
 487                   QUIT;
 488                   if (source_arg != NULL)
 489                     {
 490                       print_for_source
 491                         = compare_filenames_for_search
 492                         (symtab_to_filename_for_display (s), source_arg);
 493                       found = 1;
 494                     }
 495                   if (source_arg == NULL
 496                       || print_for_source)
 497                     dump_symtab (s, outfile);
 498                 }
 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 ());
 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));
 529       else
 530         fprintf_filtered (outfile, "\n");
 531       return;
 532     }
 533
 534   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 535     {
 536       if (TYPE_NAME (SYMBOL_TYPE (symbol)))
 537         {
 538           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 539                          &type_print_raw_options);
 540         }
 541       else
 542         {
 543           fprintf_filtered (outfile, "%s %s = ",
 544                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 545                           ? "enum"
 546                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 547                         ? "struct" : "union")),
 548                             symbol->linkage_name ());
 549           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
 550                          &type_print_raw_options);
 551         }
 552       fprintf_filtered (outfile, ";\n");
 553     }
 554   else
 555     {
 556       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 557         fprintf_filtered (outfile, "typedef ");
 558       if (SYMBOL_TYPE (symbol))
 559         {
 560           /* Print details of types, except for enums where it's clutter.  */
 561           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), symbol->print_name (),
 562                          outfile,
 563                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 564                          depth,
 565                          &type_print_raw_options);
 566           fprintf_filtered (outfile, "; ");
 567         }
 568       else
 569         fprintf_filtered (outfile, "%s ", symbol->print_name ());
 570
 571       switch (SYMBOL_CLASS (symbol))
 572         {
 573         case LOC_CONST:
 574           fprintf_filtered (outfile, "const %s (%s)",
 575                             plongest (SYMBOL_VALUE (symbol)),
 576                             hex_string (SYMBOL_VALUE (symbol)));
 577           break;
 578
 579         case LOC_CONST_BYTES:
 580           {
 581             unsigned i;
 582             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 583
 584             fprintf_filtered (outfile, "const %s hex bytes:",
 585                               pulongest (TYPE_LENGTH (type)));
 586             for (i = 0; i < TYPE_LENGTH (type); i++)
 587               fprintf_filtered (outfile, " %02x",
 588                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 589           }
 590           break;
 591
 592         case LOC_STATIC:
 593           fprintf_filtered (outfile, "static at ");
 594           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 595                           outfile);
 596           if (section)
 597             fprintf_filtered (outfile, " section %s",
 598                               bfd_section_name (section->the_bfd_section));
 599           break;
 600
 601         case LOC_REGISTER:
 602           if (SYMBOL_IS_ARGUMENT (symbol))
 603             fprintf_filtered (outfile, "parameter register %s",
 604                               plongest (SYMBOL_VALUE (symbol)));
 605           else
 606             fprintf_filtered (outfile, "register %s",
 607                               plongest (SYMBOL_VALUE (symbol)));
 608           break;
 609
 610         case LOC_ARG:
 611           fprintf_filtered (outfile, "arg at offset %s",
 612                             hex_string (SYMBOL_VALUE (symbol)));
 613           break;
 614
 615         case LOC_REF_ARG:
 616           fprintf_filtered (outfile, "reference arg at %s",
 617                             hex_string (SYMBOL_VALUE (symbol)));
 618           break;
 619
 620         case LOC_REGPARM_ADDR:
 621           fprintf_filtered (outfile, "address parameter register %s",
 622                             plongest (SYMBOL_VALUE (symbol)));
 623           break;
 624
 625         case LOC_LOCAL:
 626           fprintf_filtered (outfile, "local at offset %s",
 627                             hex_string (SYMBOL_VALUE (symbol)));
 628           break;
 629
 630         case LOC_TYPEDEF:
 631           break;
 632
 633         case LOC_LABEL:
 634           fprintf_filtered (outfile, "label at ");
 635           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
 636                           outfile);
 637           if (section)
 638             fprintf_filtered (outfile, " section %s",
 639                               bfd_section_name (section->the_bfd_section));
 640           break;
 641
 642         case LOC_BLOCK:
 643           fprintf_filtered (outfile, "block object ");
 644           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 645           fprintf_filtered (outfile, ", ");
 646           fputs_filtered (paddress (gdbarch,
 647                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 648                           outfile);
 649           fprintf_filtered (outfile, "..");
 650           fputs_filtered (paddress (gdbarch,
 651                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 652                           outfile);
 653           if (section)
 654             fprintf_filtered (outfile, " section %s",
 655                               bfd_section_name (section->the_bfd_section));
 656           break;
 657
 658         case LOC_COMPUTED:
 659           fprintf_filtered (outfile, "computed at runtime");
 660           break;
 661
 662         case LOC_UNRESOLVED:
 663           fprintf_filtered (outfile, "unresolved");
 664           break;
 665
 666         case LOC_OPTIMIZED_OUT:
 667           fprintf_filtered (outfile, "optimized out");
 668           break;
 669
 670         default:
 671           fprintf_filtered (outfile, "botched symbol class %x",
 672                             SYMBOL_CLASS (symbol));
 673           break;
 674         }
 675     }
 676   fprintf_filtered (outfile, "\n");
 677 }
 678
 679 static void
 680 maintenance_print_msymbols (const char *args, int from_tty)
 681 {
 682   struct ui_file *outfile = gdb_stdout;
 683   char *objfile_arg = NULL;
 684   int i, outfile_idx;
 685
 686   dont_repeat ();
 687
 688   gdb_argv argv (args);
 689
 690   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
 691     {
 692       if (strcmp (argv[i], "-objfile") == 0)
 693         {
 694           if (argv[i + 1] == NULL)
 695             error (_("Missing objfile name"));
 696           objfile_arg = argv[++i];
 697         }
 698       else if (strcmp (argv[i], "--") == 0)
 699         {
 700           /* End of options.  */
 701           ++i;
 702           break;
 703         }
 704       else if (argv[i][0] == '-')
 705         {
 706           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
 707           error (_("Unknown option: %s"), argv[i]);
 708         }
 709       else
 710         break;
 711     }
 712   outfile_idx = i;
 713
 714   stdio_file arg_outfile;
 715
 716   if (argv != NULL && argv[outfile_idx] != NULL)
 717     {
 718       if (argv[outfile_idx + 1] != NULL)
 719         error (_("Junk at end of command"));
 720       gdb::unique_xmalloc_ptr<char> outfile_name
 721         (tilde_expand (argv[outfile_idx]));
 722       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
 723         perror_with_name (outfile_name.get ());
 724       outfile = &arg_outfile;
 725     }
 726
 727   for (objfile *objfile : current_program_space->objfiles ())
 728     {
 729       QUIT;
 730       if (objfile_arg == NULL
 731           || compare_filenames_for_search (objfile_name (objfile), objfile_arg))
 732         dump_msymbols (objfile, outfile);
 733     }
 734 }
 735
 736 static void
 737 maintenance_print_objfiles (const char *regexp, int from_tty)
 738 {
 739   struct program_space *pspace;
 740
 741   dont_repeat ();
 742
 743   if (regexp)
 744     re_comp (regexp);
 745
 746   ALL_PSPACES (pspace)
 747     for (objfile *objfile : pspace->objfiles ())
 748       {
 749         QUIT;
 750         if (! regexp
 751             || re_exec (objfile_name (objfile)))
 752           dump_objfile (objfile);
 753       }
 754 }
 755
 756 /* List all the symbol tables whose names match REGEXP (optional).  */
 757
 758 static void
 759 maintenance_info_symtabs (const char *regexp, int from_tty)
 760 {
 761   struct program_space *pspace;
 762
 763   dont_repeat ();
 764
 765   if (regexp)
 766     re_comp (regexp);
 767
 768   ALL_PSPACES (pspace)
 769     for (objfile *objfile : pspace->objfiles ())
 770       {
 771         /* We don't want to print anything for this objfile until we
 772            actually find a symtab whose name matches.  */
 773         int printed_objfile_start = 0;
 774
 775         for (compunit_symtab *cust : objfile->compunits ())
 776           {
 777             int printed_compunit_symtab_start = 0;
 778
 779             for (symtab *symtab : compunit_filetabs (cust))
 780               {
 781                 QUIT;
 782
 783                 if (! regexp
 784                     || re_exec (symtab_to_filename_for_display (symtab)))
 785                   {
 786                     if (! printed_objfile_start)
 787                       {
 788                         printf_filtered ("{ objfile %s ", objfile_name (objfile));
 789                         wrap_here ("  ");
 790                         printf_filtered ("((struct objfile *) %s)\n",
 791                                          host_address_to_string (objfile));
 792                         printed_objfile_start = 1;
 793                       }
 794                     if (! printed_compunit_symtab_start)
 795                       {
 796                         printf_filtered ("  { ((struct compunit_symtab *) %s)\n",
 797                                          host_address_to_string (cust));
 798                         printf_filtered ("    debugformat %s\n",
 799                                          COMPUNIT_DEBUGFORMAT (cust));
 800                         printf_filtered ("    producer %s\n",
 801                                          COMPUNIT_PRODUCER (cust) != NULL
 802                                          ? COMPUNIT_PRODUCER (cust)
 803                                          : "(null)");
 804                         printf_filtered ("    dirname %s\n",
 805                                          COMPUNIT_DIRNAME (cust) != NULL
 806                                          ? COMPUNIT_DIRNAME (cust)
 807                                          : "(null)");
 808                         printf_filtered ("    blockvector"
 809                                          " ((struct blockvector *) %s)\n",
 810                                          host_address_to_string
 811                                          (COMPUNIT_BLOCKVECTOR (cust)));
 812                         printed_compunit_symtab_start = 1;
 813                       }
 814
 815                     printf_filtered ("\t{ symtab %s ",
 816                                      symtab_to_filename_for_display (symtab));
 817                     wrap_here ("    ");
 818                     printf_filtered ("((struct symtab *) %s)\n",
 819                                      host_address_to_string (symtab));
 820                     printf_filtered ("\t  fullname %s\n",
 821                                      symtab->fullname != NULL
 822                                      ? symtab->fullname
 823                                      : "(null)");
 824                     printf_filtered ("\t  "
 825                                      "linetable ((struct linetable *) %s)\n",
 826                                      host_address_to_string (symtab->linetable));
 827                     printf_filtered ("\t}\n");
 828                   }
 829               }
 830
 831             if (printed_compunit_symtab_start)
 832               printf_filtered ("  }\n");
 833           }
 834
 835         if (printed_objfile_start)
 836           printf_filtered ("}\n");
 837       }
 838 }
 839
 840 /* Check consistency of symtabs.
 841    An example of what this checks for is NULL blockvectors.
 842    They can happen if there's a bug during debug info reading.
 843    GDB assumes they are always non-NULL.
 844
 845    Note: This does not check for psymtab vs symtab consistency.
 846    Use "maint check-psymtabs" for that.  */
 847
 848 static void
 849 maintenance_check_symtabs (const char *ignore, int from_tty)
 850 {
 851   struct program_space *pspace;
 852
 853   ALL_PSPACES (pspace)
 854     for (objfile *objfile : pspace->objfiles ())
 855       {
 856         /* We don't want to print anything for this objfile until we
 857            actually find something worth printing.  */
 858         int printed_objfile_start = 0;
 859
 860         for (compunit_symtab *cust : objfile->compunits ())
 861           {
 862             int found_something = 0;
 863             struct symtab *symtab = compunit_primary_filetab (cust);
 864
 865             QUIT;
 866
 867             if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 868               found_something = 1;
 869             /* Add more checks here.  */
 870
 871             if (found_something)
 872               {
 873                 if (! printed_objfile_start)
 874                   {
 875                     printf_filtered ("{ objfile %s ", objfile_name (objfile));
 876                     wrap_here ("  ");
 877                     printf_filtered ("((struct objfile *) %s)\n",
 878                                      host_address_to_string (objfile));
 879                     printed_objfile_start = 1;
 880                   }
 881                 printf_filtered ("  { symtab %s\n",
 882                                  symtab_to_filename_for_display (symtab));
 883                 if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
 884                   printf_filtered ("    NULL blockvector\n");
 885                 printf_filtered ("  }\n");
 886               }
 887           }
 888
 889         if (printed_objfile_start)
 890           printf_filtered ("}\n");
 891       }
 892 }
 893
 894 /* Expand all symbol tables whose name matches an optional regexp.  */
 895
 896 static void
 897 maintenance_expand_symtabs (const char *args, int from_tty)
 898 {
 899   struct program_space *pspace;
 900   char *regexp = NULL;
 901
 902   /* We use buildargv here so that we handle spaces in the regexp
 903      in a way that allows adding more arguments later.  */
 904   gdb_argv argv (args);
 905
 906   if (argv != NULL)
 907     {
 908       if (argv[0] != NULL)
 909         {
 910           regexp = argv[0];
 911           if (argv[1] != NULL)
 912             error (_("Extra arguments after regexp."));
 913         }
 914     }
 915
 916   if (regexp)
 917     re_comp (regexp);
 918
 919   ALL_PSPACES (pspace)
 920     for (objfile *objfile : pspace->objfiles ())
 921       {
 922         if (objfile->sf)
 923           {
 924             objfile->sf->qf->expand_symtabs_matching
 925               (objfile,
 926                [&] (const char *filename, bool basenames)
 927                {
 928                  /* KISS: Only apply the regexp to the complete file name.  */
 929                  return (!basenames
 930                          && (regexp == NULL || re_exec (filename)));
 931                },
 932                lookup_name_info::match_any (),
 933                [] (const char *symname)
 934                {
 935                  /* Since we're not searching on symbols, just return true.  */
 936                  return true;
 937                },
 938                NULL,
 939                ALL_DOMAIN);
 940           }
 941       }
 942 }
 943 \f
 944
 945 /* Return the nexting depth of a block within other blocks in its symtab.  */
 946
 947 static int
 948 block_depth (const struct block *block)
 949 {
 950   int i = 0;
 951
 952   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
 953     {
 954       i++;
 955     }
 956   return i;
 957 }
 958 \f
 959
 960 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
 961    single line table.  */
 962
 963 static int
 964 maintenance_print_one_line_table (struct symtab *symtab, void *data)
 965 {
 966   struct linetable *linetable;
 967   struct objfile *objfile;
 968
 969   objfile = symtab->compunit_symtab->objfile;
 970   printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
 971                    objfile_name (objfile),
 972                    host_address_to_string (objfile));
 973   printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
 974                    host_address_to_string (symtab->compunit_symtab));
 975   printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
 976                    symtab_to_fullname (symtab),
 977                    host_address_to_string (symtab));
 978   linetable = SYMTAB_LINETABLE (symtab);
 979   printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
 980                    host_address_to_string (linetable));
 981
 982   if (linetable == NULL)
 983     printf_filtered (_("No line table.\n"));
 984   else if (linetable->nitems <= 0)
 985     printf_filtered (_("Line table has no lines.\n"));
 986   else
 987     {
 988       int i;
 989
 990       /* Leave space for 6 digits of index and line number.  After that the
 991          tables will just not format as well.  */
 992       printf_filtered (_("%-6s %6s %s %s\n"),
 993                        _("INDEX"), _("LINE"), _("ADDRESS"), _("IS-STMT"));
 994
 995       for (i = 0; i < linetable->nitems; ++i)
 996         {
 997           struct linetable_entry *item;
 998
 999           item = &linetable->item [i];
1000           printf_filtered ("%-6d ", i);
1001           if (item->line > 0)
1002             printf_filtered ("%6d ", item->line);
1003           else
1004             printf_filtered ("%6s ", _("END"));
1005           printf_filtered ("%s%s\n",
1006                            core_addr_to_string (item->pc),
1007                            (item->is_stmt ? " Y" : ""));
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 : pspace->objfiles ())
1028       {
1029         for (compunit_symtab *cust : objfile->compunits ())
1030           {
1031             for (symtab *symtab : compunit_filetabs (cust))
1032               {
1033                 QUIT;
1034
1035                 if (regexp == NULL
1036                     || re_exec (symtab_to_filename_for_display (symtab)))
1037                   maintenance_print_one_line_table (symtab, NULL);
1038               }
1039           }
1040       }
1041 }
1042
1043 \f
1044
1045 /* Do early runtime initializations.  */
1046
1047 void _initialize_symmisc ();
1048 void
1049 _initialize_symmisc ()
1050 {
1051   std_in = stdin;
1052   std_out = stdout;
1053   std_err = stderr;
1054
1055   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1056 Print dump of current symbol definitions.\n\
1057 Usage: mt print symbols [-pc ADDRESS] [--] [OUTFILE]\n\
1058        mt print symbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1059 Entries in the full symbol table are dumped to file OUTFILE,\n\
1060 or the terminal if OUTFILE is unspecified.\n\
1061 If ADDRESS is provided, dump only the file for that address.\n\
1062 If SOURCE is provided, dump only that file's symbols.\n\
1063 If OBJFILE is provided, dump only that file's minimal symbols."),
1064            &maintenanceprintlist);
1065
1066   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1067 Print dump of current minimal symbol definitions.\n\
1068 Usage: mt print msymbols [-objfile OBJFILE] [--] [OUTFILE]\n\
1069 Entries in the minimal symbol table are dumped to file OUTFILE,\n\
1070 or the terminal if OUTFILE is unspecified.\n\
1071 If OBJFILE is provided, dump only that file's minimal symbols."),
1072            &maintenanceprintlist);
1073
1074   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1075            _("Print dump of current object file definitions.\n\
1076 With an argument REGEXP, list the object files with matching names."),
1077            &maintenanceprintlist);
1078
1079   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1080 List the full symbol tables for all object files.\n\
1081 This does not include information about individual symbols, blocks, or\n\
1082 linetables --- just the symbol table structures themselves.\n\
1083 With an argument REGEXP, list the symbol tables with matching names."),
1084            &maintenanceinfolist);
1085
1086   add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1087 List the contents of all line tables, from all symbol tables.\n\
1088 With an argument REGEXP, list just the line tables for the symbol\n\
1089 tables with matching names."),
1090            &maintenanceinfolist);
1091
1092   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1093            _("\
1094 Check consistency of currently expanded symtabs."),
1095            &maintenancelist);
1096
1097   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1098            _("Expand symbol tables.\n\
1099 With an argument REGEXP, only expand the symbol tables with matching names."),
1100            &maintenancelist);
1101 }