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   char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
 381   int i, outfile_idx;
 382
 383   dont_repeat ();
 384
 385   gdb_argv argv (args);
 386
 387   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
 388     {
 389       if (strcmp (argv[i], "-pc") == 0)
 390         {
 391           if (argv[i + 1] == NULL)
 392             error (_("Missing pc value"));
 393           address_arg = argv[++i];
 394         }
 395       else if (strcmp (argv[i], "-source") == 0)
 396         {
 397           if (argv[i + 1] == NULL)
 398             error (_("Missing source file"));
 399           source_arg = argv[++i];
 400         }
 401       else if (strcmp (argv[i], "-objfile") == 0)
 402         {
 403           if (argv[i + 1] == NULL)
 404             error (_("Missing objfile name"));
 405           objfile_arg = argv[++i];
 406         }
 407       else if (strcmp (argv[i], "--") == 0)
 408         {
 409           /* End of options.  */
 410           ++i;
 411           break;
 412         }
 413       else if (argv[i][0] == '-')
 414         {
 415           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
 416           error (_("Unknown option: %s"), argv[i]);
 417         }
 418       else
 419         break;
 420     }
 421   outfile_idx = i;
 422
 423   if (address_arg != NULL && source_arg != NULL)
 424     error (_("Must specify at most one of -pc and -source"));
 425
 426   stdio_file arg_outfile;
 427
 428   if (argv != NULL && argv[outfile_idx] != NULL)
 429     {
 430       if (argv[outfile_idx + 1] != NULL)
 431         error (_("Junk at end of command"));
 432       gdb::unique_xmalloc_ptr<char> outfile_name
 433         (tilde_expand (argv[outfile_idx]));
 434       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
 435         perror_with_name (outfile_name.get ());
 436       outfile = &arg_outfile;
 437     }
 438
 439   if (address_arg != NULL)
 440     {
 441       CORE_ADDR pc = parse_and_eval_address (address_arg);
 442       struct symtab *s = find_pc_line_symtab (pc);
 443
 444       if (s == NULL)
 445         error (_("No symtab for address: %s"), address_arg);
 446       dump_symtab (s, outfile);
 447     }
 448   else
 449     {
 450       int found = 0;
 451
 452       for (objfile *objfile : current_program_space->objfiles ())
 453         {
 454           int print_for_objfile = 1;
 455
 456           if (objfile_arg != NULL)
 457             print_for_objfile
 458               = compare_filenames_for_search (objfile_name (objfile),
 459                                               objfile_arg);
 460           if (!print_for_objfile)
 461             continue;
 462
 463           for (compunit_symtab *cu : objfile->compunits ())
 464             {
 465               for (symtab *s : cu->filetabs ())
 466                 {
 467                   int print_for_source = 0;
 468
 469                   QUIT;
 470                   if (source_arg != NULL)
 471                     {
 472                       print_for_source
 473                         = compare_filenames_for_search
 474                         (symtab_to_filename_for_display (s), source_arg);
 475                       found = 1;
 476                     }
 477                   if (source_arg == NULL
 478                       || print_for_source)
 479                     dump_symtab (s, outfile);
 480                 }
 481             }
 482         }
 483
 484       if (source_arg != NULL && !found)
 485         error (_("No symtab for source file: %s"), source_arg);
 486     }
 487 }
 488
 489 /* Print symbol SYMBOL on OUTFILE.  DEPTH says how far to indent.  */
 490
 491 static void
 492 print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
 493               int depth, ui_file *outfile)
 494 {
 495   struct obj_section *section;
 496
 497   if (symbol->is_objfile_owned ())
 498     section = symbol->obj_section (symbol->objfile ());
 499   else
 500     section = NULL;
 501
 502   print_spaces (depth, outfile);
 503   if (symbol->domain () == LABEL_DOMAIN)
 504     {
 505       gdb_printf (outfile, "label %s at ", symbol->print_name ());
 506       gdb_puts (paddress (gdbarch, symbol->value_address ()),
 507                 outfile);
 508       if (section)
 509         gdb_printf (outfile, " section %s\n",
 510                     bfd_section_name (section->the_bfd_section));
 511       else
 512         gdb_printf (outfile, "\n");
 513       return;
 514     }
 515
 516   if (symbol->domain () == STRUCT_DOMAIN)
 517     {
 518       if (symbol->type ()->name ())
 519         {
 520           current_language->print_type (symbol->type (), "", outfile, 1, depth,
 521                                         &type_print_raw_options);
 522         }
 523       else
 524         {
 525           gdb_printf (outfile, "%s %s = ",
 526                       (symbol->type ()->code () == TYPE_CODE_ENUM
 527                        ? "enum"
 528                        : (symbol->type ()->code () == TYPE_CODE_STRUCT
 529                           ? "struct" : "union")),
 530                       symbol->linkage_name ());
 531           current_language->print_type (symbol->type (), "", outfile, 1, depth,
 532                                         &type_print_raw_options);
 533         }
 534       gdb_printf (outfile, ";\n");
 535     }
 536   else
 537     {
 538       if (symbol->aclass () == LOC_TYPEDEF)
 539         gdb_printf (outfile, "typedef ");
 540       if (symbol->type ())
 541         {
 542           /* Print details of types, except for enums where it's clutter.  */
 543           current_language->print_type (symbol->type (), symbol->print_name (),
 544                                         outfile,
 545                                         symbol->type ()->code () != TYPE_CODE_ENUM,
 546                                         depth,
 547                                         &type_print_raw_options);
 548           gdb_printf (outfile, "; ");
 549         }
 550       else
 551         gdb_printf (outfile, "%s ", symbol->print_name ());
 552
 553       switch (symbol->aclass ())
 554         {
 555         case LOC_CONST:
 556           gdb_printf (outfile, "const %s (%s)",
 557                       plongest (symbol->value_longest ()),
 558                       hex_string (symbol->value_longest ()));
 559           break;
 560
 561         case LOC_CONST_BYTES:
 562           {
 563             unsigned i;
 564             struct type *type = check_typedef (symbol->type ());
 565
 566             gdb_printf (outfile, "const %s hex bytes:",
 567                         pulongest (type->length ()));
 568             for (i = 0; i < type->length (); i++)
 569               gdb_printf (outfile, " %02x",
 570                           (unsigned) symbol->value_bytes ()[i]);
 571           }
 572           break;
 573
 574         case LOC_STATIC:
 575           gdb_printf (outfile, "static at ");
 576           gdb_puts (paddress (gdbarch, symbol->value_address ()), outfile);
 577           if (section)
 578             gdb_printf (outfile, " section %s",
 579                         bfd_section_name (section->the_bfd_section));
 580           break;
 581
 582         case LOC_REGISTER:
 583           if (symbol->is_argument ())
 584             gdb_printf (outfile, "parameter register %s",
 585                         plongest (symbol->value_longest ()));
 586           else
 587             gdb_printf (outfile, "register %s",
 588                         plongest (symbol->value_longest ()));
 589           break;
 590
 591         case LOC_ARG:
 592           gdb_printf (outfile, "arg at offset %s",
 593                       hex_string (symbol->value_longest ()));
 594           break;
 595
 596         case LOC_REF_ARG:
 597           gdb_printf (outfile, "reference arg at %s",
 598                       hex_string (symbol->value_longest ()));
 599           break;
 600
 601         case LOC_REGPARM_ADDR:
 602           gdb_printf (outfile, "address parameter register %s",
 603                       plongest (symbol->value_longest ()));
 604           break;
 605
 606         case LOC_LOCAL:
 607           gdb_printf (outfile, "local at offset %s",
 608                       hex_string (symbol->value_longest ()));
 609           break;
 610
 611         case LOC_TYPEDEF:
 612           break;
 613
 614         case LOC_LABEL:
 615           gdb_printf (outfile, "label at ");
 616           gdb_puts (paddress (gdbarch, symbol->value_address ()), outfile);
 617           if (section)
 618             gdb_printf (outfile, " section %s",
 619                         bfd_section_name (section->the_bfd_section));
 620           break;
 621
 622         case LOC_BLOCK:
 623           gdb_printf
 624             (outfile, "block object %s, %s..%s",
 625              host_address_to_string (symbol->value_block ()),
 626              paddress (gdbarch, symbol->value_block()->start ()),
 627              paddress (gdbarch, symbol->value_block()->end ()));
 628           if (section)
 629             gdb_printf (outfile, " section %s",
 630                         bfd_section_name (section->the_bfd_section));
 631           break;
 632
 633         case LOC_COMPUTED:
 634           gdb_printf (outfile, "computed at runtime");
 635           break;
 636
 637         case LOC_UNRESOLVED:
 638           gdb_printf (outfile, "unresolved");
 639           break;
 640
 641         case LOC_OPTIMIZED_OUT:
 642           gdb_printf (outfile, "optimized out");
 643           break;
 644
 645         default:
 646           gdb_printf (outfile, "botched symbol class %x",
 647                       symbol->aclass ());
 648           break;
 649         }
 650     }
 651   gdb_printf (outfile, "\n");
 652 }
 653
 654 static void
 655 maintenance_print_msymbols (const char *args, int from_tty)
 656 {
 657   struct ui_file *outfile = gdb_stdout;
 658   char *objfile_arg = NULL;
 659   int i, outfile_idx;
 660
 661   dont_repeat ();
 662
 663   gdb_argv argv (args);
 664
 665   for (i = 0; argv != NULL && argv[i] != NULL; ++i)
 666     {
 667       if (strcmp (argv[i], "-objfile") == 0)
 668         {
 669           if (argv[i + 1] == NULL)
 670             error (_("Missing objfile name"));
 671           objfile_arg = argv[++i];
 672         }
 673       else if (strcmp (argv[i], "--") == 0)
 674         {
 675           /* End of options.  */
 676           ++i;
 677           break;
 678         }
 679       else if (argv[i][0] == '-')
 680         {
 681           /* Future proofing: Don't allow OUTFILE to begin with "-".  */
 682           error (_("Unknown option: %s"), argv[i]);
 683         }
 684       else
 685         break;
 686     }
 687   outfile_idx = i;
 688
 689   stdio_file arg_outfile;
 690
 691   if (argv != NULL && argv[outfile_idx] != NULL)
 692     {
 693       if (argv[outfile_idx + 1] != NULL)
 694         error (_("Junk at end of command"));
 695       gdb::unique_xmalloc_ptr<char> outfile_name
 696         (tilde_expand (argv[outfile_idx]));
 697       if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
 698         perror_with_name (outfile_name.get ());
 699       outfile = &arg_outfile;
 700     }
 701
 702   for (objfile *objfile : current_program_space->objfiles ())
 703     {
 704       QUIT;
 705       if (objfile_arg == NULL
 706           || compare_filenames_for_search (objfile_name (objfile), objfile_arg))
 707         dump_msymbols (objfile, outfile);
 708     }
 709 }
 710
 711 static void
 712 maintenance_print_objfiles (const char *regexp, int from_tty)
 713 {
 714   dont_repeat ();
 715
 716   if (regexp)
 717     re_comp (regexp);
 718
 719   for (struct program_space *pspace : program_spaces)
 720     for (objfile *objfile : pspace->objfiles ())
 721       {
 722         QUIT;
 723         if (! regexp
 724             || re_exec (objfile_name (objfile)))
 725           dump_objfile (objfile);
 726       }
 727 }
 728
 729 /* List all the symbol tables whose names match REGEXP (optional).  */
 730
 731 static void
 732 maintenance_info_symtabs (const char *regexp, int from_tty)
 733 {
 734   dont_repeat ();
 735
 736   if (regexp)
 737     re_comp (regexp);
 738
 739   for (struct program_space *pspace : program_spaces)
 740     for (objfile *objfile : pspace->objfiles ())
 741       {
 742         /* We don't want to print anything for this objfile until we
 743            actually find a symtab whose name matches.  */
 744         int printed_objfile_start = 0;
 745
 746         for (compunit_symtab *cust : objfile->compunits ())
 747           {
 748             int printed_compunit_symtab_start = 0;
 749
 750             for (symtab *symtab : cust->filetabs ())
 751               {
 752                 QUIT;
 753
 754                 if (! regexp
 755                     || re_exec (symtab_to_filename_for_display (symtab)))
 756                   {
 757                     if (! printed_objfile_start)
 758                       {
 759                         gdb_printf ("{ objfile %s ", objfile_name (objfile));
 760                         gdb_stdout->wrap_here (2);
 761                         gdb_printf ("((struct objfile *) %s)\n",
 762                                     host_address_to_string (objfile));
 763                         printed_objfile_start = 1;
 764                       }
 765                     if (! printed_compunit_symtab_start)
 766                       {
 767                         gdb_printf ("  { ((struct compunit_symtab *) %s)\n",
 768                                     host_address_to_string (cust));
 769                         gdb_printf ("    debugformat %s\n",
 770                                     cust->debugformat ());
 771                         gdb_printf ("    producer %s\n",
 772                                     (cust->producer () != nullptr
 773                                      ? cust->producer () : "(null)"));
 774                         gdb_printf ("    name %s\n", cust->name);
 775                         gdb_printf ("    dirname %s\n",
 776                                     (cust->dirname () != NULL
 777                                      ? cust->dirname () : "(null)"));
 778                         gdb_printf ("    blockvector"
 779                                     " ((struct blockvector *) %s)\n",
 780                                     host_address_to_string
 781                                     (cust->blockvector ()));
 782                         gdb_printf ("    user"
 783                                     " ((struct compunit_symtab *) %s)\n",
 784                                     cust->user != nullptr
 785                                     ? host_address_to_string (cust->user)
 786                                     : "(null)");
 787                         if (cust->includes != nullptr)
 788                           {
 789                             gdb_printf ("    ( includes\n");
 790                             for (int i = 0; ; ++i)
 791                               {
 792                                 struct compunit_symtab *include
 793                                   = cust->includes[i];
 794                                 if (include == nullptr)
 795                                   break;
 796                                 const char *addr
 797                                   = host_address_to_string (include);
 798                                 gdb_printf ("      (%s %s)\n",
 799                                             "(struct compunit_symtab *)",
 800                                             addr);
 801                               }
 802                             gdb_printf ("    )\n");
 803                           }
 804                         printed_compunit_symtab_start = 1;
 805                       }
 806
 807                     gdb_printf ("\t{ symtab %s ",
 808                                 symtab_to_filename_for_display (symtab));
 809                     gdb_stdout->wrap_here (4);
 810                     gdb_printf ("((struct symtab *) %s)\n",
 811                                 host_address_to_string (symtab));
 812                     gdb_printf ("\t  fullname %s\n",
 813                                 symtab->fullname () != nullptr
 814                                 ? symtab->fullname ()
 815                                 : "(null)");
 816                     gdb_printf ("\t  "
 817                                 "linetable ((struct linetable *) %s)\n",
 818                                 host_address_to_string
 819                                 (symtab->linetable ()));
 820                     gdb_printf ("\t}\n");
 821                   }
 822               }
 823
 824             if (printed_compunit_symtab_start)
 825               gdb_printf ("  }\n");
 826           }
 827
 828         if (printed_objfile_start)
 829           gdb_printf ("}\n");
 830       }
 831 }
 832
 833 /* Check consistency of symtabs.
 834    An example of what this checks for is NULL blockvectors.
 835    They can happen if there's a bug during debug info reading.
 836    GDB assumes they are always non-NULL.
 837
 838    Note: This does not check for psymtab vs symtab consistency.
 839    Use "maint check-psymtabs" for that.  */
 840
 841 static void
 842 maintenance_check_symtabs (const char *ignore, int from_tty)
 843 {
 844   for (struct program_space *pspace : program_spaces)
 845     for (objfile *objfile : pspace->objfiles ())
 846       {
 847         /* We don't want to print anything for this objfile until we
 848            actually find something worth printing.  */
 849         int printed_objfile_start = 0;
 850
 851         for (compunit_symtab *cust : objfile->compunits ())
 852           {
 853             int found_something = 0;
 854             struct symtab *symtab = cust->primary_filetab ();
 855
 856             QUIT;
 857
 858             if (cust->blockvector () == NULL)
 859               found_something = 1;
 860             /* Add more checks here.  */
 861
 862             if (found_something)
 863               {
 864                 if (! printed_objfile_start)
 865                   {
 866                     gdb_printf ("{ objfile %s ", objfile_name (objfile));
 867                     gdb_stdout->wrap_here (2);
 868                     gdb_printf ("((struct objfile *) %s)\n",
 869                                 host_address_to_string (objfile));
 870                     printed_objfile_start = 1;
 871                   }
 872                 gdb_printf ("  { symtab %s\n",
 873                             symtab_to_filename_for_display (symtab));
 874                 if (cust->blockvector () == NULL)
 875                   gdb_printf ("    NULL blockvector\n");
 876                 gdb_printf ("  }\n");
 877               }
 878           }
 879
 880         if (printed_objfile_start)
 881           gdb_printf ("}\n");
 882       }
 883 }
 884
 885 /* Expand all symbol tables whose name matches an optional regexp.  */
 886
 887 static void
 888 maintenance_expand_symtabs (const char *args, int from_tty)
 889 {
 890   char *regexp = NULL;
 891
 892   /* We use buildargv here so that we handle spaces in the regexp
 893      in a way that allows adding more arguments later.  */
 894   gdb_argv argv (args);
 895
 896   if (argv != NULL)
 897     {
 898       if (argv[0] != NULL)
 899         {
 900           regexp = argv[0];
 901           if (argv[1] != NULL)
 902             error (_("Extra arguments after regexp."));
 903         }
 904     }
 905
 906   if (regexp)
 907     re_comp (regexp);
 908
 909   for (struct program_space *pspace : program_spaces)
 910     for (objfile *objfile : pspace->objfiles ())
 911       objfile->expand_symtabs_matching
 912         ([&] (const char *filename, bool basenames)
 913          {
 914            /* KISS: Only apply the regexp to the complete file name.  */
 915            return (!basenames
 916                    && (regexp == NULL || re_exec (filename)));
 917          },
 918          NULL,
 919          NULL,
 920          NULL,
 921          SEARCH_GLOBAL_BLOCK | SEARCH_STATIC_BLOCK,
 922          SEARCH_ALL_DOMAINS);
 923 }
 924 \f
 925
 926 /* Return the nexting depth of a block within other blocks in its symtab.  */
 927
 928 static int
 929 block_depth (const struct block *block)
 930 {
 931   int i = 0;
 932
 933   while ((block = block->superblock ()) != NULL)
 934     {
 935       i++;
 936     }
 937   return i;
 938 }
 939 \f
 940
 941 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
 942    single line table.  */
 943
 944 static int
 945 maintenance_print_one_line_table (struct symtab *symtab, void *data)
 946 {
 947   const struct linetable *linetable;
 948   struct objfile *objfile;
 949
 950   objfile = symtab->compunit ()->objfile ();
 951   gdb_printf (_("objfile: %ps ((struct objfile *) %s)\n"),
 952               styled_string (file_name_style.style (),
 953                              objfile_name (objfile)),
 954               host_address_to_string (objfile));
 955   gdb_printf (_("compunit_symtab: %s ((struct compunit_symtab *) %s)\n"),
 956               symtab->compunit ()->name,
 957               host_address_to_string (symtab->compunit ()));
 958   gdb_printf (_("symtab: %ps ((struct symtab *) %s)\n"),
 959               styled_string (file_name_style.style (),
 960                              symtab_to_fullname (symtab)),
 961               host_address_to_string (symtab));
 962   linetable = symtab->linetable ();
 963   gdb_printf (_("linetable: ((struct linetable *) %s):\n"),
 964               host_address_to_string (linetable));
 965
 966   if (linetable == NULL)
 967     gdb_printf (_("No line table.\n"));
 968   else if (linetable->nitems <= 0)
 969     gdb_printf (_("Line table has no lines.\n"));
 970   else
 971     {
 972       /* Leave space for 6 digits of index and line number.  After that the
 973          tables will just not format as well.  */
 974       struct ui_out *uiout = current_uiout;
 975       ui_out_emit_table table_emitter (uiout, 7, -1, "line-table");
 976       uiout->table_header (6, ui_left, "index", _("INDEX"));
 977       uiout->table_header (6, ui_left, "line", _("LINE"));
 978       uiout->table_header (18, ui_left, "rel-address", _("REL-ADDRESS"));
 979       uiout->table_header (18, ui_left, "unrel-address", _("UNREL-ADDRESS"));
 980       uiout->table_header (7, ui_left, "is-stmt", _("IS-STMT"));
 981       uiout->table_header (12, ui_left, "prologue-end", _("PROLOGUE-END"));
 982       uiout->table_header (14, ui_left, "epilogue-begin", _("EPILOGUE-BEGIN"));
 983       uiout->table_body ();
 984
 985       for (int i = 0; i < linetable->nitems; ++i)
 986         {
 987           const linetable_entry *item;
 988
 989           item = &linetable->item [i];
 990           ui_out_emit_tuple tuple_emitter (uiout, nullptr);
 991           uiout->field_signed ("index", i);
 992           if (item->line > 0)
 993             uiout->field_signed ("line", item->line);
 994           else
 995             uiout->field_string ("line", _("END"));
 996           uiout->field_core_addr ("rel-address", objfile->arch (),
 997                                   item->pc (objfile));
 998           uiout->field_core_addr ("unrel-address", objfile->arch (),
 999                                   CORE_ADDR (item->unrelocated_pc ()));
1000           uiout->field_string ("is-stmt", item->is_stmt ? "Y" : "");
1001           uiout->field_string ("prologue-end", item->prologue_end ? "Y" : "");
1002           uiout->field_string ("epilogue-begin", item->epilogue_begin ? "Y" : "");
1003           uiout->text ("\n");
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   dont_repeat ();
1016
1017   if (regexp != NULL)
1018     re_comp (regexp);
1019
1020   for (struct program_space *pspace : program_spaces)
1021     for (objfile *objfile : pspace->objfiles ())
1022       {
1023         for (compunit_symtab *cust : objfile->compunits ())
1024           {
1025             for (symtab *symtab : cust->filetabs ())
1026               {
1027                 QUIT;
1028
1029                 if (regexp == NULL
1030                     || re_exec (symtab_to_filename_for_display (symtab)))
1031                   {
1032                     maintenance_print_one_line_table (symtab, NULL);
1033                     gdb_printf ("\n");
1034                   }
1035               }
1036           }
1037       }
1038 }
1039
1040 \f
1041
1042 /* Do early runtime initializations.  */
1043
1044 void _initialize_symmisc ();
1045 void
1046 _initialize_symmisc ()
1047 {
1048   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1049 Print dump of current symbol definitions.\n\
1050 Usage: mt print symbols [-pc ADDRESS] [--] [OUTFILE]\n\
1051        mt print symbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1052 Entries in the full symbol table are dumped to file OUTFILE,\n\
1053 or the terminal if OUTFILE is unspecified.\n\
1054 If ADDRESS is provided, dump only the symbols for the file with code at that address.\n\
1055 If SOURCE is provided, dump only that file's symbols.\n\
1056 If OBJFILE is provided, dump only that object file's symbols."),
1057            &maintenanceprintlist);
1058
1059   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1060 Print dump of current minimal symbol definitions.\n\
1061 Usage: mt print msymbols [-objfile OBJFILE] [--] [OUTFILE]\n\
1062 Entries in the minimal symbol table are dumped to file OUTFILE,\n\
1063 or the terminal if OUTFILE is unspecified.\n\
1064 If OBJFILE is provided, dump only that file's minimal symbols."),
1065            &maintenanceprintlist);
1066
1067   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1068            _("Print dump of current object file definitions.\n\
1069 With an argument REGEXP, list the object files with matching names."),
1070            &maintenanceprintlist);
1071
1072   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1073 List the full symbol tables for all object files.\n\
1074 This does not include information about individual symbols, blocks, or\n\
1075 linetables --- just the symbol table structures themselves.\n\
1076 With an argument REGEXP, list the symbol tables with matching names."),
1077            &maintenanceinfolist);
1078
1079   add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1080 List the contents of all line tables, from all symbol tables.\n\
1081 With an argument REGEXP, list just the line tables for the symbol\n\
1082 tables with matching names."),
1083            &maintenanceinfolist);
1084
1085   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1086            _("\
1087 Check consistency of currently expanded symtabs."),
1088            &maintenancelist);
1089
1090   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1091            _("Expand symbol tables.\n\
1092 With an argument REGEXP, only expand the symbol tables with matching names."),
1093            &maintenancelist);
1094 }