1 /* Do various things to symbol tables (other than lookup), for GDB.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2002 Free Software Foundation,
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 2 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, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
30 #include "breakpoint.h"
32 #include "gdb_obstack.h"
36 #include "gdb_string.h"
37 #include <readline/readline.h>
40 #define DEV_TTY "/dev/tty"
43 /* Unfortunately for debugging, stderr is usually a macro. This is painful
44 when calling functions that take FILE *'s from the debugger.
45 So we make a variable which has the same value and which is accessible when
46 debugging GDB with itself. Because stdin et al need not be constants,
47 we initialize them in the _initialize_symmisc function at the bottom
53 /* Prototypes for local functions */
55 static void dump_symtab (struct objfile *, struct symtab *,
58 static void dump_psymtab (struct objfile *, struct partial_symtab *,
61 static void dump_msymbols (struct objfile *, struct ui_file *);
63 static void dump_objfile (struct objfile *);
65 static int block_depth (struct block *);
67 static void print_partial_symbols (struct partial_symbol **, int,
68 char *, struct ui_file *);
70 static void free_symtab_block (struct objfile *, struct block *);
72 void _initialize_symmisc (void);
74 struct print_symbol_args
76 struct symbol *symbol;
78 struct ui_file *outfile;
81 static int print_symbol (void *);
83 static void free_symtab_block (struct objfile *, struct block *);
86 /* Free a struct block <- B and all the symbols defined in that block. */
89 free_symtab_block (struct objfile *objfile, struct block *b)
92 struct symbol *sym, *next_sym;
94 n = BLOCK_BUCKETS (b);
95 for (i = 0; i < n; i++)
97 for (sym = BLOCK_BUCKET (b, i); sym; sym = next_sym)
99 next_sym = sym->hash_next;
100 xmfree (objfile->md, SYMBOL_NAME (sym));
101 xmfree (objfile->md, sym);
104 xmfree (objfile->md, b);
107 /* Free all the storage associated with the struct symtab <- S.
108 Note that some symtabs have contents malloc'ed structure by structure,
109 while some have contents that all live inside one big block of memory,
110 and some share the contents of another symbol table and so you should
111 not free the contents on their behalf (except sometimes the linetable,
112 which maybe per symtab even when the rest is not).
113 It is s->free_code that says which alternative to use. */
116 free_symtab (register struct symtab *s)
119 register struct blockvector *bv;
121 switch (s->free_code)
124 /* All the contents are part of a big block of memory (an obstack),
125 and some other symtab is in charge of freeing that block.
126 Therefore, do nothing. */
130 /* Here all the contents were malloc'ed structure by structure
131 and must be freed that way. */
132 /* First free the blocks (and their symbols. */
133 bv = BLOCKVECTOR (s);
134 n = BLOCKVECTOR_NBLOCKS (bv);
135 for (i = 0; i < n; i++)
136 free_symtab_block (s->objfile, BLOCKVECTOR_BLOCK (bv, i));
137 /* Free the blockvector itself. */
138 xmfree (s->objfile->md, bv);
139 /* Also free the linetable. */
142 /* Everything will be freed either by our `free_ptr'
143 or by some other symtab, except for our linetable.
146 xmfree (s->objfile->md, LINETABLE (s));
150 /* If there is a single block of memory to free, free it. */
151 if (s->free_ptr != NULL)
152 xmfree (s->objfile->md, s->free_ptr);
154 /* Free source-related stuff */
155 if (s->line_charpos != NULL)
156 xmfree (s->objfile->md, s->line_charpos);
157 if (s->fullname != NULL)
158 xmfree (s->objfile->md, s->fullname);
159 if (s->debugformat != NULL)
160 xmfree (s->objfile->md, s->debugformat);
161 xmfree (s->objfile->md, s);
165 print_symbol_bcache_statistics (void)
167 struct objfile *objfile;
170 ALL_OBJFILES (objfile)
172 printf_filtered ("Byte cache statistics for '%s':\n", objfile->name);
173 print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
179 print_objfile_statistics (void)
181 struct objfile *objfile;
183 struct partial_symtab *ps;
184 int i, linetables, blockvectors;
187 ALL_OBJFILES (objfile)
189 printf_filtered ("Statistics for '%s':\n", objfile->name);
190 if (OBJSTAT (objfile, n_stabs) > 0)
191 printf_filtered (" Number of \"stab\" symbols read: %d\n",
192 OBJSTAT (objfile, n_stabs));
193 if (OBJSTAT (objfile, n_minsyms) > 0)
194 printf_filtered (" Number of \"minimal\" symbols read: %d\n",
195 OBJSTAT (objfile, n_minsyms));
196 if (OBJSTAT (objfile, n_psyms) > 0)
197 printf_filtered (" Number of \"partial\" symbols read: %d\n",
198 OBJSTAT (objfile, n_psyms));
199 if (OBJSTAT (objfile, n_syms) > 0)
200 printf_filtered (" Number of \"full\" symbols read: %d\n",
201 OBJSTAT (objfile, n_syms));
202 if (OBJSTAT (objfile, n_types) > 0)
203 printf_filtered (" Number of \"types\" defined: %d\n",
204 OBJSTAT (objfile, n_types));
206 ALL_OBJFILE_PSYMTABS (objfile, ps)
211 printf_filtered (" Number of psym tables (not yet expanded): %d\n", i);
212 i = linetables = blockvectors = 0;
213 ALL_OBJFILE_SYMTABS (objfile, s)
216 if (s->linetable != NULL)
221 printf_filtered (" Number of symbol tables: %d\n", i);
222 printf_filtered (" Number of symbol tables with line tables: %d\n",
224 printf_filtered (" Number of symbol tables with blockvectors: %d\n",
227 if (OBJSTAT (objfile, sz_strtab) > 0)
228 printf_filtered (" Space used by a.out string tables: %d\n",
229 OBJSTAT (objfile, sz_strtab));
230 printf_filtered (" Total memory used for psymbol obstack: %d\n",
231 obstack_memory_used (&objfile->psymbol_obstack));
232 printf_filtered (" Total memory used for psymbol cache: %d\n",
233 bcache_memory_used (objfile->psymbol_cache));
234 printf_filtered (" Total memory used for macro cache: %d\n",
235 bcache_memory_used (objfile->macro_cache));
236 printf_filtered (" Total memory used for symbol obstack: %d\n",
237 obstack_memory_used (&objfile->symbol_obstack));
238 printf_filtered (" Total memory used for type obstack: %d\n",
239 obstack_memory_used (&objfile->type_obstack));
245 dump_objfile (struct objfile *objfile)
247 struct symtab *symtab;
248 struct partial_symtab *psymtab;
250 printf_filtered ("\nObject file %s: ", objfile->name);
251 printf_filtered ("Objfile at ");
252 gdb_print_host_address (objfile, gdb_stdout);
253 printf_filtered (", bfd at ");
254 gdb_print_host_address (objfile->obfd, gdb_stdout);
255 printf_filtered (", %d minsyms\n\n",
256 objfile->minimal_symbol_count);
258 if (objfile->psymtabs)
260 printf_filtered ("Psymtabs:\n");
261 for (psymtab = objfile->psymtabs;
263 psymtab = psymtab->next)
265 printf_filtered ("%s at ",
267 gdb_print_host_address (psymtab, gdb_stdout);
268 printf_filtered (", ");
269 if (psymtab->objfile != objfile)
271 printf_filtered ("NOT ON CHAIN! ");
275 printf_filtered ("\n\n");
278 if (objfile->symtabs)
280 printf_filtered ("Symtabs:\n");
281 for (symtab = objfile->symtabs;
283 symtab = symtab->next)
285 printf_filtered ("%s at ", symtab->filename);
286 gdb_print_host_address (symtab, gdb_stdout);
287 printf_filtered (", ");
288 if (symtab->objfile != objfile)
290 printf_filtered ("NOT ON CHAIN! ");
294 printf_filtered ("\n\n");
298 /* Print minimal symbols from this objfile. */
301 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
303 struct minimal_symbol *msymbol;
307 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
308 if (objfile->minimal_symbol_count == 0)
310 fprintf_filtered (outfile, "No minimal symbols found.\n");
313 for (index = 0, msymbol = objfile->msymbols;
314 SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
316 switch (msymbol->type)
324 case mst_solib_trampoline:
349 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
350 print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1, outfile);
351 fprintf_filtered (outfile, " %s", SYMBOL_NAME (msymbol));
352 if (SYMBOL_BFD_SECTION (msymbol))
353 fprintf_filtered (outfile, " section %s",
354 bfd_section_name (objfile->obfd,
355 SYMBOL_BFD_SECTION (msymbol)));
356 if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
358 fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol));
360 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
361 if (msymbol->filename)
362 fprintf_filtered (outfile, " %s", msymbol->filename);
364 fputs_filtered ("\n", outfile);
366 if (objfile->minimal_symbol_count != index)
368 warning ("internal error: minimal symbol count %d != %d",
369 objfile->minimal_symbol_count, index);
371 fprintf_filtered (outfile, "\n");
375 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
376 struct ui_file *outfile)
380 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
382 fprintf_filtered (outfile, "(object ");
383 gdb_print_host_address (psymtab, outfile);
384 fprintf_filtered (outfile, ")\n\n");
385 fprintf_unfiltered (outfile, " Read from object file %s (",
387 gdb_print_host_address (objfile, outfile);
388 fprintf_unfiltered (outfile, ")\n");
392 fprintf_filtered (outfile,
393 " Full symtab was read (at ");
394 gdb_print_host_address (psymtab->symtab, outfile);
395 fprintf_filtered (outfile, " by function at ");
396 gdb_print_host_address (psymtab->read_symtab, outfile);
397 fprintf_filtered (outfile, ")\n");
400 fprintf_filtered (outfile, " Relocate symbols by ");
401 for (i = 0; i < psymtab->objfile->num_sections; ++i)
404 fprintf_filtered (outfile, ", ");
406 print_address_numeric (ANOFFSET (psymtab->section_offsets, i),
410 fprintf_filtered (outfile, "\n");
412 fprintf_filtered (outfile, " Symbols cover text addresses ");
413 print_address_numeric (psymtab->textlow, 1, outfile);
414 fprintf_filtered (outfile, "-");
415 print_address_numeric (psymtab->texthigh, 1, outfile);
416 fprintf_filtered (outfile, "\n");
417 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
418 psymtab->number_of_dependencies);
419 for (i = 0; i < psymtab->number_of_dependencies; i++)
421 fprintf_filtered (outfile, " %d ", i);
422 gdb_print_host_address (psymtab->dependencies[i], outfile);
423 fprintf_filtered (outfile, " %s\n",
424 psymtab->dependencies[i]->filename);
426 if (psymtab->n_global_syms > 0)
428 print_partial_symbols (objfile->global_psymbols.list
429 + psymtab->globals_offset,
430 psymtab->n_global_syms, "Global", outfile);
432 if (psymtab->n_static_syms > 0)
434 print_partial_symbols (objfile->static_psymbols.list
435 + psymtab->statics_offset,
436 psymtab->n_static_syms, "Static", outfile);
438 fprintf_filtered (outfile, "\n");
442 dump_symtab (struct objfile *objfile, struct symtab *symtab,
443 struct ui_file *outfile)
447 register struct linetable *l;
448 struct blockvector *bv;
450 register struct block *b;
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 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 blen = BLOCK_BUCKETS (b);
498 if (BLOCK_HASHTABLE (b))
499 fprintf_filtered (outfile, ", %d buckets in ", blen);
501 fprintf_filtered (outfile, ", %d syms in ", blen);
502 print_address_numeric (BLOCK_START (b), 1, outfile);
503 fprintf_filtered (outfile, "..");
504 print_address_numeric (BLOCK_END (b), 1, outfile);
505 if (BLOCK_FUNCTION (b))
507 fprintf_filtered (outfile, ", function %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
508 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
510 fprintf_filtered (outfile, ", %s",
511 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
514 if (BLOCK_GCC_COMPILED (b))
515 fprintf_filtered (outfile, ", compiled with gcc%d", BLOCK_GCC_COMPILED (b));
516 fprintf_filtered (outfile, "\n");
517 /* Now print each symbol in this block (in no particular order, if
518 we're using a hashtable). */
519 ALL_BLOCK_SYMBOLS (b, j, sym)
521 struct print_symbol_args s;
525 catch_errors (print_symbol, &s, "Error printing symbol:\n",
529 fprintf_filtered (outfile, "\n");
533 fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
538 maintenance_print_symbols (char *args, int from_tty)
541 struct ui_file *outfile;
542 struct cleanup *cleanups;
543 char *symname = NULL;
544 char *filename = DEV_TTY;
545 struct objfile *objfile;
553 Arguments missing: an output file name and an optional symbol file name");
555 else if ((argv = buildargv (args)) == NULL)
559 cleanups = make_cleanup_freeargv (argv);
564 /* If a second arg is supplied, it is a source file name to match on */
571 filename = tilde_expand (filename);
572 make_cleanup (xfree, filename);
574 outfile = gdb_fopen (filename, FOPEN_WT);
576 perror_with_name (filename);
577 make_cleanup_ui_file_delete (outfile);
580 ALL_SYMTABS (objfile, s)
581 if (symname == NULL || (STREQ (symname, s->filename)))
582 dump_symtab (objfile, s, outfile);
584 do_cleanups (cleanups);
587 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
588 far to indent. ARGS is really a struct print_symbol_args *, but is
589 declared as char * to get it past catch_errors. Returns 0 for error,
593 print_symbol (void *args)
595 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
596 int depth = ((struct print_symbol_args *) args)->depth;
597 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
599 print_spaces (depth, outfile);
600 if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
602 fprintf_filtered (outfile, "label %s at ", SYMBOL_SOURCE_NAME (symbol));
603 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
604 if (SYMBOL_BFD_SECTION (symbol))
605 fprintf_filtered (outfile, " section %s\n",
606 bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
607 SYMBOL_BFD_SECTION (symbol)));
609 fprintf_filtered (outfile, "\n");
612 if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
614 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
616 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
620 fprintf_filtered (outfile, "%s %s = ",
621 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
623 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
624 ? "struct" : "union")),
625 SYMBOL_NAME (symbol));
626 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
628 fprintf_filtered (outfile, ";\n");
632 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
633 fprintf_filtered (outfile, "typedef ");
634 if (SYMBOL_TYPE (symbol))
636 /* Print details of types, except for enums where it's clutter. */
637 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_SOURCE_NAME (symbol),
639 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
641 fprintf_filtered (outfile, "; ");
644 fprintf_filtered (outfile, "%s ", SYMBOL_SOURCE_NAME (symbol));
646 switch (SYMBOL_CLASS (symbol))
649 fprintf_filtered (outfile, "const %ld (0x%lx)",
650 SYMBOL_VALUE (symbol),
651 SYMBOL_VALUE (symbol));
654 case LOC_CONST_BYTES:
657 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
658 fprintf_filtered (outfile, "const %u hex bytes:",
660 for (i = 0; i < TYPE_LENGTH (type); i++)
661 fprintf_filtered (outfile, " %02x",
662 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
667 fprintf_filtered (outfile, "static at ");
668 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
669 if (SYMBOL_BFD_SECTION (symbol))
670 fprintf_filtered (outfile, " section %s",
672 (SYMBOL_BFD_SECTION (symbol)->owner,
673 SYMBOL_BFD_SECTION (symbol)));
677 fprintf_filtered (outfile, "extern global at *(");
678 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
679 fprintf_filtered (outfile, "),");
683 fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
687 fprintf_filtered (outfile, "arg at offset 0x%lx",
688 SYMBOL_VALUE (symbol));
692 fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
693 SYMBOL_VALUE (symbol));
697 fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
701 fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
704 case LOC_REGPARM_ADDR:
705 fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
709 fprintf_filtered (outfile, "local at offset 0x%lx",
710 SYMBOL_VALUE (symbol));
714 fprintf_filtered (outfile, "local at 0x%lx from register %d",
715 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
718 case LOC_BASEREG_ARG:
719 fprintf_filtered (outfile, "arg at 0x%lx from register %d",
720 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
727 fprintf_filtered (outfile, "label at ");
728 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
729 if (SYMBOL_BFD_SECTION (symbol))
730 fprintf_filtered (outfile, " section %s",
732 (SYMBOL_BFD_SECTION (symbol)->owner,
733 SYMBOL_BFD_SECTION (symbol)));
737 fprintf_filtered (outfile, "block object ");
738 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
739 fprintf_filtered (outfile, ", ");
740 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
743 fprintf_filtered (outfile, "..");
744 print_address_numeric (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol)),
747 if (SYMBOL_BFD_SECTION (symbol))
748 fprintf_filtered (outfile, " section %s",
750 (SYMBOL_BFD_SECTION (symbol)->owner,
751 SYMBOL_BFD_SECTION (symbol)));
755 fprintf_filtered (outfile, "unresolved");
758 case LOC_OPTIMIZED_OUT:
759 fprintf_filtered (outfile, "optimized out");
763 fprintf_filtered (outfile, "botched symbol class %x",
764 SYMBOL_CLASS (symbol));
768 fprintf_filtered (outfile, "\n");
773 maintenance_print_psymbols (char *args, int from_tty)
776 struct ui_file *outfile;
777 struct cleanup *cleanups;
778 char *symname = NULL;
779 char *filename = DEV_TTY;
780 struct objfile *objfile;
781 struct partial_symtab *ps;
787 error ("print-psymbols takes an output file name and optional symbol file name");
789 else if ((argv = buildargv (args)) == NULL)
793 cleanups = make_cleanup_freeargv (argv);
798 /* If a second arg is supplied, it is a source file name to match on */
805 filename = tilde_expand (filename);
806 make_cleanup (xfree, filename);
808 outfile = gdb_fopen (filename, FOPEN_WT);
810 perror_with_name (filename);
811 make_cleanup_ui_file_delete (outfile);
814 ALL_PSYMTABS (objfile, ps)
815 if (symname == NULL || (STREQ (symname, ps->filename)))
816 dump_psymtab (objfile, ps, outfile);
818 do_cleanups (cleanups);
822 print_partial_symbols (struct partial_symbol **p, int count, char *what,
823 struct ui_file *outfile)
825 fprintf_filtered (outfile, " %s partial symbols:\n", what);
828 fprintf_filtered (outfile, " `%s'", SYMBOL_NAME (*p));
829 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
831 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
833 fputs_filtered (", ", outfile);
834 switch (SYMBOL_NAMESPACE (*p))
836 case UNDEF_NAMESPACE:
837 fputs_filtered ("undefined namespace, ", outfile);
840 /* This is the usual thing -- don't print it */
842 case STRUCT_NAMESPACE:
843 fputs_filtered ("struct namespace, ", outfile);
845 case LABEL_NAMESPACE:
846 fputs_filtered ("label namespace, ", outfile);
849 fputs_filtered ("<invalid namespace>, ", outfile);
852 switch (SYMBOL_CLASS (*p))
855 fputs_filtered ("undefined", outfile);
858 fputs_filtered ("constant int", outfile);
861 fputs_filtered ("static", outfile);
864 fputs_filtered ("extern global", outfile);
867 fputs_filtered ("register", outfile);
870 fputs_filtered ("pass by value", outfile);
873 fputs_filtered ("pass by reference", outfile);
876 fputs_filtered ("register parameter", outfile);
878 case LOC_REGPARM_ADDR:
879 fputs_filtered ("register address parameter", outfile);
882 fputs_filtered ("stack parameter", outfile);
885 fputs_filtered ("type", outfile);
888 fputs_filtered ("label", outfile);
891 fputs_filtered ("function", outfile);
893 case LOC_CONST_BYTES:
894 fputs_filtered ("constant bytes", outfile);
897 fputs_filtered ("shuffled arg", outfile);
900 fputs_filtered ("unresolved", outfile);
902 case LOC_OPTIMIZED_OUT:
903 fputs_filtered ("optimized out", outfile);
906 fputs_filtered ("<invalid location>", outfile);
909 fputs_filtered (", ", outfile);
910 print_address_numeric (SYMBOL_VALUE_ADDRESS (*p), 1, outfile);
911 fprintf_filtered (outfile, "\n");
917 maintenance_print_msymbols (char *args, int from_tty)
920 struct ui_file *outfile;
921 struct cleanup *cleanups;
922 char *filename = DEV_TTY;
923 char *symname = NULL;
924 struct objfile *objfile;
930 error ("print-msymbols takes an output file name and optional symbol file name");
932 else if ((argv = buildargv (args)) == NULL)
936 cleanups = make_cleanup_freeargv (argv);
941 /* If a second arg is supplied, it is a source file name to match on */
948 filename = tilde_expand (filename);
949 make_cleanup (xfree, filename);
951 outfile = gdb_fopen (filename, FOPEN_WT);
953 perror_with_name (filename);
954 make_cleanup_ui_file_delete (outfile);
957 ALL_OBJFILES (objfile)
958 if (symname == NULL || (STREQ (symname, objfile->name)))
959 dump_msymbols (objfile, outfile);
961 fprintf_filtered (outfile, "\n\n");
962 do_cleanups (cleanups);
966 maintenance_print_objfiles (char *ignore, int from_tty)
968 struct objfile *objfile;
973 ALL_OBJFILES (objfile)
974 dump_objfile (objfile);
978 /* Check consistency of psymtabs and symtabs. */
981 maintenance_check_symtabs (char *ignore, int from_tty)
983 register struct symbol *sym;
984 register struct partial_symbol **psym;
985 register struct symtab *s = NULL;
986 register struct partial_symtab *ps;
987 struct blockvector *bv;
988 register struct objfile *objfile;
989 register struct block *b;
992 ALL_PSYMTABS (objfile, ps)
994 s = PSYMTAB_TO_SYMTAB (ps);
997 bv = BLOCKVECTOR (s);
998 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
999 psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1000 length = ps->n_static_syms;
1003 sym = lookup_block_symbol (b, SYMBOL_NAME (*psym),
1004 NULL, SYMBOL_NAMESPACE (*psym));
1007 printf_filtered ("Static symbol `");
1008 puts_filtered (SYMBOL_NAME (*psym));
1009 printf_filtered ("' only found in ");
1010 puts_filtered (ps->filename);
1011 printf_filtered (" psymtab\n");
1015 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1016 psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1017 length = ps->n_global_syms;
1020 sym = lookup_block_symbol (b, SYMBOL_NAME (*psym),
1021 NULL, SYMBOL_NAMESPACE (*psym));
1024 printf_filtered ("Global symbol `");
1025 puts_filtered (SYMBOL_NAME (*psym));
1026 printf_filtered ("' only found in ");
1027 puts_filtered (ps->filename);
1028 printf_filtered (" psymtab\n");
1032 if (ps->texthigh < ps->textlow)
1034 printf_filtered ("Psymtab ");
1035 puts_filtered (ps->filename);
1036 printf_filtered (" covers bad range ");
1037 print_address_numeric (ps->textlow, 1, gdb_stdout);
1038 printf_filtered (" - ");
1039 print_address_numeric (ps->texthigh, 1, gdb_stdout);
1040 printf_filtered ("\n");
1043 if (ps->texthigh == 0)
1045 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1047 printf_filtered ("Psymtab ");
1048 puts_filtered (ps->filename);
1049 printf_filtered (" covers ");
1050 print_address_numeric (ps->textlow, 1, gdb_stdout);
1051 printf_filtered (" - ");
1052 print_address_numeric (ps->texthigh, 1, gdb_stdout);
1053 printf_filtered (" but symtab covers only ");
1054 print_address_numeric (BLOCK_START (b), 1, gdb_stdout);
1055 printf_filtered (" - ");
1056 print_address_numeric (BLOCK_END (b), 1, gdb_stdout);
1057 printf_filtered ("\n");
1063 /* Return the nexting depth of a block within other blocks in its symtab. */
1066 block_depth (struct block *block)
1069 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1077 /* Increase the space allocated for LISTP, which is probably
1078 global_psymbols or static_psymbols. This space will eventually
1079 be freed in free_objfile(). */
1082 extend_psymbol_list (register struct psymbol_allocation_list *listp,
1083 struct objfile *objfile)
1086 if (listp->size == 0)
1089 listp->list = (struct partial_symbol **)
1090 xmmalloc (objfile->md, new_size * sizeof (struct partial_symbol *));
1094 new_size = listp->size * 2;
1095 listp->list = (struct partial_symbol **)
1096 xmrealloc (objfile->md, (char *) listp->list,
1097 new_size * sizeof (struct partial_symbol *));
1099 /* Next assumes we only went one over. Should be good if
1100 program works correctly */
1101 listp->next = listp->list + listp->size;
1102 listp->size = new_size;
1106 /* Do early runtime initializations. */
1108 _initialize_symmisc (void)