gdb/symmisc.c

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