GDB (xrefs)
/tmp/gdb-7.10/gdb/symmisc.c
Go to the documentation of this file.
1 /* Do various things to symbol tables (other than lookup), for GDB.
2 
3  Copyright (C) 1986-2015 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 #ifndef DEV_TTY
44 #define DEV_TTY "/dev/tty"
45 #endif
46 
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;
56 
57 /* Prototypes for local functions */
58 
59 static int block_depth (struct block *);
60 
61 void _initialize_symmisc (void);
62 
64  {
65  struct gdbarch *gdbarch;
66  struct symbol *symbol;
67  int depth;
68  struct ui_file *outfile;
69  };
70 
71 static int print_symbol (void *);
72 
73 
74 void
76 {
77  struct program_space *pspace;
78  struct objfile *objfile;
79 
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));
87  "partial symbol cache");
89  "preprocessor macro cache");
91  "file name cache");
92  }
93 }
94 
95 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;
103 
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);
140 
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"),
152  (objfile->psymbol_cache)));
153  printf_filtered (_(" Total memory used for macro cache: %d\n"),
155  printf_filtered (_(" Total memory used for file name cache: %d\n"),
157  }
158 }
159 
160 static void
162 {
163  struct compunit_symtab *cust;
164  struct symtab *symtab;
165 
166  printf_filtered ("\nObject file %s: ", objfile_name (objfile));
167  printf_filtered ("Objfile at ");
169  printf_filtered (", bfd at ");
171  printf_filtered (", %d minsyms\n\n",
172  objfile->per_bfd->minimal_symbol_count);
173 
174  if (objfile->sf)
175  objfile->sf->qf->dump (objfile);
176 
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));
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 }
194 
195 /* Print minimal symbols from this objfile. */
196 
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;
204 
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);
215 
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;
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 }
283 
284 static void
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;
297 
298  fprintf_filtered (outfile, "\nSymtab for file %s\n",
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));
309 
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 ");
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",
354  if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
355  {
356  fprintf_filtered (outfile, ", %s",
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;
367 
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",
374  }
375  }
376  fprintf_filtered (outfile, "\n");
377  }
378  else
379  {
380  fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
381  }
382 }
383 
384 static void
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;
396 
397  saved_lang = set_language (symtab->language);
398 
399  dump_symtab_1 (objfile, symtab, outfile);
400 
401  set_language (saved_lang);
402  }
403  else
404  dump_symtab_1 (objfile, symtab, outfile);
405 }
406 
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;
418 
419  dont_repeat ();
420 
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);
428 
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  }
438 
439  filename = tilde_expand (filename);
440  make_cleanup (xfree, filename);
441 
442  outfile = gdb_fopen (filename, FOPEN_WT);
443  if (outfile == 0)
444  perror_with_name (filename);
445  make_cleanup_ui_file_delete (outfile);
446 
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 }
456 
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. */
461 
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;
470 
471  if (SYMBOL_OBJFILE_OWNED (symbol))
472  section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
473  else
474  section = NULL;
475 
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,
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,
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,
522  fprintf_filtered (outfile, "; ");
523  }
524  else
525  fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
526 
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;
534 
535  case LOC_CONST_BYTES:
536  {
537  unsigned i;
538  struct type *type = check_typedef (SYMBOL_TYPE (symbol));
539 
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;
547 
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;
557 
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;
566 
567  case LOC_ARG:
568  fprintf_filtered (outfile, "arg at offset %s",
569  hex_string (SYMBOL_VALUE (symbol)));
570  break;
571 
572  case LOC_REF_ARG:
573  fprintf_filtered (outfile, "reference arg at %s",
574  hex_string (SYMBOL_VALUE (symbol)));
575  break;
576 
577  case LOC_REGPARM_ADDR:
578  fprintf_filtered (outfile, "address parameter register %s",
579  plongest (SYMBOL_VALUE (symbol)));
580  break;
581 
582  case LOC_LOCAL:
583  fprintf_filtered (outfile, "local at offset %s",
584  hex_string (SYMBOL_VALUE (symbol)));
585  break;
586 
587  case LOC_TYPEDEF:
588  break;
589 
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;
599 
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;
616 
617  case LOC_COMPUTED:
618  fprintf_filtered (outfile, "computed at runtime");
619  break;
620 
621  case LOC_UNRESOLVED:
622  fprintf_filtered (outfile, "unresolved");
623  break;
624 
625  case LOC_OPTIMIZED_OUT:
626  fprintf_filtered (outfile, "optimized out");
627  break;
628 
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 }
638 
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;
649 
650  struct stat sym_st, obj_st;
651 
652  dont_repeat ();
653 
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);
661 
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  }
674 
675  filename = tilde_expand (filename);
676  make_cleanup (xfree, filename);
677 
678  outfile = gdb_fopen (filename, FOPEN_WT);
679  if (outfile == 0)
680  perror_with_name (filename);
681  make_cleanup_ui_file_delete (outfile);
682 
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 }
695 
696 static void
697 maintenance_print_objfiles (char *regexp, int from_tty)
698 {
699  struct program_space *pspace;
700  struct objfile *objfile;
701 
702  dont_repeat ();
703 
704  if (regexp)
705  re_comp (regexp);
706 
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 }
716 
717 /* List all the symbol tables whose names match REGEXP (optional). */
718 
719 static void
720 maintenance_info_symtabs (char *regexp, int from_tty)
721 {
722  struct program_space *pspace;
723  struct objfile *objfile;
724 
725  dont_repeat ();
726 
727  if (regexp)
728  re_comp (regexp);
729 
730  ALL_PSPACES (pspace)
731  ALL_PSPACE_OBJFILES (pspace, objfile)
732  {
733  struct compunit_symtab *cust;
734  struct symtab *symtab;
735 
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;
739 
740  ALL_OBJFILE_COMPUNITS (objfile, cust)
741  {
742  int printed_compunit_symtab_start = 0;
743 
744  ALL_COMPUNIT_FILETABS (cust, symtab)
745  {
746  QUIT;
747 
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",
776  (COMPUNIT_BLOCKVECTOR (cust)));
777  printed_compunit_symtab_start = 1;
778  }
779 
780  printf_filtered ("\t{ symtab %s ",
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",
792  printf_filtered ("\t}\n");
793  }
794  }
795 
796  if (printed_compunit_symtab_start)
797  printf_filtered (" }\n");
798  }
799 
800  if (printed_objfile_start)
801  printf_filtered ("}\n");
802  }
803 }
804 
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.
809 
810  Note: This does not check for psymtab vs symtab consistency.
811  Use "maint check-psymtabs" for that. */
812 
813 static void
814 maintenance_check_symtabs (char *ignore, int from_tty)
815 {
816  struct program_space *pspace;
817  struct objfile *objfile;
818 
819  ALL_PSPACES (pspace)
820  ALL_PSPACE_OBJFILES (pspace, objfile)
821  {
822  struct compunit_symtab *cust;
823 
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;
827 
828  ALL_OBJFILE_COMPUNITS (objfile, cust)
829  {
830  int found_something = 0;
831  struct symtab *symtab = compunit_primary_filetab (cust);
832 
833  QUIT;
834 
835  if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
836  found_something = 1;
837  /* Add more checks here. */
838 
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",
851  if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
852  printf_filtered (" NULL blockvector\n");
853  printf_filtered (" }\n");
854  }
855  }
856 
857  if (printed_objfile_start)
858  printf_filtered ("}\n");
859  }
860 }
861 
862 /* Helper function for maintenance_expand_symtabs.
863  This is the name_matcher function for expand_symtabs_matching. */
864 
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 }
871 
872 /* Helper function for maintenance_expand_symtabs.
873  This is the file_matcher function for expand_symtabs_matching. */
874 
875 static int
876 maintenance_expand_file_matcher (const char *filename, void *data,
877  int basenames)
878 {
879  const char *regexp = data;
880 
881  QUIT;
882 
883  /* KISS: Only apply the regexp to the complete file name. */
884  if (basenames)
885  return 0;
886 
887  if (regexp == NULL || re_exec (filename))
888  return 1;
889 
890  return 0;
891 }
892 
893 /* Expand all symbol tables whose name matches an optional regexp. */
894 
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;
903 
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);
908 
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  }
918 
919  if (regexp)
920  re_comp (regexp);
921 
922  ALL_PSPACES (pspace)
923  ALL_PSPACE_OBJFILES (pspace, objfile)
924  {
925  if (objfile->sf)
926  {
927  objfile->sf->qf->expand_symtabs_matching
930  }
931  }
932 
933  do_cleanups (cleanups);
934 }
935 
936 
937 /* Return the nexting depth of a block within other blocks in its symtab. */
938 
939 static int
941 {
942  int i = 0;
943 
944  while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
945  {
946  i++;
947  }
948  return i;
949 }
950 
951 
952 /* Do early runtime initializations. */
953 
954 void
956 {
957  std_in = stdin;
958  std_out = stdout;
959  std_err = stderr;
960 
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."),
966 
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."),
972 
974  _("Print dump of current object file definitions.\n\
975 With an argument REGEXP, list the object files with matching names."),
977 
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."),
984 
986  _("\
987 Check consistency of currently expanded symtabs."),
988  &maintenancelist);
989 
991  _("Expand symbol tables.\n\
992 With an argument REGEXP, only expand the symbol tables with matching names."),
993  &maintenancelist);
994 }
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
static void dump_symtab(struct objfile *objfile, struct symtab *symtab, struct ui_file *outfile)
Definition: symmisc.c:385
struct ui_file * outfile
Definition: symmisc.c:68
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition: source.c:1171
#define SYMTAB_COMPUNIT(symtab)
Definition: symtab.h:965
#define SYMTAB_DIRNAME(symtab)
Definition: symtab.h:973
char * gdb_realpath(const char *filename)
Definition: utils.c:2840
bfd * obfd
Definition: objfiles.h:313
#define ALL_OBJFILE_FILETABS(objfile, cu, s)
Definition: objfiles.h:591
#define COMPUNIT_DEBUGFORMAT(cust)
Definition: symtab.h:1096
#define SYMBOL_PRINT_NAME(symbol)
Definition: symtab.h:260
void print_objfile_statistics(void)
Definition: symmisc.c:96
struct obstack storage_obstack
Definition: objfiles.h:177
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:409
void(* expand_symtabs_matching)(struct objfile *objfile, expand_symtabs_file_matcher_ftype *file_matcher, expand_symtabs_symbol_matcher_ftype *symbol_matcher, expand_symtabs_exp_notify_ftype *expansion_notify, enum search_domain kind, void *data)
Definition: symfile.h:290
struct linetable_entry item[1]
Definition: symtab.h:892
FILE * std_in
Definition: symmisc.c:53
struct bcache * psymbol_bcache_get_bcache(struct psymbol_bcache *bcache)
Definition: psymtab.c:1596
void xfree(void *)
Definition: common-utils.c:97
static int maintenance_expand_name_matcher(const char *symname, void *data)
Definition: symmisc.c:866
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
void warning(const char *fmt,...)
Definition: errors.c:26
void _initialize_symmisc(void)
Definition: symmisc.c:955
enum language set_language(enum language lang)
Definition: language.c:346
struct cmd_list_element * maintenanceinfolist
Definition: cli-cmds.c:163
struct ui_file * gdb_stdout
Definition: main.c:71
const struct type_print_options type_print_raw_options
Definition: typeprint.c:48
struct ui_file * gdb_fopen(const char *name, const char *mode)
Definition: ui-file.c:723
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:793
void print_spaces(int n, struct ui_file *file)
Definition: utils.c:1098
void(* print_stats)(struct objfile *objfile)
Definition: symfile.h:215
#define ALL_DICT_SYMBOLS(dict, iter, sym)
Definition: dictionary.h:179
FILE * std_out
Definition: symmisc.c:54
int catch_errors(catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask)
Definition: exceptions.c:228
static int print_symbol(void *)
Definition: symmisc.c:463
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:136
const char * filename
Definition: symtab.h:943
#define _(String)
Definition: gdb_locale.h:40
#define MSYMBOL_DEMANGLED_NAME(symbol)
Definition: symtab.h:412
#define BLOCK_START(bl)
Definition: block.h:116
#define COMPUNIT_DIRNAME(cust)
Definition: symtab.h:1098
struct objfile_per_bfd_storage * per_bfd
Definition: objfiles.h:318
struct linetable * linetable
Definition: symtab.h:939
struct objfile * symbol_objfile(const struct symbol *symbol)
Definition: symtab.c:6231
void printf_filtered(const char *format,...)
Definition: utils.c:2388
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
#define SYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:189
#define BLOCK_FUNCTION(bl)
Definition: block.h:118
struct symbol * symbol
Definition: symmisc.c:66
#define MSYMBOL_OBJ_SECTION(objfile, symbol)
Definition: symtab.h:402
static void dump_msymbols(struct objfile *objfile, struct ui_file *outfile)
Definition: symmisc.c:198
#define DEV_TTY
Definition: symmisc.c:44
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:968
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
CORE_ADDR pc
Definition: symtab.h:865
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
#define SYMBOL_DEMANGLED_NAME(symbol)
Definition: symtab.h:245
#define SYMTAB_OBJFILE(symtab)
Definition: symtab.h:970
const char * filename
Definition: symtab.h:342
struct symtab * compunit_primary_filetab(const struct compunit_symtab *cust)
Definition: symtab.c:287
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, cmd_cfunc_ftype *fun, const char *doc, struct cmd_list_element **list)
Definition: cli-decode.c:192
const struct sym_fns * sf
Definition: objfiles.h:347
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
struct obj_section * sections
Definition: objfiles.h:386
const char * language_str(enum language lang)
Definition: language.c:487
Definition: gdbtypes.h:749
#define BLOCK_SUPERBLOCK(bl)
Definition: block.h:119
static void maintenance_check_symtabs(char *ignore, int from_tty)
Definition: symmisc.c:814
enum language language
Definition: symtab.h:957
void(* dump)(struct objfile *objfile)
Definition: symfile.h:219
#define COMPUNIT_PRODUCER(cust)
Definition: symtab.h:1097
int bcache_memory_used(struct bcache *bcache)
Definition: bcache.c:485
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:241
struct compunit_symtab * compunit_symtabs
Definition: objfiles.h:291
#define BLOCK_END(bl)
Definition: block.h:117
static void maintenance_print_symbols(char *args, int from_tty)
Definition: symmisc.c:408
#define BLOCK_DICT(bl)
Definition: block.h:120
void wrap_here(char *indent)
Definition: utils.c:1930
Definition: symtab.h:925
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
#define ALL_FILETABS(objfile, ps, s)
Definition: objfiles.h:610
struct cmd_list_element * maintenanceprintlist
Definition: cli-cmds.c:167
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:181
Definition: block.h:60
#define ALL_OBJFILE_COMPUNITS(objfile, cu)
Definition: objfiles.h:597
struct bcache * macro_cache
Definition: objfiles.h:184
static int maintenance_expand_file_matcher(const char *filename, void *data, int basenames)
Definition: symmisc.c:876
struct bcache * filename_cache
Definition: objfiles.h:181
#define SYMBOL_OBJFILE_OWNED(symbol)
Definition: symtab.h:794
#define LA_PRINT_TYPE(type, varstring, stream, show, level, flags)
Definition: language.h:482
struct gdbarch * gdbarch
Definition: symmisc.c:65
static void maintenance_print_msymbols(char *args, int from_tty)
Definition: symmisc.c:640
#define COMPUNIT_BLOCKVECTOR(cust)
Definition: symtab.h:1099
static void dump_symtab_1(struct objfile *objfile, struct symtab *symtab, struct ui_file *outfile)
Definition: symmisc.c:285
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:382
void gdb_print_host_address(const void *addr, struct ui_file *stream)
Definition: utils.c:1106
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
#define ALL_PSPACES(pspace)
Definition: progspace.h:232
void print_bcache_statistics(struct bcache *c, char *type)
Definition: bcache.c:358
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
#define SYMBOL_BLOCK_VALUE(symbol)
Definition: symtab.h:185
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
static void dump_objfile(struct objfile *objfile)
Definition: symmisc.c:161
#define OBJSTAT(objfile, expr)
Definition: objfiles.h:160
const char * symbol
Definition: signals.c:48
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
#define COMPUNIT_FILETABS(cust)
Definition: symtab.h:1095
#define BLOCKVECTOR_NBLOCKS(blocklist)
Definition: block.h:135
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1228
#define ALL_OBJFILE_MSYMBOLS(objfile, m)
Definition: objfiles.h:602
EXTERN_C char * re_comp(const char *)
static void maintenance_info_symtabs(char *regexp, int from_tty)
Definition: symmisc.c:720
FILE * std_err
Definition: symmisc.c:55
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:917
language
Definition: defs.h:167
int nitems
Definition: symtab.h:887
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
int dict_size(const struct dictionary *dict)
Definition: dictionary.c:568
struct cmd_list_element * maintenancelist
Definition: cli-cmds.c:159
void print_symbol_bcache_statistics(void)
Definition: symmisc.c:75
#define ALL_COMPUNIT_FILETABS(cu, s)
Definition: symtab.h:1108
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1237
static void maintenance_expand_symtabs(char *args, int from_tty)
Definition: symmisc.c:896
char * fullname
Definition: symtab.h:962
void dont_repeat(void)
Definition: top.c:582
static int block_depth(struct block *)
Definition: symmisc.c:940
#define SYMBOL_VALUE_BYTES(symbol)
Definition: symtab.h:183
int line
Definition: symtab.h:864
#define QUIT
Definition: defs.h:160
const struct quick_symbol_functions * qf
Definition: symfile.h:398
static void maintenance_print_objfiles(char *regexp, int from_tty)
Definition: symmisc.c:697
#define ALL_PSPACE_OBJFILES(ss, obj)
Definition: objfiles.h:576
#define SYMTAB_LINETABLE(symtab)
Definition: symtab.h:966
struct psymbol_bcache * psymbol_cache
Definition: objfiles.h:333
void error(const char *fmt,...)
Definition: errors.c:38
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
#define MSYMBOL_VALUE_ADDRESS(objfile, symbol)
Definition: symtab.h:389
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:795
const ULONGEST const LONGEST len
Definition: target.h:309