1 /* Do various things to symbol tables (other than lookup), for GDB.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2007, 2008
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "breakpoint.h"
30 #include "gdb_obstack.h"
31 #include "exceptions.h"
35 #include "gdb_regex.h"
37 #include "dictionary.h"
39 #include "gdb_string.h"
40 #include "readline/readline.h"
43 #define DEV_TTY "/dev/tty"
46 /* Unfortunately for debugging, stderr is usually a macro. This is painful
47 when calling functions that take FILE *'s from the debugger.
48 So we make a variable which has the same value and which is accessible when
49 debugging GDB with itself. Because stdin et al need not be constants,
50 we initialize them in the _initialize_symmisc function at the bottom
56 /* Prototypes for local functions */
58 static void dump_symtab (struct objfile *, struct symtab *,
61 static void dump_psymtab (struct objfile *, struct partial_symtab *,
64 static void dump_msymbols (struct objfile *, struct ui_file *);
66 static void dump_objfile (struct objfile *);
68 static int block_depth (struct block *);
70 static void print_partial_symbols (struct partial_symbol **, int,
71 char *, struct ui_file *);
73 void _initialize_symmisc (void);
75 struct print_symbol_args
77 struct symbol *symbol;
79 struct ui_file *outfile;
82 static int print_symbol (void *);
84 /* Free all the storage associated with the struct symtab <- S.
85 Note that some symtabs have contents that all live inside one big block of
86 memory, and some share the contents of another symbol table and so you
87 should not free the contents on their behalf (except sometimes the
88 linetable, which maybe per symtab even when the rest is not).
89 It is s->free_code that says which alternative to use. */
92 free_symtab (struct symtab *s)
95 struct blockvector *bv;
100 /* All the contents are part of a big block of memory (an obstack),
101 and some other symtab is in charge of freeing that block.
102 Therefore, do nothing. */
106 /* Everything will be freed either by our `free_func'
107 or by some other symtab, except for our linetable.
110 xfree (LINETABLE (s));
114 /* If there is a single block of memory to free, free it. */
115 if (s->free_func != NULL)
118 /* Free source-related stuff */
119 if (s->line_charpos != NULL)
120 xfree (s->line_charpos);
121 if (s->fullname != NULL)
123 if (s->debugformat != NULL)
124 xfree (s->debugformat);
129 print_symbol_bcache_statistics (void)
131 struct objfile *objfile;
134 ALL_OBJFILES (objfile)
136 printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
137 print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
143 print_objfile_statistics (void)
145 struct objfile *objfile;
147 struct partial_symtab *ps;
148 int i, linetables, blockvectors;
151 ALL_OBJFILES (objfile)
153 printf_filtered (_("Statistics for '%s':\n"), objfile->name);
154 if (OBJSTAT (objfile, n_stabs) > 0)
155 printf_filtered (_(" Number of \"stab\" symbols read: %d\n"),
156 OBJSTAT (objfile, n_stabs));
157 if (OBJSTAT (objfile, n_minsyms) > 0)
158 printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"),
159 OBJSTAT (objfile, n_minsyms));
160 if (OBJSTAT (objfile, n_psyms) > 0)
161 printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
162 OBJSTAT (objfile, n_psyms));
163 if (OBJSTAT (objfile, n_syms) > 0)
164 printf_filtered (_(" Number of \"full\" symbols read: %d\n"),
165 OBJSTAT (objfile, n_syms));
166 if (OBJSTAT (objfile, n_types) > 0)
167 printf_filtered (_(" Number of \"types\" defined: %d\n"),
168 OBJSTAT (objfile, n_types));
170 ALL_OBJFILE_PSYMTABS (objfile, ps)
175 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
176 i = linetables = blockvectors = 0;
177 ALL_OBJFILE_SYMTABS (objfile, s)
180 if (s->linetable != NULL)
185 printf_filtered (_(" Number of symbol tables: %d\n"), i);
186 printf_filtered (_(" Number of symbol tables with line tables: %d\n"),
188 printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"),
191 if (OBJSTAT (objfile, sz_strtab) > 0)
192 printf_filtered (_(" Space used by a.out string tables: %d\n"),
193 OBJSTAT (objfile, sz_strtab));
194 printf_filtered (_(" Total memory used for objfile obstack: %d\n"),
195 obstack_memory_used (&objfile->objfile_obstack));
196 printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
197 bcache_memory_used (objfile->psymbol_cache));
198 printf_filtered (_(" Total memory used for macro cache: %d\n"),
199 bcache_memory_used (objfile->macro_cache));
205 dump_objfile (struct objfile *objfile)
207 struct symtab *symtab;
208 struct partial_symtab *psymtab;
210 printf_filtered ("\nObject file %s: ", objfile->name);
211 printf_filtered ("Objfile at ");
212 gdb_print_host_address (objfile, gdb_stdout);
213 printf_filtered (", bfd at ");
214 gdb_print_host_address (objfile->obfd, gdb_stdout);
215 printf_filtered (", %d minsyms\n\n",
216 objfile->minimal_symbol_count);
218 if (objfile->psymtabs)
220 printf_filtered ("Psymtabs:\n");
221 for (psymtab = objfile->psymtabs;
223 psymtab = psymtab->next)
225 printf_filtered ("%s at ",
227 gdb_print_host_address (psymtab, gdb_stdout);
228 printf_filtered (", ");
229 if (psymtab->objfile != objfile)
231 printf_filtered ("NOT ON CHAIN! ");
235 printf_filtered ("\n\n");
238 if (objfile->symtabs)
240 printf_filtered ("Symtabs:\n");
241 for (symtab = objfile->symtabs;
243 symtab = symtab->next)
245 printf_filtered ("%s at ", symtab->filename);
246 gdb_print_host_address (symtab, gdb_stdout);
247 printf_filtered (", ");
248 if (symtab->objfile != objfile)
250 printf_filtered ("NOT ON CHAIN! ");
254 printf_filtered ("\n\n");
258 /* Print minimal symbols from this objfile. */
261 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
263 struct minimal_symbol *msymbol;
267 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
268 if (objfile->minimal_symbol_count == 0)
270 fprintf_filtered (outfile, "No minimal symbols found.\n");
273 for (index = 0, msymbol = objfile->msymbols;
274 DEPRECATED_SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
276 switch (msymbol->type)
284 case mst_solib_trampoline:
309 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
310 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (msymbol)), outfile);
311 fprintf_filtered (outfile, " %s", DEPRECATED_SYMBOL_NAME (msymbol));
312 if (SYMBOL_BFD_SECTION (msymbol))
313 fprintf_filtered (outfile, " section %s",
314 bfd_section_name (objfile->obfd,
315 SYMBOL_BFD_SECTION (msymbol)));
316 if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
318 fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol));
320 if (msymbol->filename)
321 fprintf_filtered (outfile, " %s", msymbol->filename);
322 fputs_filtered ("\n", outfile);
324 if (objfile->minimal_symbol_count != index)
326 warning (_("internal error: minimal symbol count %d != %d"),
327 objfile->minimal_symbol_count, index);
329 fprintf_filtered (outfile, "\n");
333 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
334 struct ui_file *outfile)
338 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
340 fprintf_filtered (outfile, "(object ");
341 gdb_print_host_address (psymtab, outfile);
342 fprintf_filtered (outfile, ")\n\n");
343 fprintf_unfiltered (outfile, " Read from object file %s (",
345 gdb_print_host_address (objfile, outfile);
346 fprintf_unfiltered (outfile, ")\n");
350 fprintf_filtered (outfile,
351 " Full symtab was read (at ");
352 gdb_print_host_address (psymtab->symtab, outfile);
353 fprintf_filtered (outfile, " by function at ");
354 gdb_print_host_address (psymtab->read_symtab, outfile);
355 fprintf_filtered (outfile, ")\n");
358 fprintf_filtered (outfile, " Relocate symbols by ");
359 for (i = 0; i < psymtab->objfile->num_sections; ++i)
362 fprintf_filtered (outfile, ", ");
364 fputs_filtered (paddress (ANOFFSET (psymtab->section_offsets, i)),
367 fprintf_filtered (outfile, "\n");
369 fprintf_filtered (outfile, " Symbols cover text addresses ");
370 fputs_filtered (paddress (psymtab->textlow), outfile);
371 fprintf_filtered (outfile, "-");
372 fputs_filtered (paddress (psymtab->texthigh), outfile);
373 fprintf_filtered (outfile, "\n");
374 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
375 psymtab->number_of_dependencies);
376 for (i = 0; i < psymtab->number_of_dependencies; i++)
378 fprintf_filtered (outfile, " %d ", i);
379 gdb_print_host_address (psymtab->dependencies[i], outfile);
380 fprintf_filtered (outfile, " %s\n",
381 psymtab->dependencies[i]->filename);
383 if (psymtab->n_global_syms > 0)
385 print_partial_symbols (objfile->global_psymbols.list
386 + psymtab->globals_offset,
387 psymtab->n_global_syms, "Global", outfile);
389 if (psymtab->n_static_syms > 0)
391 print_partial_symbols (objfile->static_psymbols.list
392 + psymtab->statics_offset,
393 psymtab->n_static_syms, "Static", outfile);
395 fprintf_filtered (outfile, "\n");
399 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
400 struct ui_file *outfile)
403 struct dict_iterator iter;
406 struct blockvector *bv;
411 fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
413 fprintf_filtered (outfile, "Compilation directory is %s\n",
415 fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
416 gdb_print_host_address (objfile, outfile);
417 fprintf_filtered (outfile, ")\n");
418 fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
420 /* First print the line table. */
421 l = LINETABLE (symtab);
424 fprintf_filtered (outfile, "\nLine table:\n\n");
426 for (i = 0; i < len; i++)
428 fprintf_filtered (outfile, " line %d at ", l->item[i].line);
429 fputs_filtered (paddress (l->item[i].pc), outfile);
430 fprintf_filtered (outfile, "\n");
433 /* Now print the block info, but only for primary symtabs since we will
434 print lots of duplicate info otherwise. */
437 fprintf_filtered (outfile, "\nBlockvector:\n\n");
438 bv = BLOCKVECTOR (symtab);
439 len = BLOCKVECTOR_NBLOCKS (bv);
440 for (i = 0; i < len; i++)
442 b = BLOCKVECTOR_BLOCK (bv, i);
443 depth = block_depth (b) * 2;
444 print_spaces (depth, outfile);
445 fprintf_filtered (outfile, "block #%03d, object at ", i);
446 gdb_print_host_address (b, outfile);
447 if (BLOCK_SUPERBLOCK (b))
449 fprintf_filtered (outfile, " under ");
450 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
452 /* drow/2002-07-10: We could save the total symbols count
453 even if we're using a hashtable, but nothing else but this message
455 fprintf_filtered (outfile, ", %d syms/buckets in ",
456 dict_size (BLOCK_DICT (b)));
457 fputs_filtered (paddress (BLOCK_START (b)), outfile);
458 fprintf_filtered (outfile, "..");
459 fputs_filtered (paddress (BLOCK_END (b)), outfile);
460 if (BLOCK_FUNCTION (b))
462 fprintf_filtered (outfile, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b)));
463 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
465 fprintf_filtered (outfile, ", %s",
466 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
469 fprintf_filtered (outfile, "\n");
470 /* Now print each symbol in this block (in no particular order, if
471 we're using a hashtable). */
472 ALL_BLOCK_SYMBOLS (b, iter, sym)
474 struct print_symbol_args s;
478 catch_errors (print_symbol, &s, "Error printing symbol:\n",
482 fprintf_filtered (outfile, "\n");
486 fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
491 dump_symtab (struct objfile *objfile, struct symtab *symtab,
492 struct ui_file *outfile)
494 enum language saved_lang;
496 /* Set the current language to the language of the symtab we're dumping
497 because certain routines used during dump_symtab() use the current
498 language to print an image of the symbol. We'll restore it later. */
499 saved_lang = set_language (symtab->language);
501 dump_symtab_1 (objfile, symtab, outfile);
503 set_language (saved_lang);
507 maintenance_print_symbols (char *args, int from_tty)
510 struct ui_file *outfile;
511 struct cleanup *cleanups;
512 char *symname = NULL;
513 char *filename = DEV_TTY;
514 struct objfile *objfile;
522 Arguments missing: an output file name and an optional symbol file name"));
524 else if ((argv = buildargv (args)) == NULL)
528 cleanups = make_cleanup_freeargv (argv);
533 /* If a second arg is supplied, it is a source file name to match on */
540 filename = tilde_expand (filename);
541 make_cleanup (xfree, filename);
543 outfile = gdb_fopen (filename, FOPEN_WT);
545 perror_with_name (filename);
546 make_cleanup_ui_file_delete (outfile);
549 ALL_SYMTABS (objfile, s)
550 if (symname == NULL || strcmp (symname, s->filename) == 0)
551 dump_symtab (objfile, s, outfile);
553 do_cleanups (cleanups);
556 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
557 far to indent. ARGS is really a struct print_symbol_args *, but is
558 declared as char * to get it past catch_errors. Returns 0 for error,
562 print_symbol (void *args)
564 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
565 int depth = ((struct print_symbol_args *) args)->depth;
566 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
568 print_spaces (depth, outfile);
569 if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
571 fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
572 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
573 if (SYMBOL_BFD_SECTION (symbol))
574 fprintf_filtered (outfile, " section %s\n",
575 bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
576 SYMBOL_BFD_SECTION (symbol)));
578 fprintf_filtered (outfile, "\n");
581 if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
583 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
585 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
589 fprintf_filtered (outfile, "%s %s = ",
590 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
592 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
593 ? "struct" : "union")),
594 DEPRECATED_SYMBOL_NAME (symbol));
595 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
597 fprintf_filtered (outfile, ";\n");
601 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
602 fprintf_filtered (outfile, "typedef ");
603 if (SYMBOL_TYPE (symbol))
605 /* Print details of types, except for enums where it's clutter. */
606 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
608 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
610 fprintf_filtered (outfile, "; ");
613 fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
615 switch (SYMBOL_CLASS (symbol))
618 fprintf_filtered (outfile, "const %ld (0x%lx)",
619 SYMBOL_VALUE (symbol),
620 SYMBOL_VALUE (symbol));
623 case LOC_CONST_BYTES:
626 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
627 fprintf_filtered (outfile, "const %u hex bytes:",
629 for (i = 0; i < TYPE_LENGTH (type); i++)
630 fprintf_filtered (outfile, " %02x",
631 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
636 fprintf_filtered (outfile, "static at ");
637 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
638 if (SYMBOL_BFD_SECTION (symbol))
639 fprintf_filtered (outfile, " section %s",
641 (SYMBOL_BFD_SECTION (symbol)->owner,
642 SYMBOL_BFD_SECTION (symbol)));
646 fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
650 fprintf_filtered (outfile, "arg at offset 0x%lx",
651 SYMBOL_VALUE (symbol));
655 fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
659 fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
662 case LOC_REGPARM_ADDR:
663 fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
667 fprintf_filtered (outfile, "local at offset 0x%lx",
668 SYMBOL_VALUE (symbol));
675 fprintf_filtered (outfile, "label at ");
676 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
677 if (SYMBOL_BFD_SECTION (symbol))
678 fprintf_filtered (outfile, " section %s",
680 (SYMBOL_BFD_SECTION (symbol)->owner,
681 SYMBOL_BFD_SECTION (symbol)));
685 fprintf_filtered (outfile, "block object ");
686 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
687 fprintf_filtered (outfile, ", ");
688 fputs_filtered (paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
690 fprintf_filtered (outfile, "..");
691 fputs_filtered (paddress (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
693 if (SYMBOL_BFD_SECTION (symbol))
694 fprintf_filtered (outfile, " section %s",
696 (SYMBOL_BFD_SECTION (symbol)->owner,
697 SYMBOL_BFD_SECTION (symbol)));
701 case LOC_COMPUTED_ARG:
702 fprintf_filtered (outfile, "computed at runtime");
706 fprintf_filtered (outfile, "unresolved");
709 case LOC_OPTIMIZED_OUT:
710 fprintf_filtered (outfile, "optimized out");
714 fprintf_filtered (outfile, "botched symbol class %x",
715 SYMBOL_CLASS (symbol));
719 fprintf_filtered (outfile, "\n");
724 maintenance_print_psymbols (char *args, int from_tty)
727 struct ui_file *outfile;
728 struct cleanup *cleanups;
729 char *symname = NULL;
730 char *filename = DEV_TTY;
731 struct objfile *objfile;
732 struct partial_symtab *ps;
738 error (_("print-psymbols takes an output file name and optional symbol file name"));
740 else if ((argv = buildargv (args)) == NULL)
744 cleanups = make_cleanup_freeargv (argv);
749 /* If a second arg is supplied, it is a source file name to match on */
756 filename = tilde_expand (filename);
757 make_cleanup (xfree, filename);
759 outfile = gdb_fopen (filename, FOPEN_WT);
761 perror_with_name (filename);
762 make_cleanup_ui_file_delete (outfile);
765 ALL_PSYMTABS (objfile, ps)
766 if (symname == NULL || strcmp (symname, ps->filename) == 0)
767 dump_psymtab (objfile, ps, outfile);
769 do_cleanups (cleanups);
773 print_partial_symbols (struct partial_symbol **p, int count, char *what,
774 struct ui_file *outfile)
776 fprintf_filtered (outfile, " %s partial symbols:\n", what);
779 fprintf_filtered (outfile, " `%s'", DEPRECATED_SYMBOL_NAME (*p));
780 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
782 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
784 fputs_filtered (", ", outfile);
785 switch (SYMBOL_DOMAIN (*p))
788 fputs_filtered ("undefined domain, ", outfile);
791 /* This is the usual thing -- don't print it */
794 fputs_filtered ("struct domain, ", outfile);
797 fputs_filtered ("label domain, ", outfile);
800 fputs_filtered ("<invalid domain>, ", outfile);
803 switch (SYMBOL_CLASS (*p))
806 fputs_filtered ("undefined", outfile);
809 fputs_filtered ("constant int", outfile);
812 fputs_filtered ("static", outfile);
815 fputs_filtered ("register", outfile);
818 fputs_filtered ("pass by value", outfile);
821 fputs_filtered ("pass by reference", outfile);
824 fputs_filtered ("register parameter", outfile);
826 case LOC_REGPARM_ADDR:
827 fputs_filtered ("register address parameter", outfile);
830 fputs_filtered ("stack parameter", outfile);
833 fputs_filtered ("type", outfile);
836 fputs_filtered ("label", outfile);
839 fputs_filtered ("function", outfile);
841 case LOC_CONST_BYTES:
842 fputs_filtered ("constant bytes", outfile);
845 fputs_filtered ("unresolved", outfile);
847 case LOC_OPTIMIZED_OUT:
848 fputs_filtered ("optimized out", outfile);
851 case LOC_COMPUTED_ARG:
852 fputs_filtered ("computed at runtime", outfile);
855 fputs_filtered ("<invalid location>", outfile);
858 fputs_filtered (", ", outfile);
859 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (*p)), outfile);
860 fprintf_filtered (outfile, "\n");
866 maintenance_print_msymbols (char *args, int from_tty)
869 struct ui_file *outfile;
870 struct cleanup *cleanups;
871 char *filename = DEV_TTY;
872 char *symname = NULL;
873 struct objfile *objfile;
875 struct stat sym_st, obj_st;
881 error (_("print-msymbols takes an output file name and optional symbol file name"));
883 else if ((argv = buildargv (args)) == NULL)
887 cleanups = make_cleanup_freeargv (argv);
892 /* If a second arg is supplied, it is a source file name to match on */
895 symname = xfullpath (argv[1]);
896 make_cleanup (xfree, symname);
897 if (symname && stat (symname, &sym_st))
898 perror_with_name (symname);
902 filename = tilde_expand (filename);
903 make_cleanup (xfree, filename);
905 outfile = gdb_fopen (filename, FOPEN_WT);
907 perror_with_name (filename);
908 make_cleanup_ui_file_delete (outfile);
911 ALL_OBJFILES (objfile)
913 || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
914 dump_msymbols (objfile, outfile);
916 fprintf_filtered (outfile, "\n\n");
917 do_cleanups (cleanups);
921 maintenance_print_objfiles (char *ignore, int from_tty)
923 struct objfile *objfile;
928 ALL_OBJFILES (objfile)
929 dump_objfile (objfile);
934 /* List all the symbol tables whose names match REGEXP (optional). */
936 maintenance_info_symtabs (char *regexp, int from_tty)
938 struct objfile *objfile;
943 ALL_OBJFILES (objfile)
945 struct symtab *symtab;
947 /* We don't want to print anything for this objfile until we
948 actually find a symtab whose name matches. */
949 int printed_objfile_start = 0;
951 ALL_OBJFILE_SYMTABS (objfile, symtab)
953 || re_exec (symtab->filename))
955 if (! printed_objfile_start)
957 printf_filtered ("{ objfile %s ", objfile->name);
959 printf_filtered ("((struct objfile *) %p)\n", objfile);
960 printed_objfile_start = 1;
963 printf_filtered (" { symtab %s ", symtab->filename);
965 printf_filtered ("((struct symtab *) %p)\n", symtab);
966 printf_filtered (" dirname %s\n",
967 symtab->dirname ? symtab->dirname : "(null)");
968 printf_filtered (" fullname %s\n",
969 symtab->fullname ? symtab->fullname : "(null)");
970 printf_filtered (" blockvector ((struct blockvector *) %p)%s\n",
972 symtab->primary ? " (primary)" : "");
973 printf_filtered (" linetable ((struct linetable *) %p)\n",
975 printf_filtered (" debugformat %s\n", symtab->debugformat);
976 printf_filtered (" }\n");
979 if (printed_objfile_start)
980 printf_filtered ("}\n");
985 /* List all the partial symbol tables whose names match REGEXP (optional). */
987 maintenance_info_psymtabs (char *regexp, int from_tty)
989 struct objfile *objfile;
994 ALL_OBJFILES (objfile)
996 struct partial_symtab *psymtab;
998 /* We don't want to print anything for this objfile until we
999 actually find a symtab whose name matches. */
1000 int printed_objfile_start = 0;
1002 ALL_OBJFILE_PSYMTABS (objfile, psymtab)
1004 || re_exec (psymtab->filename))
1006 if (! printed_objfile_start)
1008 printf_filtered ("{ objfile %s ", objfile->name);
1010 printf_filtered ("((struct objfile *) %p)\n", objfile);
1011 printed_objfile_start = 1;
1014 printf_filtered (" { psymtab %s ", psymtab->filename);
1016 printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
1017 printf_filtered (" readin %s\n",
1018 psymtab->readin ? "yes" : "no");
1019 printf_filtered (" fullname %s\n",
1020 psymtab->fullname ? psymtab->fullname : "(null)");
1021 printf_filtered (" text addresses ");
1022 fputs_filtered (paddress (psymtab->textlow), gdb_stdout);
1023 printf_filtered (" -- ");
1024 fputs_filtered (paddress (psymtab->texthigh), gdb_stdout);
1025 printf_filtered ("\n");
1026 printf_filtered (" globals ");
1027 if (psymtab->n_global_syms)
1029 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1030 (psymtab->objfile->global_psymbols.list
1031 + psymtab->globals_offset),
1032 psymtab->n_global_syms);
1035 printf_filtered ("(none)\n");
1036 printf_filtered (" statics ");
1037 if (psymtab->n_static_syms)
1039 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1040 (psymtab->objfile->static_psymbols.list
1041 + psymtab->statics_offset),
1042 psymtab->n_static_syms);
1045 printf_filtered ("(none)\n");
1046 printf_filtered (" dependencies ");
1047 if (psymtab->number_of_dependencies)
1051 printf_filtered ("{\n");
1052 for (i = 0; i < psymtab->number_of_dependencies; i++)
1054 struct partial_symtab *dep = psymtab->dependencies[i];
1056 /* Note the string concatenation there --- no comma. */
1057 printf_filtered (" psymtab %s "
1058 "((struct partial_symtab *) %p)\n",
1059 dep->filename, dep);
1061 printf_filtered (" }\n");
1064 printf_filtered ("(none)\n");
1065 printf_filtered (" }\n");
1068 if (printed_objfile_start)
1069 printf_filtered ("}\n");
1074 /* Check consistency of psymtabs and symtabs. */
1077 maintenance_check_symtabs (char *ignore, int from_tty)
1080 struct partial_symbol **psym;
1081 struct symtab *s = NULL;
1082 struct partial_symtab *ps;
1083 struct blockvector *bv;
1084 struct objfile *objfile;
1088 ALL_PSYMTABS (objfile, ps)
1090 s = PSYMTAB_TO_SYMTAB (ps);
1093 bv = BLOCKVECTOR (s);
1094 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1095 psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1096 length = ps->n_static_syms;
1099 sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1100 NULL, SYMBOL_DOMAIN (*psym));
1103 printf_filtered ("Static symbol `");
1104 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1105 printf_filtered ("' only found in ");
1106 puts_filtered (ps->filename);
1107 printf_filtered (" psymtab\n");
1111 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1112 psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1113 length = ps->n_global_syms;
1116 sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1117 NULL, SYMBOL_DOMAIN (*psym));
1120 printf_filtered ("Global symbol `");
1121 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1122 printf_filtered ("' only found in ");
1123 puts_filtered (ps->filename);
1124 printf_filtered (" psymtab\n");
1128 if (ps->texthigh < ps->textlow)
1130 printf_filtered ("Psymtab ");
1131 puts_filtered (ps->filename);
1132 printf_filtered (" covers bad range ");
1133 fputs_filtered (paddress (ps->textlow), gdb_stdout);
1134 printf_filtered (" - ");
1135 fputs_filtered (paddress (ps->texthigh), gdb_stdout);
1136 printf_filtered ("\n");
1139 if (ps->texthigh == 0)
1141 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1143 printf_filtered ("Psymtab ");
1144 puts_filtered (ps->filename);
1145 printf_filtered (" covers ");
1146 fputs_filtered (paddress (ps->textlow), gdb_stdout);
1147 printf_filtered (" - ");
1148 fputs_filtered (paddress (ps->texthigh), gdb_stdout);
1149 printf_filtered (" but symtab covers only ");
1150 fputs_filtered (paddress (BLOCK_START (b)), gdb_stdout);
1151 printf_filtered (" - ");
1152 fputs_filtered (paddress (BLOCK_END (b)), gdb_stdout);
1153 printf_filtered ("\n");
1159 /* Return the nexting depth of a block within other blocks in its symtab. */
1162 block_depth (struct block *block)
1165 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1173 /* Increase the space allocated for LISTP, which is probably
1174 global_psymbols or static_psymbols. This space will eventually
1175 be freed in free_objfile(). */
1178 extend_psymbol_list (struct psymbol_allocation_list *listp,
1179 struct objfile *objfile)
1182 if (listp->size == 0)
1185 listp->list = (struct partial_symbol **)
1186 xmalloc (new_size * sizeof (struct partial_symbol *));
1190 new_size = listp->size * 2;
1191 listp->list = (struct partial_symbol **)
1192 xrealloc ((char *) listp->list,
1193 new_size * sizeof (struct partial_symbol *));
1195 /* Next assumes we only went one over. Should be good if
1196 program works correctly */
1197 listp->next = listp->list + listp->size;
1198 listp->size = new_size;
1202 /* Do early runtime initializations. */
1204 _initialize_symmisc (void)