gdb/symmisc.c

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