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