gdb/symmisc.c

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