gdb/symmisc.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Do various things to symbol tables (other than lookup), for GDB.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  41. #include "psymtab.h"

  43. #ifndef DEV_TTY
  44. ‌#define DEV_TTY "/dev/tty"
  45. #endif

  47. /* Unfortunately for debugging, stderr is usually a macro.  This is painful
  48.    when calling functions that take FILE *'s from the debugger.
  49.    So we make a variable which has the same value and which is accessible when
  50.    debugging GDB with itself.  Because stdin et al need not be constants,
  51.    we initialize them in the _initialize_symmisc function at the bottom
  52.    of the file.  */
  53. ‌FILE *std_in;
  54. ‌FILE *std_out;
  55. ‌FILE *std_err;

  57. /* Prototypes for local functions */

  59. static int block_depth (struct block *);

  61. void _initialize_symmisc (void);

  63. ‌struct print_symbol_args
  64.   {
  65.     struct gdbarch *gdbarch;
  66.     struct symbol *symbol;
  67.     int depth;
  68.     struct ui_file *outfile;
  69.   };

  71. static int print_symbol (void *);


  74. void
  75. ‌print_symbol_bcache_statistics (void)
  76. {
  77.   struct program_space *pspace;
  78.   struct objfile *objfile;

  80.   ALL_PSPACES (pspace)
  81.     ALL_PSPACE_OBJFILES (pspace, objfile)
  82.   {
  83.     QUIT;
  84.     printf_filtered (_("Byte cache statistics for '%s':\n"),
  85.                      objfile_name (objfile));
  86.     print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
  87.                              "partial symbol cache");
  88.     print_bcache_statistics (objfile->per_bfd->macro_cache,
  89.                              "preprocessor macro cache");
  90.     print_bcache_statistics (objfile->per_bfd->filename_cache,
  91.                              "file name cache");
  92.   }
  93. }

  95. void
  96. ‌print_objfile_statistics (void)
  97. {
  98.   struct program_space *pspace;
  99.   struct objfile *objfile;
  100.   struct compunit_symtab *cu;
  101.   struct symtab *s;
  102.   int i, linetables, blockvectors;

  104.   ALL_PSPACES (pspace)
  105.     ALL_PSPACE_OBJFILES (pspace, objfile)
  106.   {
  107.     QUIT;
  108.     printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile));
  109.     if (OBJSTAT (objfile, n_stabs) > 0)
  110.       printf_filtered (_("  Number of \"stab\" symbols read: %d\n"),
  111.                        OBJSTAT (objfile, n_stabs));
  112.     if (objfile->per_bfd->n_minsyms > 0)
  113.       printf_filtered (_("  Number of \"minimal\" symbols read: %d\n"),
  114.                        objfile->per_bfd->n_minsyms);
  115.     if (OBJSTAT (objfile, n_psyms) > 0)
  116.       printf_filtered (_("  Number of \"partial\" symbols read: %d\n"),
  117.                        OBJSTAT (objfile, n_psyms));
  118.     if (OBJSTAT (objfile, n_syms) > 0)
  119.       printf_filtered (_("  Number of \"full\" symbols read: %d\n"),
  120.                        OBJSTAT (objfile, n_syms));
  121.     if (OBJSTAT (objfile, n_types) > 0)
  122.       printf_filtered (_("  Number of \"types\" defined: %d\n"),
  123.                        OBJSTAT (objfile, n_types));
  124.     if (objfile->sf)
  125.       objfile->sf->qf->print_stats (objfile);
  126.     i = linetables = blockvectors = 0;
  127.     ALL_OBJFILE_FILETABS (objfile, cu, s)
  128.       {
  129.         i++;
  130.         if (SYMTAB_LINETABLE (s) != NULL)
  131.           linetables++;
  132.       }
  133.     ALL_OBJFILE_COMPUNITS (objfile, cu)
  134.       blockvectors++;
  135.     printf_filtered (_("  Number of symbol tables: %d\n"), i);
  136.     printf_filtered (_("  Number of symbol tables with line tables: %d\n"),
  137.                      linetables);
  138.     printf_filtered (_("  Number of symbol tables with blockvectors: %d\n"),
  139.                      blockvectors);

  141.     if (OBJSTAT (objfile, sz_strtab) > 0)
  142.       printf_filtered (_("  Space used by a.out string tables: %d\n"),
  143.                        OBJSTAT (objfile, sz_strtab));
  144.     printf_filtered (_("  Total memory used for objfile obstack: %s\n"),
  145.                      pulongest (obstack_memory_used (&objfile
  146.                                                      ->objfile_obstack)));
  147.     printf_filtered (_("  Total memory used for BFD obstack: %s\n"),
  148.                      pulongest (obstack_memory_used (&objfile->per_bfd
  149.                                                      ->storage_obstack)));
  150.     printf_filtered (_("  Total memory used for psymbol cache: %d\n"),
  151.                      bcache_memory_used (psymbol_bcache_get_bcache
  152.                                           (objfile->psymbol_cache)));
  153.     printf_filtered (_("  Total memory used for macro cache: %d\n"),
  154.                      bcache_memory_used (objfile->per_bfd->macro_cache));
  155.     printf_filtered (_("  Total memory used for file name cache: %d\n"),
  156.                      bcache_memory_used (objfile->per_bfd->filename_cache));
  157.   }
  158. }

  160. static void
  161. ‌dump_objfile (struct objfile *objfile)
  162. {
  163.   struct compunit_symtab *cust;
  164.   struct symtab *symtab;

  166.   printf_filtered ("\nObject file %s:  ", objfile_name (objfile));
  167.   printf_filtered ("Objfile at ");
  168.   gdb_print_host_address (objfile, gdb_stdout);
  169.   printf_filtered (", bfd at ");
  170.   gdb_print_host_address (objfile->obfd, gdb_stdout);
  171.   printf_filtered (", %d minsyms\n\n",
  172.                    objfile->per_bfd->minimal_symbol_count);

  174.   if (objfile->sf)
  175.     objfile->sf->qf->dump (objfile);

  177.   if (objfile->compunit_symtabs != NULL)
  178.     {
  179.       printf_filtered ("Symtabs:\n");
  180.       ALL_OBJFILE_FILETABS (objfile, cust, symtab)
  181.         {
  182.           printf_filtered ("%s at ", symtab_to_filename_for_display (symtab));
  183.           gdb_print_host_address (symtab, gdb_stdout);
  184.           printf_filtered (", ");
  185.           if (SYMTAB_OBJFILE (symtab) != objfile)
  186.             {
  187.               printf_filtered ("NOT ON CHAIN!  ");
  188.             }
  189.           wrap_here ("  ");
  190.         }
  191.       printf_filtered ("\n\n");
  192.     }
  193. }

  195. /* Print minimal symbols from this objfile.  */

  197. static void
  198. ‌dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
  199. {
  200.   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  201.   struct minimal_symbol *msymbol;
  202.   int index;
  203.   char ms_type;

  205.   fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
  206.   if (objfile->per_bfd->minimal_symbol_count == 0)
  207.     {
  208.       fprintf_filtered (outfile, "No minimal symbols found.\n");
  209.       return;
  210.     }
  211.   index = 0;
  212.   ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
  213.     {
  214.       struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);

  216.       switch (MSYMBOL_TYPE (msymbol))
  217.         {
  218.         case mst_unknown:
  219.           ms_type = 'u';
  220.           break;
  221.         case mst_text:
  222.           ms_type = 'T';
  223.           break;
  224.         case mst_text_gnu_ifunc:
  225.           ms_type = 'i';
  226.           break;
  227.         case mst_solib_trampoline:
  228.           ms_type = 'S';
  229.           break;
  230.         case mst_data:
  231.           ms_type = 'D';
  232.           break;
  233.         case mst_bss:
  234.           ms_type = 'B';
  235.           break;
  236.         case mst_abs:
  237.           ms_type = 'A';
  238.           break;
  239.         case mst_file_text:
  240.           ms_type = 't';
  241.           break;
  242.         case mst_file_data:
  243.           ms_type = 'd';
  244.           break;
  245.         case mst_file_bss:
  246.           ms_type = 'b';
  247.           break;
  248.         default:
  249.           ms_type = '?';
  250.           break;
  251.         }
  252.       fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
  253.       fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
  254.                                                                 msymbol)),
  255.                       outfile);
  256.       fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
  257.       if (section)
  258.         {
  259.           if (section->the_bfd_section != NULL)
  260.             fprintf_filtered (outfile, " section %s",
  261.                               bfd_section_name (objfile->obfd,
  262.                                                 section->the_bfd_section));
  263.           else
  264.             fprintf_filtered (outfile, " spurious section %ld",
  265.                               (long) (section - objfile->sections));
  266.         }
  267.       if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
  268.         {
  269.           fprintf_filtered (outfile, "  %s", MSYMBOL_DEMANGLED_NAME (msymbol));
  270.         }
  271.       if (msymbol->filename)
  272.         fprintf_filtered (outfile, "  %s", msymbol->filename);
  273.       fputs_filtered ("\n", outfile);
  274.       index++;
  275.     }
  276.   if (objfile->per_bfd->minimal_symbol_count != index)
  277.     {
  278.       warning (_("internal error:  minimal symbol count %d != %d"),
  279.                objfile->per_bfd->minimal_symbol_count, index);
  280.     }
  281.   fprintf_filtered (outfile, "\n");
  282. }

  284. static void
  285. ‌dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
  286.                struct ui_file *outfile)
  287. {
  288.   struct gdbarch *gdbarch = get_objfile_arch (objfile);
  289.   int i;
  290.   struct dict_iterator iter;
  291.   int len;
  292.   struct linetable *l;
  293.   const struct blockvector *bv;
  294.   struct symbol *sym;
  295.   struct block *b;
  296.   int depth;

  298.   fprintf_filtered (outfile, "\nSymtab for file %s\n",
  299.                     symtab_to_filename_for_display (symtab));
  300.   if (SYMTAB_DIRNAME (symtab) != NULL)
  301.     fprintf_filtered (outfile, "Compilation directory is %s\n",
  302.                       SYMTAB_DIRNAME (symtab));
  303.   fprintf_filtered (outfile, "Read from object file %s (",
  304.                     objfile_name (objfile));
  305.   gdb_print_host_address (objfile, outfile);
  306.   fprintf_filtered (outfile, ")\n");
  307.   fprintf_filtered (outfile, "Language: %s\n",
  308.                     language_str (symtab->language));

  310.   /* First print the line table.  */
  311.   l = SYMTAB_LINETABLE (symtab);
  312.   if (l)
  313.     {
  314.       fprintf_filtered (outfile, "\nLine table:\n\n");
  315.       len = l->nitems;
  316.       for (i = 0; i < len; i++)
  317.         {
  318.           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
  319.           fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
  320.           fprintf_filtered (outfile, "\n");
  321.         }
  322.     }
  323.   /* Now print the block info, but only for compunit symtabs since we will
  324.      print lots of duplicate info otherwise.  */
  325.   if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)))
  326.     {
  327.       fprintf_filtered (outfile, "\nBlockvector:\n\n");
  328.       bv = SYMTAB_BLOCKVECTOR (symtab);
  329.       len = BLOCKVECTOR_NBLOCKS (bv);
  330.       for (i = 0; i < len; i++)
  331.         {
  332.           b = BLOCKVECTOR_BLOCK (bv, i);
  333.           depth = block_depth (b) * 2;
  334.           print_spaces (depth, outfile);
  335.           fprintf_filtered (outfile, "block #%03d, object at ", i);
  336.           gdb_print_host_address (b, outfile);
  337.           if (BLOCK_SUPERBLOCK (b))
  338.             {
  339.               fprintf_filtered (outfile, " under ");
  340.               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
  341.             }
  342.           /* drow/2002-07-10: We could save the total symbols count
  343.              even if we're using a hashtable, but nothing else but this message
  344.              wants it.  */
  345.           fprintf_filtered (outfile, ", %d syms/buckets in ",
  346.                             dict_size (BLOCK_DICT (b)));
  347.           fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
  348.           fprintf_filtered (outfile, "..");
  349.           fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
  350.           if (BLOCK_FUNCTION (b))
  351.             {
  352.               fprintf_filtered (outfile, ", function %s",
  353.                                 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
  354.               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
  355.                 {
  356.                   fprintf_filtered (outfile, ", %s",
  357.                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
  358.                 }
  359.             }
  360.           fprintf_filtered (outfile, "\n");
  361.           /* Now print each symbol in this block (in no particular order, if
  362.              we're using a hashtable).  Note that we only want this
  363.              block, not any blocks from included symtabs.  */
  364.           ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
  365.             {
  366.               struct print_symbol_args s;

  368.               s.gdbarch = gdbarch;
  369.               s.symbol = sym;
  370.               s.depth = depth + 1;
  371.               s.outfile = outfile;
  372.               catch_errors (print_symbol, &s, "Error printing symbol:\n",
  373.                             RETURN_MASK_ERROR);
  374.             }
  375.         }
  376.       fprintf_filtered (outfile, "\n");
  377.     }
  378.   else
  379.     {
  380.       fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
  381.     }
  382. }

  384. static void
  385. ‌dump_symtab (struct objfile *objfile, struct symtab *symtab,
  386.              struct ui_file *outfile)
  387. {
  388.   /* Set the current language to the language of the symtab we're dumping
  389.      because certain routines used during dump_symtab() use the current
  390.      language to print an image of the symbol.  We'll restore it later.
  391.      But use only real languages, not placeholders.  */
  392.   if (symtab->language != language_unknown
  393.       && symtab->language != language_auto)
  394.     {
  395.       enum language saved_lang;

  397.       saved_lang = set_language (symtab->language);

  399.       dump_symtab_1 (objfile, symtab, outfile);

  401.       set_language (saved_lang);
  402.     }
  403.   else
  404.     dump_symtab_1 (objfile, symtab, outfile);
  405. }

  407. static void
  408. ‌maintenance_print_symbols (char *args, int from_tty)
  409. {
  410.   char **argv;
  411.   struct ui_file *outfile;
  412.   struct cleanup *cleanups;
  413.   char *symname = NULL;
  414.   char *filename = DEV_TTY;
  415.   struct objfile *objfile;
  416.   struct compunit_symtab *cu;
  417.   struct symtab *s;

  419.   dont_repeat ();

  421.   if (args == NULL)
  422.     {
  423.       error (_("Arguments missing: an output file name "
  424.                "and an optional symbol file name"));
  425.     }
  426.   argv = gdb_buildargv (args);
  427.   cleanups = make_cleanup_freeargv (argv);

  429.   if (argv[0] != NULL)
  430.     {
  431.       filename = argv[0];
  432.       /* If a second arg is supplied, it is a source file name to match on.  */
  433.       if (argv[1] != NULL)
  434.         {
  435.           symname = argv[1];
  436.         }
  437.     }

  439.   filename = tilde_expand (filename);
  440.   make_cleanup (xfree, filename);

  442.   outfile = gdb_fopen (filename, FOPEN_WT);
  443.   if (outfile == 0)
  444.     perror_with_name (filename);
  445.   make_cleanup_ui_file_delete (outfile);

  447.   ALL_FILETABS (objfile, cu, s)
  448.     {
  449.       QUIT;
  450.       if (symname == NULL
  451.           || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0)
  452.         dump_symtab (objfile, s, outfile);
  453.     }
  454.   do_cleanups (cleanups);
  455. }

  457. /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
  458.    far to indent.  ARGS is really a struct print_symbol_args *, but is
  459.    declared as char * to get it past catch_errors.  Returns 0 for error,
  460.    1 for success.  */

  462. static int
  463. ‌print_symbol (void *args)
  464. {
  465.   struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
  466.   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
  467.   int depth = ((struct print_symbol_args *) args)->depth;
  468.   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
  469.   struct obj_section *section;

  471.   if (SYMBOL_OBJFILE_OWNED (symbol))
  472.     section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
  473.   else
  474.     section = NULL;

  476.   print_spaces (depth, outfile);
  477.   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
  478.     {
  479.       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
  480.       fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
  481.                       outfile);
  482.       if (section)
  483.         fprintf_filtered (outfile, " section %s\n",
  484.                           bfd_section_name (section->the_bfd_section->owner,
  485.                                             section->the_bfd_section));
  486.       else
  487.         fprintf_filtered (outfile, "\n");
  488.       return 1;
  489.     }
  490.   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
  491.     {
  492.       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
  493.         {
  494.           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
  495.                          &type_print_raw_options);
  496.         }
  497.       else
  498.         {
  499.           fprintf_filtered (outfile, "%s %s = ",
  500.                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
  501.                           ? "enum"
  502.                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
  503.                         ? "struct" : "union")),
  504.                             SYMBOL_LINKAGE_NAME (symbol));
  505.           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
  506.                          &type_print_raw_options);
  507.         }
  508.       fprintf_filtered (outfile, ";\n");
  509.     }
  510.   else
  511.     {
  512.       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
  513.         fprintf_filtered (outfile, "typedef ");
  514.       if (SYMBOL_TYPE (symbol))
  515.         {
  516.           /* Print details of types, except for enums where it's clutter.  */
  517.           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
  518.                          outfile,
  519.                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
  520.                          depth,
  521.                          &type_print_raw_options);
  522.           fprintf_filtered (outfile, "; ");
  523.         }
  524.       else
  525.         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));

  527.       switch (SYMBOL_CLASS (symbol))
  528.         {
  529.         case LOC_CONST:
  530.           fprintf_filtered (outfile, "const %s (%s)",
  531.                             plongest (SYMBOL_VALUE (symbol)),
  532.                             hex_string (SYMBOL_VALUE (symbol)));
  533.           break;

  535.         case LOC_CONST_BYTES:
  536.           {
  537.             unsigned i;
  538.             struct type *type = check_typedef (SYMBOL_TYPE (symbol));

  540.             fprintf_filtered (outfile, "const %u hex bytes:",
  541.                               TYPE_LENGTH (type));
  542.             for (i = 0; i < TYPE_LENGTH (type); i++)
  543.               fprintf_filtered (outfile, " %02x",
  544.                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
  545.           }
  546.           break;

  548.         case LOC_STATIC:
  549.           fprintf_filtered (outfile, "static at ");
  550.           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
  551.                           outfile);
  552.           if (section)
  553.             fprintf_filtered (outfile, " section %s",
  554.                               bfd_section_name (section->the_bfd_section->owner,
  555.                                                 section->the_bfd_section));
  556.           break;

  558.         case LOC_REGISTER:
  559.           if (SYMBOL_IS_ARGUMENT (symbol))
  560.             fprintf_filtered (outfile, "parameter register %s",
  561.                               plongest (SYMBOL_VALUE (symbol)));
  562.           else
  563.             fprintf_filtered (outfile, "register %s",
  564.                               plongest (SYMBOL_VALUE (symbol)));
  565.           break;

  567.         case LOC_ARG:
  568.           fprintf_filtered (outfile, "arg at offset %s",
  569.                             hex_string (SYMBOL_VALUE (symbol)));
  570.           break;

  572.         case LOC_REF_ARG:
  573.           fprintf_filtered (outfile, "reference arg at %s",
  574.                             hex_string (SYMBOL_VALUE (symbol)));
  575.           break;

  577.         case LOC_REGPARM_ADDR:
  578.           fprintf_filtered (outfile, "address parameter register %s",
  579.                             plongest (SYMBOL_VALUE (symbol)));
  580.           break;

  582.         case LOC_LOCAL:
  583.           fprintf_filtered (outfile, "local at offset %s",
  584.                             hex_string (SYMBOL_VALUE (symbol)));
  585.           break;

  587.         case LOC_TYPEDEF:
  588.           break;

  590.         case LOC_LABEL:
  591.           fprintf_filtered (outfile, "label at ");
  592.           fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
  593.                           outfile);
  594.           if (section)
  595.             fprintf_filtered (outfile, " section %s",
  596.                               bfd_section_name (section->the_bfd_section->owner,
  597.                                                 section->the_bfd_section));
  598.           break;

  600.         case LOC_BLOCK:
  601.           fprintf_filtered (outfile, "block object ");
  602.           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
  603.           fprintf_filtered (outfile, ", ");
  604.           fputs_filtered (paddress (gdbarch,
  605.                                     BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
  606.                           outfile);
  607.           fprintf_filtered (outfile, "..");
  608.           fputs_filtered (paddress (gdbarch,
  609.                                     BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
  610.                           outfile);
  611.           if (section)
  612.             fprintf_filtered (outfile, " section %s",
  613.                               bfd_section_name (section->the_bfd_section->owner,
  614.                                                 section->the_bfd_section));
  615.           break;

  617.         case LOC_COMPUTED:
  618.           fprintf_filtered (outfile, "computed at runtime");
  619.           break;

  621.         case LOC_UNRESOLVED:
  622.           fprintf_filtered (outfile, "unresolved");
  623.           break;

  625.         case LOC_OPTIMIZED_OUT:
  626.           fprintf_filtered (outfile, "optimized out");
  627.           break;

  629.         default:
  630.           fprintf_filtered (outfile, "botched symbol class %x",
  631.                             SYMBOL_CLASS (symbol));
  632.           break;
  633.         }
  634.     }
  635.   fprintf_filtered (outfile, "\n");
  636.   return 1;
  637. }

  639. static void
  640. ‌maintenance_print_msymbols (char *args, int from_tty)
  641. {
  642.   char **argv;
  643.   struct ui_file *outfile;
  644.   struct cleanup *cleanups;
  645.   char *filename = DEV_TTY;
  646.   char *symname = NULL;
  647.   struct program_space *pspace;
  648.   struct objfile *objfile;

  650.   struct stat sym_st, obj_st;

  652.   dont_repeat ();

  654.   if (args == NULL)
  655.     {
  656.       error (_("print-msymbols takes an output file "
  657.                "name and optional symbol file name"));
  658.     }
  659.   argv = gdb_buildargv (args);
  660.   cleanups = make_cleanup_freeargv (argv);

  662.   if (argv[0] != NULL)
  663.     {
  664.       filename = argv[0];
  665.       /* If a second arg is supplied, it is a source file name to match on.  */
  666.       if (argv[1] != NULL)
  667.         {
  668.           symname = gdb_realpath (argv[1]);
  669.           make_cleanup (xfree, symname);
  670.           if (symname && stat (symname, &sym_st))
  671.             perror_with_name (symname);
  672.         }
  673.     }

  675.   filename = tilde_expand (filename);
  676.   make_cleanup (xfree, filename);

  678.   outfile = gdb_fopen (filename, FOPEN_WT);
  679.   if (outfile == 0)
  680.     perror_with_name (filename);
  681.   make_cleanup_ui_file_delete (outfile);

  683.   ALL_PSPACES (pspace)
  684.     ALL_PSPACE_OBJFILES (pspace, objfile)
  685.       {
  686.         QUIT;
  687.         if (symname == NULL || (!stat (objfile_name (objfile), &obj_st)
  688.                                 && sym_st.st_dev == obj_st.st_dev
  689.                                 && sym_st.st_ino == obj_st.st_ino))
  690.           dump_msymbols (objfile, outfile);
  691.       }
  692.   fprintf_filtered (outfile, "\n\n");
  693.   do_cleanups (cleanups);
  694. }

  696. static void
  697. ‌maintenance_print_objfiles (char *regexp, int from_tty)
  698. {
  699.   struct program_space *pspace;
  700.   struct objfile *objfile;

  702.   dont_repeat ();

  704.   if (regexp)
  705.     re_comp (regexp);

  707.   ALL_PSPACES (pspace)
  708.     ALL_PSPACE_OBJFILES (pspace, objfile)
  709.       {
  710.         QUIT;
  711.         if (! regexp
  712.             || re_exec (objfile_name (objfile)))
  713.           dump_objfile (objfile);
  714.       }
  715. }

  717. /* List all the symbol tables whose names match REGEXP (optional).  */

  719. static void
  720. ‌maintenance_info_symtabs (char *regexp, int from_tty)
  721. {
  722.   struct program_space *pspace;
  723.   struct objfile *objfile;

  725.   dont_repeat ();

  727.   if (regexp)
  728.     re_comp (regexp);

  730.   ALL_PSPACES (pspace)
  731.     ALL_PSPACE_OBJFILES (pspace, objfile)
  732.     {
  733.       struct compunit_symtab *cust;
  734.       struct symtab *symtab;

  736.       /* We don't want to print anything for this objfile until we
  737.          actually find a symtab whose name matches.  */
  738.       int printed_objfile_start = 0;

  740.       ALL_OBJFILE_COMPUNITS (objfile, cust)
  741.         {
  742.           int printed_compunit_symtab_start = 0;

  744.           ALL_COMPUNIT_FILETABS (cust, symtab)
  745.             {
  746.               QUIT;

  748.               if (! regexp
  749.                   || re_exec (symtab_to_filename_for_display (symtab)))
  750.                 {
  751.                   if (! printed_objfile_start)
  752.                     {
  753.                       printf_filtered ("{ objfile %s ", objfile_name (objfile));
  754.                       wrap_here ("  ");
  755.                       printf_filtered ("((struct objfile *) %s)\n",
  756.                                        host_address_to_string (objfile));
  757.                       printed_objfile_start = 1;
  758.                     }
  759.                   if (! printed_compunit_symtab_start)
  760.                     {
  761.                       printf_filtered ("  { ((struct compunit_symtab *) %s)\n",
  762.                                        host_address_to_string (cust));
  763.                       printf_filtered ("    debugformat %s\n",
  764.                                        COMPUNIT_DEBUGFORMAT (cust));
  765.                       printf_filtered ("    producer %s\n",
  766.                                        COMPUNIT_PRODUCER (cust) != NULL
  767.                                        ? COMPUNIT_PRODUCER (cust)
  768.                                        : "(null)");
  769.                       printf_filtered ("    dirname %s\n",
  770.                                        COMPUNIT_DIRNAME (cust) != NULL
  771.                                        ? COMPUNIT_DIRNAME (cust)
  772.                                        : "(null)");
  773.                       printf_filtered ("    blockvector"
  774.                                        " ((struct blockvector *) %s)\n",
  775.                                        host_address_to_string
  776.                                          (COMPUNIT_BLOCKVECTOR (cust)));
  777.                       printed_compunit_symtab_start = 1;
  778.                     }

  780.                   printf_filtered ("\t{ symtab %s ",
  781.                                    symtab_to_filename_for_display (symtab));
  782.                   wrap_here ("    ");
  783.                   printf_filtered ("((struct symtab *) %s)\n",
  784.                                    host_address_to_string (symtab));
  785.                   printf_filtered ("\t  fullname %s\n",
  786.                                    symtab->fullname != NULL
  787.                                    ? symtab->fullname
  788.                                    : "(null)");
  789.                   printf_filtered ("\t  "
  790.                                    "linetable ((struct linetable *) %s)\n",
  791.                                    host_address_to_string (symtab->linetable));
  792.                   printf_filtered ("\t}\n");
  793.                 }
  794.             }

  796.           if (printed_compunit_symtab_start)
  797.             printf_filtered ("  }\n");
  798.         }

  800.       if (printed_objfile_start)
  801.         printf_filtered ("}\n");
  802.     }
  803. }

  805. /* Check consistency of symtabs.
  806.    An example of what this checks for is NULL blockvectors.
  807.    They can happen if there's a bug during debug info reading.
  808.    GDB assumes they are always non-NULL.

  810.    Note: This does not check for psymtab vs symtab consistency.
  811.    Use "maint check-psymtabs" for that.  */

  813. static void
  814. ‌maintenance_check_symtabs (char *ignore, int from_tty)
  815. {
  816.   struct program_space *pspace;
  817.   struct objfile *objfile;

  819.   ALL_PSPACES (pspace)
  820.     ALL_PSPACE_OBJFILES (pspace, objfile)
  821.     {
  822.       struct compunit_symtab *cust;

  824.       /* We don't want to print anything for this objfile until we
  825.          actually find something worth printing.  */
  826.       int printed_objfile_start = 0;

  828.       ALL_OBJFILE_COMPUNITS (objfile, cust)
  829.         {
  830.           int found_something = 0;
  831.           struct symtab *symtab = compunit_primary_filetab (cust);

  833.           QUIT;

  835.           if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
  836.             found_something = 1;
  837.           /* Add more checks here.  */

  839.           if (found_something)
  840.             {
  841.               if (! printed_objfile_start)
  842.                 {
  843.                   printf_filtered ("{ objfile %s ", objfile_name (objfile));
  844.                   wrap_here ("  ");
  845.                   printf_filtered ("((struct objfile *) %s)\n",
  846.                                    host_address_to_string (objfile));
  847.                   printed_objfile_start = 1;
  848.                 }
  849.               printf_filtered ("  { symtab %s\n",
  850.                                symtab_to_filename_for_display (symtab));
  851.               if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
  852.                 printf_filtered ("    NULL blockvector\n");
  853.               printf_filtered ("  }\n");
  854.             }
  855.         }

  857.       if (printed_objfile_start)
  858.         printf_filtered ("}\n");
  859.     }
  860. }

  862. /* Helper function for maintenance_expand_symtabs.
  863.    This is the name_matcher function for expand_symtabs_matching.  */

  865. static int
  866. ‌maintenance_expand_name_matcher (const char *symname, void *data)
  867. {
  868.   /* Since we're not searching on symbols, just return TRUE.  */
  869.   return 1;
  870. }

  872. /* Helper function for maintenance_expand_symtabs.
  873.    This is the file_matcher function for expand_symtabs_matching.  */

  875. static int
  876. ‌maintenance_expand_file_matcher (const char *filename, void *data,
  877.                                  int basenames)
  878. {
  879.   const char *regexp = data;

  881.   QUIT;

  883.   /* KISS: Only apply the regexp to the complete file name.  */
  884.   if (basenames)
  885.     return 0;

  887.   if (regexp == NULL || re_exec (filename))
  888.     return 1;

  890.   return 0;
  891. }

  893. /* Expand all symbol tables whose name matches an optional regexp.  */

  895. static void
  896. ‌maintenance_expand_symtabs (char *args, int from_tty)
  897. {
  898.   struct program_space *pspace;
  899.   struct objfile *objfile;
  900.   struct cleanup *cleanups;
  901.   char **argv;
  902.   char *regexp = NULL;

  904.   /* We use buildargv here so that we handle spaces in the regexp
  905.      in a way that allows adding more arguments later.  */
  906.   argv = gdb_buildargv (args);
  907.   cleanups = make_cleanup_freeargv (argv);

  909.   if (argv != NULL)
  910.     {
  911.       if (argv[0] != NULL)
  912.         {
  913.           regexp = argv[0];
  914.           if (argv[1] != NULL)
  915.             error (_("Extra arguments after regexp."));
  916.         }
  917.     }

  919.   if (regexp)
  920.     re_comp (regexp);

  922.   ALL_PSPACES (pspace)
  923.     ALL_PSPACE_OBJFILES (pspace, objfile)
  924.     {
  925.       if (objfile->sf)
  926.         {
  927.           objfile->sf->qf->expand_symtabs_matching
  928.             (objfile, maintenance_expand_file_matcher,
  929.              maintenance_expand_name_matcher, ALL_DOMAIN, regexp);
  930.         }
  931.     }

  933.   do_cleanups (cleanups);
  934. }


  937. /* Return the nexting depth of a block within other blocks in its symtab.  */

  939. static int
  940. ‌block_depth (struct block *block)
  941. {
  942.   int i = 0;

  944.   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
  945.     {
  946.       i++;
  947.     }
  948.   return i;
  949. }


  952. /* Do early runtime initializations.  */

  954. void
  955. ‌_initialize_symmisc (void)
  956. {
  957.   std_in = stdin;
  958.   std_out = stdout;
  959.   std_err = stderr;

  961.   add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
  962. Print dump of current symbol definitions.\n\
  963. Entries in the full symbol table are dumped to file OUTFILE.\n\
  964. If a SOURCE file is specified, dump only that file's symbols."),
  965.            &maintenanceprintlist);

  967.   add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
  968. Print dump of current minimal symbol definitions.\n\
  969. Entries in the minimal symbol table are dumped to file OUTFILE.\n\
  970. If a SOURCE file is specified, dump only that file's minimal symbols."),
  971.            &maintenanceprintlist);

  973.   add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
  974.            _("Print dump of current object file definitions.\n\
  975. With an argument REGEXP, list the object files with matching names."),
  976.            &maintenanceprintlist);

  978.   add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
  979. List the full symbol tables for all object files.\n\
  980. This does not include information about individual symbols, blocks, or\n\
  981. linetables --- just the symbol table structures themselves.\n\
  982. With an argument REGEXP, list the symbol tables with matching names."),
  983.            &maintenanceinfolist);

  985.   add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
  986.            _("\
  987. Check consistency of currently expanded symtabs."),
  988.            &maintenancelist);

  990.   add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
  991.            _("Expand symbol tables.\n\
  992. With an argument REGEXP, only expand the symbol tables with matching names."),
  993.            &maintenancelist);
  994. }