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
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 static void free_symtab_block (struct objfile *, struct block *);
75 void _initialize_symmisc (void);
77 struct print_symbol_args
79 struct symbol *symbol;
81 struct ui_file *outfile;
84 static int print_symbol (void *);
86 static void free_symtab_block (struct objfile *, struct block *);
89 /* Free a struct block <- B and all the symbols defined in that block. */
91 /* FIXME: carlton/2003-04-28: I don't believe this is currently ever
95 free_symtab_block (struct objfile *objfile, struct block *b)
97 struct dict_iterator iter;
100 ALL_BLOCK_SYMBOLS (b, iter, sym)
102 xfree (DEPRECATED_SYMBOL_NAME (sym));
106 dict_free (BLOCK_DICT (b));
110 /* Free all the storage associated with the struct symtab <- S.
111 Note that some symtabs have contents malloc'ed structure by structure,
112 while some have contents that all live inside one big block of memory,
113 and some share the contents of another symbol table and so you should
114 not free the contents on their behalf (except sometimes the linetable,
115 which maybe per symtab even when the rest is not).
116 It is s->free_code that says which alternative to use. */
119 free_symtab (struct symtab *s)
122 struct blockvector *bv;
124 switch (s->free_code)
127 /* All the contents are part of a big block of memory (an obstack),
128 and some other symtab is in charge of freeing that block.
129 Therefore, do nothing. */
133 /* Here all the contents were malloc'ed structure by structure
134 and must be freed that way. */
135 /* First free the blocks (and their symbols. */
136 bv = BLOCKVECTOR (s);
137 n = BLOCKVECTOR_NBLOCKS (bv);
138 for (i = 0; i < n; i++)
139 free_symtab_block (s->objfile, BLOCKVECTOR_BLOCK (bv, i));
140 /* Free the blockvector itself. */
142 /* Also free the linetable. */
145 /* Everything will be freed either by our `free_func'
146 or by some other symtab, except for our linetable.
149 xfree (LINETABLE (s));
153 /* If there is a single block of memory to free, free it. */
154 if (s->free_func != NULL)
157 /* Free source-related stuff */
158 if (s->line_charpos != NULL)
159 xfree (s->line_charpos);
160 if (s->fullname != NULL)
162 if (s->debugformat != NULL)
163 xfree (s->debugformat);
168 print_symbol_bcache_statistics (void)
170 struct objfile *objfile;
173 ALL_OBJFILES (objfile)
175 printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
176 print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
182 print_objfile_statistics (void)
184 struct objfile *objfile;
186 struct partial_symtab *ps;
187 int i, linetables, blockvectors;
190 ALL_OBJFILES (objfile)
192 printf_filtered (_("Statistics for '%s':\n"), objfile->name);
193 if (OBJSTAT (objfile, n_stabs) > 0)
194 printf_filtered (_(" Number of \"stab\" symbols read: %d\n"),
195 OBJSTAT (objfile, n_stabs));
196 if (OBJSTAT (objfile, n_minsyms) > 0)
197 printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"),
198 OBJSTAT (objfile, n_minsyms));
199 if (OBJSTAT (objfile, n_psyms) > 0)
200 printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
201 OBJSTAT (objfile, n_psyms));
202 if (OBJSTAT (objfile, n_syms) > 0)
203 printf_filtered (_(" Number of \"full\" symbols read: %d\n"),
204 OBJSTAT (objfile, n_syms));
205 if (OBJSTAT (objfile, n_types) > 0)
206 printf_filtered (_(" Number of \"types\" defined: %d\n"),
207 OBJSTAT (objfile, n_types));
209 ALL_OBJFILE_PSYMTABS (objfile, ps)
214 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
215 i = linetables = blockvectors = 0;
216 ALL_OBJFILE_SYMTABS (objfile, s)
219 if (s->linetable != NULL)
224 printf_filtered (_(" Number of symbol tables: %d\n"), i);
225 printf_filtered (_(" Number of symbol tables with line tables: %d\n"),
227 printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"),
230 if (OBJSTAT (objfile, sz_strtab) > 0)
231 printf_filtered (_(" Space used by a.out string tables: %d\n"),
232 OBJSTAT (objfile, sz_strtab));
233 printf_filtered (_(" Total memory used for objfile obstack: %d\n"),
234 obstack_memory_used (&objfile->objfile_obstack));
235 printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
236 bcache_memory_used (objfile->psymbol_cache));
237 printf_filtered (_(" Total memory used for macro cache: %d\n"),
238 bcache_memory_used (objfile->macro_cache));
244 dump_objfile (struct objfile *objfile)
246 struct symtab *symtab;
247 struct partial_symtab *psymtab;
249 printf_filtered ("\nObject file %s: ", objfile->name);
250 printf_filtered ("Objfile at ");
251 gdb_print_host_address (objfile, gdb_stdout);
252 printf_filtered (", bfd at ");
253 gdb_print_host_address (objfile->obfd, gdb_stdout);
254 printf_filtered (", %d minsyms\n\n",
255 objfile->minimal_symbol_count);
257 if (objfile->psymtabs)
259 printf_filtered ("Psymtabs:\n");
260 for (psymtab = objfile->psymtabs;
262 psymtab = psymtab->next)
264 printf_filtered ("%s at ",
266 gdb_print_host_address (psymtab, gdb_stdout);
267 printf_filtered (", ");
268 if (psymtab->objfile != objfile)
270 printf_filtered ("NOT ON CHAIN! ");
274 printf_filtered ("\n\n");
277 if (objfile->symtabs)
279 printf_filtered ("Symtabs:\n");
280 for (symtab = objfile->symtabs;
282 symtab = symtab->next)
284 printf_filtered ("%s at ", symtab->filename);
285 gdb_print_host_address (symtab, gdb_stdout);
286 printf_filtered (", ");
287 if (symtab->objfile != objfile)
289 printf_filtered ("NOT ON CHAIN! ");
293 printf_filtered ("\n\n");
297 /* Print minimal symbols from this objfile. */
300 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
302 struct minimal_symbol *msymbol;
306 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
307 if (objfile->minimal_symbol_count == 0)
309 fprintf_filtered (outfile, "No minimal symbols found.\n");
312 for (index = 0, msymbol = objfile->msymbols;
313 DEPRECATED_SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
315 switch (msymbol->type)
323 case mst_solib_trampoline:
348 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
349 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1, outfile);
350 fprintf_filtered (outfile, " %s", DEPRECATED_SYMBOL_NAME (msymbol));
351 if (SYMBOL_BFD_SECTION (msymbol))
352 fprintf_filtered (outfile, " section %s",
353 bfd_section_name (objfile->obfd,
354 SYMBOL_BFD_SECTION (msymbol)));
355 if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
357 fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol));
359 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
360 if (msymbol->filename)
361 fprintf_filtered (outfile, " %s", msymbol->filename);
363 fputs_filtered ("\n", outfile);
365 if (objfile->minimal_symbol_count != index)
367 warning (_("internal error: minimal symbol count %d != %d"),
368 objfile->minimal_symbol_count, index);
370 fprintf_filtered (outfile, "\n");
374 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
375 struct ui_file *outfile)
379 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
381 fprintf_filtered (outfile, "(object ");
382 gdb_print_host_address (psymtab, outfile);
383 fprintf_filtered (outfile, ")\n\n");
384 fprintf_unfiltered (outfile, " Read from object file %s (",
386 gdb_print_host_address (objfile, outfile);
387 fprintf_unfiltered (outfile, ")\n");
391 fprintf_filtered (outfile,
392 " Full symtab was read (at ");
393 gdb_print_host_address (psymtab->symtab, outfile);
394 fprintf_filtered (outfile, " by function at ");
395 gdb_print_host_address (psymtab->read_symtab, outfile);
396 fprintf_filtered (outfile, ")\n");
399 fprintf_filtered (outfile, " Relocate symbols by ");
400 for (i = 0; i < psymtab->objfile->num_sections; ++i)
403 fprintf_filtered (outfile, ", ");
405 deprecated_print_address_numeric (ANOFFSET (psymtab->section_offsets, i),
409 fprintf_filtered (outfile, "\n");
411 fprintf_filtered (outfile, " Symbols cover text addresses ");
412 deprecated_print_address_numeric (psymtab->textlow, 1, outfile);
413 fprintf_filtered (outfile, "-");
414 deprecated_print_address_numeric (psymtab->texthigh, 1, outfile);
415 fprintf_filtered (outfile, "\n");
416 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
417 psymtab->number_of_dependencies);
418 for (i = 0; i < psymtab->number_of_dependencies; i++)
420 fprintf_filtered (outfile, " %d ", i);
421 gdb_print_host_address (psymtab->dependencies[i], outfile);
422 fprintf_filtered (outfile, " %s\n",
423 psymtab->dependencies[i]->filename);
425 if (psymtab->n_global_syms > 0)
427 print_partial_symbols (objfile->global_psymbols.list
428 + psymtab->globals_offset,
429 psymtab->n_global_syms, "Global", outfile);
431 if (psymtab->n_static_syms > 0)
433 print_partial_symbols (objfile->static_psymbols.list
434 + psymtab->statics_offset,
435 psymtab->n_static_syms, "Static", outfile);
437 fprintf_filtered (outfile, "\n");
441 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
442 struct ui_file *outfile)
445 struct dict_iterator iter;
448 struct blockvector *bv;
453 fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
455 fprintf_filtered (outfile, "Compilation directory is %s\n",
457 fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
458 gdb_print_host_address (objfile, outfile);
459 fprintf_filtered (outfile, ")\n");
460 fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
462 /* First print the line table. */
463 l = LINETABLE (symtab);
466 fprintf_filtered (outfile, "\nLine table:\n\n");
468 for (i = 0; i < len; i++)
470 fprintf_filtered (outfile, " line %d at ", l->item[i].line);
471 deprecated_print_address_numeric (l->item[i].pc, 1, outfile);
472 fprintf_filtered (outfile, "\n");
475 /* Now print the block info, but only for primary symtabs since we will
476 print lots of duplicate info otherwise. */
479 fprintf_filtered (outfile, "\nBlockvector:\n\n");
480 bv = BLOCKVECTOR (symtab);
481 len = BLOCKVECTOR_NBLOCKS (bv);
482 for (i = 0; i < len; i++)
484 b = BLOCKVECTOR_BLOCK (bv, i);
485 depth = block_depth (b) * 2;
486 print_spaces (depth, outfile);
487 fprintf_filtered (outfile, "block #%03d, object at ", i);
488 gdb_print_host_address (b, outfile);
489 if (BLOCK_SUPERBLOCK (b))
491 fprintf_filtered (outfile, " under ");
492 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
494 /* drow/2002-07-10: We could save the total symbols count
495 even if we're using a hashtable, but nothing else but this message
497 fprintf_filtered (outfile, ", %d syms/buckets in ",
498 dict_size (BLOCK_DICT (b)));
499 deprecated_print_address_numeric (BLOCK_START (b), 1, outfile);
500 fprintf_filtered (outfile, "..");
501 deprecated_print_address_numeric (BLOCK_END (b), 1, outfile);
502 if (BLOCK_FUNCTION (b))
504 fprintf_filtered (outfile, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b)));
505 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
507 fprintf_filtered (outfile, ", %s",
508 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
511 fprintf_filtered (outfile, "\n");
512 /* Now print each symbol in this block (in no particular order, if
513 we're using a hashtable). */
514 ALL_BLOCK_SYMBOLS (b, iter, sym)
516 struct print_symbol_args s;
520 catch_errors (print_symbol, &s, "Error printing symbol:\n",
524 fprintf_filtered (outfile, "\n");
528 fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
533 dump_symtab (struct objfile *objfile, struct symtab *symtab,
534 struct ui_file *outfile)
536 enum language saved_lang;
538 /* Set the current language to the language of the symtab we're dumping
539 because certain routines used during dump_symtab() use the current
540 language to print an image of the symbol. We'll restore it later. */
541 saved_lang = set_language (symtab->language);
543 dump_symtab_1 (objfile, symtab, outfile);
545 set_language (saved_lang);
549 maintenance_print_symbols (char *args, int from_tty)
552 struct ui_file *outfile;
553 struct cleanup *cleanups;
554 char *symname = NULL;
555 char *filename = DEV_TTY;
556 struct objfile *objfile;
564 Arguments missing: an output file name and an optional symbol file name"));
566 else if ((argv = buildargv (args)) == NULL)
570 cleanups = make_cleanup_freeargv (argv);
575 /* If a second arg is supplied, it is a source file name to match on */
582 filename = tilde_expand (filename);
583 make_cleanup (xfree, filename);
585 outfile = gdb_fopen (filename, FOPEN_WT);
587 perror_with_name (filename);
588 make_cleanup_ui_file_delete (outfile);
591 ALL_SYMTABS (objfile, s)
592 if (symname == NULL || strcmp (symname, s->filename) == 0)
593 dump_symtab (objfile, s, outfile);
595 do_cleanups (cleanups);
598 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
599 far to indent. ARGS is really a struct print_symbol_args *, but is
600 declared as char * to get it past catch_errors. Returns 0 for error,
604 print_symbol (void *args)
606 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
607 int depth = ((struct print_symbol_args *) args)->depth;
608 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
610 print_spaces (depth, outfile);
611 if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
613 fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
614 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
615 if (SYMBOL_BFD_SECTION (symbol))
616 fprintf_filtered (outfile, " section %s\n",
617 bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
618 SYMBOL_BFD_SECTION (symbol)));
620 fprintf_filtered (outfile, "\n");
623 if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
625 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
627 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
631 fprintf_filtered (outfile, "%s %s = ",
632 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
634 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
635 ? "struct" : "union")),
636 DEPRECATED_SYMBOL_NAME (symbol));
637 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
639 fprintf_filtered (outfile, ";\n");
643 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
644 fprintf_filtered (outfile, "typedef ");
645 if (SYMBOL_TYPE (symbol))
647 /* Print details of types, except for enums where it's clutter. */
648 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
650 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
652 fprintf_filtered (outfile, "; ");
655 fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
657 switch (SYMBOL_CLASS (symbol))
660 fprintf_filtered (outfile, "const %ld (0x%lx)",
661 SYMBOL_VALUE (symbol),
662 SYMBOL_VALUE (symbol));
665 case LOC_CONST_BYTES:
668 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
669 fprintf_filtered (outfile, "const %u hex bytes:",
671 for (i = 0; i < TYPE_LENGTH (type); i++)
672 fprintf_filtered (outfile, " %02x",
673 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
678 fprintf_filtered (outfile, "static at ");
679 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
680 if (SYMBOL_BFD_SECTION (symbol))
681 fprintf_filtered (outfile, " section %s",
683 (SYMBOL_BFD_SECTION (symbol)->owner,
684 SYMBOL_BFD_SECTION (symbol)));
688 fprintf_filtered (outfile, "extern global at *(");
689 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
690 fprintf_filtered (outfile, "),");
694 fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
698 fprintf_filtered (outfile, "arg at offset 0x%lx",
699 SYMBOL_VALUE (symbol));
703 fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
704 SYMBOL_VALUE (symbol));
708 fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
712 fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
715 case LOC_REGPARM_ADDR:
716 fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
720 fprintf_filtered (outfile, "local at offset 0x%lx",
721 SYMBOL_VALUE (symbol));
725 fprintf_filtered (outfile, "local at 0x%lx from register %d",
726 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
729 case LOC_BASEREG_ARG:
730 fprintf_filtered (outfile, "arg at 0x%lx from register %d",
731 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
738 fprintf_filtered (outfile, "label at ");
739 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
740 if (SYMBOL_BFD_SECTION (symbol))
741 fprintf_filtered (outfile, " section %s",
743 (SYMBOL_BFD_SECTION (symbol)->owner,
744 SYMBOL_BFD_SECTION (symbol)));
748 fprintf_filtered (outfile, "block object ");
749 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
750 fprintf_filtered (outfile, ", ");
751 deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
754 fprintf_filtered (outfile, "..");
755 deprecated_print_address_numeric (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol)),
758 if (SYMBOL_BFD_SECTION (symbol))
759 fprintf_filtered (outfile, " section %s",
761 (SYMBOL_BFD_SECTION (symbol)->owner,
762 SYMBOL_BFD_SECTION (symbol)));
766 case LOC_COMPUTED_ARG:
767 fprintf_filtered (outfile, "computed at runtime");
771 fprintf_filtered (outfile, "unresolved");
774 case LOC_OPTIMIZED_OUT:
775 fprintf_filtered (outfile, "optimized out");
779 fprintf_filtered (outfile, "botched symbol class %x",
780 SYMBOL_CLASS (symbol));
784 fprintf_filtered (outfile, "\n");
789 maintenance_print_psymbols (char *args, int from_tty)
792 struct ui_file *outfile;
793 struct cleanup *cleanups;
794 char *symname = NULL;
795 char *filename = DEV_TTY;
796 struct objfile *objfile;
797 struct partial_symtab *ps;
803 error (_("print-psymbols takes an output file name and optional symbol file name"));
805 else if ((argv = buildargv (args)) == NULL)
809 cleanups = make_cleanup_freeargv (argv);
814 /* If a second arg is supplied, it is a source file name to match on */
821 filename = tilde_expand (filename);
822 make_cleanup (xfree, filename);
824 outfile = gdb_fopen (filename, FOPEN_WT);
826 perror_with_name (filename);
827 make_cleanup_ui_file_delete (outfile);
830 ALL_PSYMTABS (objfile, ps)
831 if (symname == NULL || strcmp (symname, ps->filename) == 0)
832 dump_psymtab (objfile, ps, outfile);
834 do_cleanups (cleanups);
838 print_partial_symbols (struct partial_symbol **p, int count, char *what,
839 struct ui_file *outfile)
841 fprintf_filtered (outfile, " %s partial symbols:\n", what);
844 fprintf_filtered (outfile, " `%s'", DEPRECATED_SYMBOL_NAME (*p));
845 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
847 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
849 fputs_filtered (", ", outfile);
850 switch (SYMBOL_DOMAIN (*p))
853 fputs_filtered ("undefined domain, ", outfile);
856 /* This is the usual thing -- don't print it */
859 fputs_filtered ("struct domain, ", outfile);
862 fputs_filtered ("label domain, ", outfile);
865 fputs_filtered ("<invalid domain>, ", outfile);
868 switch (SYMBOL_CLASS (*p))
871 fputs_filtered ("undefined", outfile);
874 fputs_filtered ("constant int", outfile);
877 fputs_filtered ("static", outfile);
880 fputs_filtered ("extern global", outfile);
883 fputs_filtered ("register", outfile);
886 fputs_filtered ("pass by value", outfile);
889 fputs_filtered ("pass by reference", outfile);
892 fputs_filtered ("register parameter", outfile);
894 case LOC_REGPARM_ADDR:
895 fputs_filtered ("register address parameter", outfile);
898 fputs_filtered ("stack parameter", outfile);
901 fputs_filtered ("type", outfile);
904 fputs_filtered ("label", outfile);
907 fputs_filtered ("function", outfile);
909 case LOC_CONST_BYTES:
910 fputs_filtered ("constant bytes", outfile);
913 fputs_filtered ("shuffled arg", outfile);
916 fputs_filtered ("unresolved", outfile);
918 case LOC_OPTIMIZED_OUT:
919 fputs_filtered ("optimized out", outfile);
922 case LOC_COMPUTED_ARG:
923 fputs_filtered ("computed at runtime", outfile);
926 fputs_filtered ("<invalid location>", outfile);
929 fputs_filtered (", ", outfile);
930 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (*p), 1, outfile);
931 fprintf_filtered (outfile, "\n");
937 maintenance_print_msymbols (char *args, int from_tty)
940 struct ui_file *outfile;
941 struct cleanup *cleanups;
942 char *filename = DEV_TTY;
943 char *symname = NULL;
944 struct objfile *objfile;
946 struct stat sym_st, obj_st;
952 error (_("print-msymbols takes an output file name and optional symbol file name"));
954 else if ((argv = buildargv (args)) == NULL)
958 cleanups = make_cleanup_freeargv (argv);
963 /* If a second arg is supplied, it is a source file name to match on */
966 symname = xfullpath (argv[1]);
967 make_cleanup (xfree, symname);
968 if (symname && stat (symname, &sym_st))
969 perror_with_name (symname);
973 filename = tilde_expand (filename);
974 make_cleanup (xfree, filename);
976 outfile = gdb_fopen (filename, FOPEN_WT);
978 perror_with_name (filename);
979 make_cleanup_ui_file_delete (outfile);
982 ALL_OBJFILES (objfile)
984 || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
985 dump_msymbols (objfile, outfile);
987 fprintf_filtered (outfile, "\n\n");
988 do_cleanups (cleanups);
992 maintenance_print_objfiles (char *ignore, int from_tty)
994 struct objfile *objfile;
999 ALL_OBJFILES (objfile)
1000 dump_objfile (objfile);
1005 /* List all the symbol tables whose names match REGEXP (optional). */
1007 maintenance_info_symtabs (char *regexp, int from_tty)
1009 struct objfile *objfile;
1014 ALL_OBJFILES (objfile)
1016 struct symtab *symtab;
1018 /* We don't want to print anything for this objfile until we
1019 actually find a symtab whose name matches. */
1020 int printed_objfile_start = 0;
1022 ALL_OBJFILE_SYMTABS (objfile, symtab)
1024 || re_exec (symtab->filename))
1026 if (! printed_objfile_start)
1028 printf_filtered ("{ objfile %s ", objfile->name);
1030 printf_filtered ("((struct objfile *) %p)\n", objfile);
1031 printed_objfile_start = 1;
1034 printf_filtered (" { symtab %s ", symtab->filename);
1036 printf_filtered ("((struct symtab *) %p)\n", symtab);
1037 printf_filtered (" dirname %s\n",
1038 symtab->dirname ? symtab->dirname : "(null)");
1039 printf_filtered (" fullname %s\n",
1040 symtab->fullname ? symtab->fullname : "(null)");
1041 printf_filtered (" blockvector ((struct blockvector *) %p)%s\n",
1042 symtab->blockvector,
1043 symtab->primary ? " (primary)" : "");
1044 printf_filtered (" debugformat %s\n", symtab->debugformat);
1045 printf_filtered (" }\n");
1048 if (printed_objfile_start)
1049 printf_filtered ("}\n");
1054 /* List all the partial symbol tables whose names match REGEXP (optional). */
1056 maintenance_info_psymtabs (char *regexp, int from_tty)
1058 struct objfile *objfile;
1063 ALL_OBJFILES (objfile)
1065 struct partial_symtab *psymtab;
1067 /* We don't want to print anything for this objfile until we
1068 actually find a symtab whose name matches. */
1069 int printed_objfile_start = 0;
1071 ALL_OBJFILE_PSYMTABS (objfile, psymtab)
1073 || re_exec (psymtab->filename))
1075 if (! printed_objfile_start)
1077 printf_filtered ("{ objfile %s ", objfile->name);
1079 printf_filtered ("((struct objfile *) %p)\n", objfile);
1080 printed_objfile_start = 1;
1083 printf_filtered (" { psymtab %s ", psymtab->filename);
1085 printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
1086 printf_filtered (" readin %s\n",
1087 psymtab->readin ? "yes" : "no");
1088 printf_filtered (" fullname %s\n",
1089 psymtab->fullname ? psymtab->fullname : "(null)");
1090 printf_filtered (" text addresses ");
1091 deprecated_print_address_numeric (psymtab->textlow, 1, gdb_stdout);
1092 printf_filtered (" -- ");
1093 deprecated_print_address_numeric (psymtab->texthigh, 1, gdb_stdout);
1094 printf_filtered ("\n");
1095 printf_filtered (" globals ");
1096 if (psymtab->n_global_syms)
1098 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1099 (psymtab->objfile->global_psymbols.list
1100 + psymtab->globals_offset),
1101 psymtab->n_global_syms);
1104 printf_filtered ("(none)\n");
1105 printf_filtered (" statics ");
1106 if (psymtab->n_static_syms)
1108 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1109 (psymtab->objfile->static_psymbols.list
1110 + psymtab->statics_offset),
1111 psymtab->n_static_syms);
1114 printf_filtered ("(none)\n");
1115 printf_filtered (" dependencies ");
1116 if (psymtab->number_of_dependencies)
1120 printf_filtered ("{\n");
1121 for (i = 0; i < psymtab->number_of_dependencies; i++)
1123 struct partial_symtab *dep = psymtab->dependencies[i];
1125 /* Note the string concatenation there --- no comma. */
1126 printf_filtered (" psymtab %s "
1127 "((struct partial_symtab *) %p)\n",
1128 dep->filename, dep);
1130 printf_filtered (" }\n");
1133 printf_filtered ("(none)\n");
1134 printf_filtered (" }\n");
1137 if (printed_objfile_start)
1138 printf_filtered ("}\n");
1143 /* Check consistency of psymtabs and symtabs. */
1146 maintenance_check_symtabs (char *ignore, int from_tty)
1149 struct partial_symbol **psym;
1150 struct symtab *s = NULL;
1151 struct partial_symtab *ps;
1152 struct blockvector *bv;
1153 struct objfile *objfile;
1157 ALL_PSYMTABS (objfile, ps)
1159 s = PSYMTAB_TO_SYMTAB (ps);
1162 bv = BLOCKVECTOR (s);
1163 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1164 psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1165 length = ps->n_static_syms;
1168 sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1169 NULL, SYMBOL_DOMAIN (*psym));
1172 printf_filtered ("Static symbol `");
1173 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1174 printf_filtered ("' only found in ");
1175 puts_filtered (ps->filename);
1176 printf_filtered (" psymtab\n");
1180 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1181 psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1182 length = ps->n_global_syms;
1185 sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1186 NULL, SYMBOL_DOMAIN (*psym));
1189 printf_filtered ("Global symbol `");
1190 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1191 printf_filtered ("' only found in ");
1192 puts_filtered (ps->filename);
1193 printf_filtered (" psymtab\n");
1197 if (ps->texthigh < ps->textlow)
1199 printf_filtered ("Psymtab ");
1200 puts_filtered (ps->filename);
1201 printf_filtered (" covers bad range ");
1202 deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
1203 printf_filtered (" - ");
1204 deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
1205 printf_filtered ("\n");
1208 if (ps->texthigh == 0)
1210 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1212 printf_filtered ("Psymtab ");
1213 puts_filtered (ps->filename);
1214 printf_filtered (" covers ");
1215 deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
1216 printf_filtered (" - ");
1217 deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
1218 printf_filtered (" but symtab covers only ");
1219 deprecated_print_address_numeric (BLOCK_START (b), 1, gdb_stdout);
1220 printf_filtered (" - ");
1221 deprecated_print_address_numeric (BLOCK_END (b), 1, gdb_stdout);
1222 printf_filtered ("\n");
1228 /* Return the nexting depth of a block within other blocks in its symtab. */
1231 block_depth (struct block *block)
1234 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1242 /* Increase the space allocated for LISTP, which is probably
1243 global_psymbols or static_psymbols. This space will eventually
1244 be freed in free_objfile(). */
1247 extend_psymbol_list (struct psymbol_allocation_list *listp,
1248 struct objfile *objfile)
1251 if (listp->size == 0)
1254 listp->list = (struct partial_symbol **)
1255 xmalloc (new_size * sizeof (struct partial_symbol *));
1259 new_size = listp->size * 2;
1260 listp->list = (struct partial_symbol **)
1261 xrealloc ((char *) listp->list,
1262 new_size * sizeof (struct partial_symbol *));
1264 /* Next assumes we only went one over. Should be good if
1265 program works correctly */
1266 listp->next = listp->list + listp->size;
1267 listp->size = new_size;
1271 /* Do early runtime initializations. */
1273 _initialize_symmisc (void)