1 /* Do various things to symbol tables (other than lookup), for GDB.
3 Copyright (C) 1986-2016 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/>. */
24 #include "filenames.h"
27 #include "breakpoint.h"
29 #include "gdb_obstack.h"
33 #include "gdb_regex.h"
35 #include "dictionary.h"
36 #include "typeprint.h"
39 #include "readline/readline.h"
44 #define DEV_TTY "/dev/tty"
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
57 /* Prototypes for local functions */
59 static int block_depth (struct block *);
61 void _initialize_symmisc (void);
63 struct print_symbol_args
65 struct gdbarch *gdbarch;
66 struct symbol *symbol;
68 struct ui_file *outfile;
71 static int print_symbol (void *);
75 print_symbol_bcache_statistics (void)
77 struct program_space *pspace;
78 struct objfile *objfile;
81 ALL_PSPACE_OBJFILES (pspace, objfile)
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,
96 print_objfile_statistics (void)
98 struct program_space *pspace;
99 struct objfile *objfile;
100 struct compunit_symtab *cu;
102 int i, linetables, blockvectors;
105 ALL_PSPACE_OBJFILES (pspace, objfile)
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));
125 objfile->sf->qf->print_stats (objfile);
126 i = linetables = blockvectors = 0;
127 ALL_OBJFILE_FILETABS (objfile, cu, s)
130 if (SYMTAB_LINETABLE (s) != NULL)
133 ALL_OBJFILE_COMPUNITS (objfile, cu)
135 printf_filtered (_(" Number of symbol tables: %d\n"), i);
136 printf_filtered (_(" Number of symbol tables with line tables: %d\n"),
138 printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"),
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));
161 dump_objfile (struct objfile *objfile)
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);
175 objfile->sf->qf->dump (objfile);
177 if (objfile->compunit_symtabs != NULL)
179 printf_filtered ("Symtabs:\n");
180 ALL_OBJFILE_FILETABS (objfile, cust, symtab)
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)
187 printf_filtered ("NOT ON CHAIN! ");
191 printf_filtered ("\n\n");
195 /* Print minimal symbols from this objfile. */
198 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
200 struct gdbarch *gdbarch = get_objfile_arch (objfile);
201 struct minimal_symbol *msymbol;
205 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
206 if (objfile->per_bfd->minimal_symbol_count == 0)
208 fprintf_filtered (outfile, "No minimal symbols found.\n");
212 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
214 struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
216 switch (MSYMBOL_TYPE (msymbol))
224 case mst_text_gnu_ifunc:
227 case mst_solib_trampoline:
252 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
253 fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
256 fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
259 if (section->the_bfd_section != NULL)
260 fprintf_filtered (outfile, " section %s",
261 bfd_section_name (objfile->obfd,
262 section->the_bfd_section));
264 fprintf_filtered (outfile, " spurious section %ld",
265 (long) (section - objfile->sections));
267 if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
269 fprintf_filtered (outfile, " %s", MSYMBOL_DEMANGLED_NAME (msymbol));
271 if (msymbol->filename)
272 fprintf_filtered (outfile, " %s", msymbol->filename);
273 fputs_filtered ("\n", outfile);
276 if (objfile->per_bfd->minimal_symbol_count != index)
278 warning (_("internal error: minimal symbol count %d != %d"),
279 objfile->per_bfd->minimal_symbol_count, index);
281 fprintf_filtered (outfile, "\n");
285 dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
287 struct objfile *objfile = SYMTAB_OBJFILE (symtab);
288 struct gdbarch *gdbarch = get_objfile_arch (objfile);
290 struct dict_iterator iter;
293 const struct blockvector *bv;
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);
314 fprintf_filtered (outfile, "\nLine table:\n\n");
316 for (i = 0; i < len; i++)
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");
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)))
327 fprintf_filtered (outfile, "\nBlockvector:\n\n");
328 bv = SYMTAB_BLOCKVECTOR (symtab);
329 len = BLOCKVECTOR_NBLOCKS (bv);
330 for (i = 0; i < len; i++)
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))
339 fprintf_filtered (outfile, " under ");
340 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
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
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))
352 fprintf_filtered (outfile, ", function %s",
353 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
354 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
356 fprintf_filtered (outfile, ", %s",
357 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
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)
366 struct print_symbol_args s;
372 catch_errors (print_symbol, &s, "Error printing symbol:\n",
376 fprintf_filtered (outfile, "\n");
380 const char *compunit_filename
381 = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)));
383 fprintf_filtered (outfile,
384 "\nBlockvector same as owning compunit: %s\n\n",
390 dump_symtab (struct symtab *symtab, struct ui_file *outfile)
392 /* Set the current language to the language of the symtab we're dumping
393 because certain routines used during dump_symtab() use the current
394 language to print an image of the symbol. We'll restore it later.
395 But use only real languages, not placeholders. */
396 if (symtab->language != language_unknown
397 && symtab->language != language_auto)
399 enum language saved_lang;
401 saved_lang = set_language (symtab->language);
403 dump_symtab_1 (symtab, outfile);
405 set_language (saved_lang);
408 dump_symtab_1 (symtab, outfile);
412 maintenance_print_symbols (char *args, int from_tty)
415 struct ui_file *outfile;
416 struct cleanup *cleanups;
417 char *symname = NULL;
418 char *filename = DEV_TTY;
419 struct objfile *objfile;
420 struct compunit_symtab *cu;
427 error (_("Arguments missing: an output file name "
428 "and an optional symbol file name"));
430 argv = gdb_buildargv (args);
431 cleanups = make_cleanup_freeargv (argv);
436 /* If a second arg is supplied, it is a source file name to match on. */
443 filename = tilde_expand (filename);
444 make_cleanup (xfree, filename);
446 outfile = gdb_fopen (filename, FOPEN_WT);
448 perror_with_name (filename);
449 make_cleanup_ui_file_delete (outfile);
451 ALL_FILETABS (objfile, cu, s)
455 || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0)
456 dump_symtab (s, outfile);
458 do_cleanups (cleanups);
461 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
462 far to indent. ARGS is really a struct print_symbol_args *, but is
463 declared as char * to get it past catch_errors. Returns 0 for error,
467 print_symbol (void *args)
469 struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
470 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
471 int depth = ((struct print_symbol_args *) args)->depth;
472 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
473 struct obj_section *section;
475 if (SYMBOL_OBJFILE_OWNED (symbol))
476 section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
480 print_spaces (depth, outfile);
481 if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
483 fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
484 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
487 fprintf_filtered (outfile, " section %s\n",
488 bfd_section_name (section->the_bfd_section->owner,
489 section->the_bfd_section));
491 fprintf_filtered (outfile, "\n");
494 if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
496 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
498 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
499 &type_print_raw_options);
503 fprintf_filtered (outfile, "%s %s = ",
504 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
506 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
507 ? "struct" : "union")),
508 SYMBOL_LINKAGE_NAME (symbol));
509 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
510 &type_print_raw_options);
512 fprintf_filtered (outfile, ";\n");
516 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
517 fprintf_filtered (outfile, "typedef ");
518 if (SYMBOL_TYPE (symbol))
520 /* Print details of types, except for enums where it's clutter. */
521 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
523 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
525 &type_print_raw_options);
526 fprintf_filtered (outfile, "; ");
529 fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
531 switch (SYMBOL_CLASS (symbol))
534 fprintf_filtered (outfile, "const %s (%s)",
535 plongest (SYMBOL_VALUE (symbol)),
536 hex_string (SYMBOL_VALUE (symbol)));
539 case LOC_CONST_BYTES:
542 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
544 fprintf_filtered (outfile, "const %u hex bytes:",
546 for (i = 0; i < TYPE_LENGTH (type); i++)
547 fprintf_filtered (outfile, " %02x",
548 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
553 fprintf_filtered (outfile, "static at ");
554 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
557 fprintf_filtered (outfile, " section %s",
558 bfd_section_name (section->the_bfd_section->owner,
559 section->the_bfd_section));
563 if (SYMBOL_IS_ARGUMENT (symbol))
564 fprintf_filtered (outfile, "parameter register %s",
565 plongest (SYMBOL_VALUE (symbol)));
567 fprintf_filtered (outfile, "register %s",
568 plongest (SYMBOL_VALUE (symbol)));
572 fprintf_filtered (outfile, "arg at offset %s",
573 hex_string (SYMBOL_VALUE (symbol)));
577 fprintf_filtered (outfile, "reference arg at %s",
578 hex_string (SYMBOL_VALUE (symbol)));
581 case LOC_REGPARM_ADDR:
582 fprintf_filtered (outfile, "address parameter register %s",
583 plongest (SYMBOL_VALUE (symbol)));
587 fprintf_filtered (outfile, "local at offset %s",
588 hex_string (SYMBOL_VALUE (symbol)));
595 fprintf_filtered (outfile, "label at ");
596 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
599 fprintf_filtered (outfile, " section %s",
600 bfd_section_name (section->the_bfd_section->owner,
601 section->the_bfd_section));
605 fprintf_filtered (outfile, "block object ");
606 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
607 fprintf_filtered (outfile, ", ");
608 fputs_filtered (paddress (gdbarch,
609 BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
611 fprintf_filtered (outfile, "..");
612 fputs_filtered (paddress (gdbarch,
613 BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
616 fprintf_filtered (outfile, " section %s",
617 bfd_section_name (section->the_bfd_section->owner,
618 section->the_bfd_section));
622 fprintf_filtered (outfile, "computed at runtime");
626 fprintf_filtered (outfile, "unresolved");
629 case LOC_OPTIMIZED_OUT:
630 fprintf_filtered (outfile, "optimized out");
634 fprintf_filtered (outfile, "botched symbol class %x",
635 SYMBOL_CLASS (symbol));
639 fprintf_filtered (outfile, "\n");
644 maintenance_print_msymbols (char *args, int from_tty)
647 struct ui_file *outfile;
648 struct cleanup *cleanups;
649 char *filename = DEV_TTY;
650 char *symname = NULL;
651 struct program_space *pspace;
652 struct objfile *objfile;
654 struct stat sym_st, obj_st;
660 error (_("print-msymbols takes an output file "
661 "name and optional symbol file name"));
663 argv = gdb_buildargv (args);
664 cleanups = make_cleanup_freeargv (argv);
669 /* If a second arg is supplied, it is a source file name to match on. */
672 symname = gdb_realpath (argv[1]);
673 make_cleanup (xfree, symname);
674 if (symname && stat (symname, &sym_st))
675 perror_with_name (symname);
679 filename = tilde_expand (filename);
680 make_cleanup (xfree, filename);
682 outfile = gdb_fopen (filename, FOPEN_WT);
684 perror_with_name (filename);
685 make_cleanup_ui_file_delete (outfile);
688 ALL_PSPACE_OBJFILES (pspace, objfile)
691 if (symname == NULL || (!stat (objfile_name (objfile), &obj_st)
692 && sym_st.st_dev == obj_st.st_dev
693 && sym_st.st_ino == obj_st.st_ino))
694 dump_msymbols (objfile, outfile);
696 fprintf_filtered (outfile, "\n\n");
697 do_cleanups (cleanups);
701 maintenance_print_objfiles (char *regexp, int from_tty)
703 struct program_space *pspace;
704 struct objfile *objfile;
712 ALL_PSPACE_OBJFILES (pspace, objfile)
716 || re_exec (objfile_name (objfile)))
717 dump_objfile (objfile);
721 /* List all the symbol tables whose names match REGEXP (optional). */
724 maintenance_info_symtabs (char *regexp, int from_tty)
726 struct program_space *pspace;
727 struct objfile *objfile;
735 ALL_PSPACE_OBJFILES (pspace, objfile)
737 struct compunit_symtab *cust;
738 struct symtab *symtab;
740 /* We don't want to print anything for this objfile until we
741 actually find a symtab whose name matches. */
742 int printed_objfile_start = 0;
744 ALL_OBJFILE_COMPUNITS (objfile, cust)
746 int printed_compunit_symtab_start = 0;
748 ALL_COMPUNIT_FILETABS (cust, symtab)
753 || re_exec (symtab_to_filename_for_display (symtab)))
755 if (! printed_objfile_start)
757 printf_filtered ("{ objfile %s ", objfile_name (objfile));
759 printf_filtered ("((struct objfile *) %s)\n",
760 host_address_to_string (objfile));
761 printed_objfile_start = 1;
763 if (! printed_compunit_symtab_start)
765 printf_filtered (" { ((struct compunit_symtab *) %s)\n",
766 host_address_to_string (cust));
767 printf_filtered (" debugformat %s\n",
768 COMPUNIT_DEBUGFORMAT (cust));
769 printf_filtered (" producer %s\n",
770 COMPUNIT_PRODUCER (cust) != NULL
771 ? COMPUNIT_PRODUCER (cust)
773 printf_filtered (" dirname %s\n",
774 COMPUNIT_DIRNAME (cust) != NULL
775 ? COMPUNIT_DIRNAME (cust)
777 printf_filtered (" blockvector"
778 " ((struct blockvector *) %s)\n",
779 host_address_to_string
780 (COMPUNIT_BLOCKVECTOR (cust)));
781 printed_compunit_symtab_start = 1;
784 printf_filtered ("\t{ symtab %s ",
785 symtab_to_filename_for_display (symtab));
787 printf_filtered ("((struct symtab *) %s)\n",
788 host_address_to_string (symtab));
789 printf_filtered ("\t fullname %s\n",
790 symtab->fullname != NULL
793 printf_filtered ("\t "
794 "linetable ((struct linetable *) %s)\n",
795 host_address_to_string (symtab->linetable));
796 printf_filtered ("\t}\n");
800 if (printed_compunit_symtab_start)
801 printf_filtered (" }\n");
804 if (printed_objfile_start)
805 printf_filtered ("}\n");
809 /* Check consistency of symtabs.
810 An example of what this checks for is NULL blockvectors.
811 They can happen if there's a bug during debug info reading.
812 GDB assumes they are always non-NULL.
814 Note: This does not check for psymtab vs symtab consistency.
815 Use "maint check-psymtabs" for that. */
818 maintenance_check_symtabs (char *ignore, int from_tty)
820 struct program_space *pspace;
821 struct objfile *objfile;
824 ALL_PSPACE_OBJFILES (pspace, objfile)
826 struct compunit_symtab *cust;
828 /* We don't want to print anything for this objfile until we
829 actually find something worth printing. */
830 int printed_objfile_start = 0;
832 ALL_OBJFILE_COMPUNITS (objfile, cust)
834 int found_something = 0;
835 struct symtab *symtab = compunit_primary_filetab (cust);
839 if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
841 /* Add more checks here. */
845 if (! printed_objfile_start)
847 printf_filtered ("{ objfile %s ", objfile_name (objfile));
849 printf_filtered ("((struct objfile *) %s)\n",
850 host_address_to_string (objfile));
851 printed_objfile_start = 1;
853 printf_filtered (" { symtab %s\n",
854 symtab_to_filename_for_display (symtab));
855 if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
856 printf_filtered (" NULL blockvector\n");
857 printf_filtered (" }\n");
861 if (printed_objfile_start)
862 printf_filtered ("}\n");
866 /* Helper function for maintenance_expand_symtabs.
867 This is the name_matcher function for expand_symtabs_matching. */
870 maintenance_expand_name_matcher (const char *symname, void *data)
872 /* Since we're not searching on symbols, just return TRUE. */
876 /* Helper function for maintenance_expand_symtabs.
877 This is the file_matcher function for expand_symtabs_matching. */
880 maintenance_expand_file_matcher (const char *filename, void *data,
883 const char *regexp = (const char *) data;
887 /* KISS: Only apply the regexp to the complete file name. */
891 if (regexp == NULL || re_exec (filename))
897 /* Expand all symbol tables whose name matches an optional regexp. */
900 maintenance_expand_symtabs (char *args, int from_tty)
902 struct program_space *pspace;
903 struct objfile *objfile;
904 struct cleanup *cleanups;
908 /* We use buildargv here so that we handle spaces in the regexp
909 in a way that allows adding more arguments later. */
910 argv = gdb_buildargv (args);
911 cleanups = make_cleanup_freeargv (argv);
919 error (_("Extra arguments after regexp."));
927 ALL_PSPACE_OBJFILES (pspace, objfile)
931 objfile->sf->qf->expand_symtabs_matching
932 (objfile, maintenance_expand_file_matcher,
933 maintenance_expand_name_matcher, NULL, ALL_DOMAIN, regexp);
937 do_cleanups (cleanups);
941 /* Return the nexting depth of a block within other blocks in its symtab. */
944 block_depth (struct block *block)
948 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
956 /* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
957 single line table. */
960 maintenance_print_one_line_table (struct symtab *symtab, void *data)
962 struct linetable *linetable;
963 struct objfile *objfile;
965 objfile = symtab->compunit_symtab->objfile;
966 printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
967 objfile_name (objfile),
968 host_address_to_string (objfile));
969 printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
970 host_address_to_string (symtab->compunit_symtab));
971 printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
972 symtab_to_fullname (symtab),
973 host_address_to_string (symtab));
974 linetable = SYMTAB_LINETABLE (symtab);
975 printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
976 host_address_to_string (linetable));
978 if (linetable == NULL)
979 printf_filtered (_("No line table.\n"));
980 else if (linetable->nitems <= 0)
981 printf_filtered (_("Line table has no lines.\n"));
986 /* Leave space for 6 digits of index and line number. After that the
987 tables will just not format as well. */
988 printf_filtered (_("%-6s %6s %s\n"),
989 _("INDEX"), _("LINE"), _("ADDRESS"));
991 for (i = 0; i < linetable->nitems; ++i)
993 struct linetable_entry *item;
994 struct cleanup *row_cleanup;
996 item = &linetable->item [i];
997 printf_filtered (_("%-6d %6d %s\n"), i, item->line,
998 core_addr_to_string (item->pc));
1005 /* Implement the 'maint info line-table' command. */
1008 maintenance_info_line_tables (char *regexp, int from_tty)
1010 struct program_space *pspace;
1011 struct objfile *objfile;
1018 ALL_PSPACES (pspace)
1019 ALL_PSPACE_OBJFILES (pspace, objfile)
1021 struct compunit_symtab *cust;
1022 struct symtab *symtab;
1024 ALL_OBJFILE_COMPUNITS (objfile, cust)
1026 ALL_COMPUNIT_FILETABS (cust, symtab)
1031 || re_exec (symtab_to_filename_for_display (symtab)))
1032 maintenance_print_one_line_table (symtab, NULL);
1040 /* Do early runtime initializations. */
1043 _initialize_symmisc (void)
1049 add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1050 Print dump of current symbol definitions.\n\
1051 Entries in the full symbol table are dumped to file OUTFILE.\n\
1052 If a SOURCE file is specified, dump only that file's symbols."),
1053 &maintenanceprintlist);
1055 add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1056 Print dump of current minimal symbol definitions.\n\
1057 Entries in the minimal symbol table are dumped to file OUTFILE.\n\
1058 If a SOURCE file is specified, dump only that file's minimal symbols."),
1059 &maintenanceprintlist);
1061 add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1062 _("Print dump of current object file definitions.\n\
1063 With an argument REGEXP, list the object files with matching names."),
1064 &maintenanceprintlist);
1066 add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1067 List the full symbol tables for all object files.\n\
1068 This does not include information about individual symbols, blocks, or\n\
1069 linetables --- just the symbol table structures themselves.\n\
1070 With an argument REGEXP, list the symbol tables with matching names."),
1071 &maintenanceinfolist);
1073 add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1074 List the contents of all line tables, from all symbol tables.\n\
1075 With an argument REGEXP, list just the line tables for the symbol\n\
1076 tables with matching names."),
1077 &maintenanceinfolist);
1079 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1081 Check consistency of currently expanded symtabs."),
1084 add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1085 _("Expand symbol tables.\n\
1086 With an argument REGEXP, only expand the symbol tables with matching names."),