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 (PTR);
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, (PTR) sym);
104 xmfree (objfile->md, (PTR) 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, (PTR) 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, (PTR) 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, (PTR) 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, (PTR) 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;
184 ALL_OBJFILES (objfile)
186 printf_filtered ("Statistics for '%s':\n", objfile->name);
187 if (OBJSTAT (objfile, n_stabs) > 0)
188 printf_filtered (" Number of \"stab\" symbols read: %d\n",
189 OBJSTAT (objfile, n_stabs));
190 if (OBJSTAT (objfile, n_minsyms) > 0)
191 printf_filtered (" Number of \"minimal\" symbols read: %d\n",
192 OBJSTAT (objfile, n_minsyms));
193 if (OBJSTAT (objfile, n_psyms) > 0)
194 printf_filtered (" Number of \"partial\" symbols read: %d\n",
195 OBJSTAT (objfile, n_psyms));
196 if (OBJSTAT (objfile, n_syms) > 0)
197 printf_filtered (" Number of \"full\" symbols read: %d\n",
198 OBJSTAT (objfile, n_syms));
199 if (OBJSTAT (objfile, n_types) > 0)
200 printf_filtered (" Number of \"types\" defined: %d\n",
201 OBJSTAT (objfile, n_types));
202 if (OBJSTAT (objfile, sz_strtab) > 0)
203 printf_filtered (" Space used by a.out string tables: %d\n",
204 OBJSTAT (objfile, sz_strtab));
205 printf_filtered (" Total memory used for psymbol obstack: %d\n",
206 obstack_memory_used (&objfile->psymbol_obstack));
207 printf_filtered (" Total memory used for psymbol cache: %d\n",
208 bcache_memory_used (objfile->psymbol_cache));
209 printf_filtered (" Total memory used for macro cache: %d\n",
210 bcache_memory_used (objfile->macro_cache));
211 printf_filtered (" Total memory used for symbol obstack: %d\n",
212 obstack_memory_used (&objfile->symbol_obstack));
213 printf_filtered (" Total memory used for type obstack: %d\n",
214 obstack_memory_used (&objfile->type_obstack));
220 dump_objfile (struct objfile *objfile)
222 struct symtab *symtab;
223 struct partial_symtab *psymtab;
225 printf_filtered ("\nObject file %s: ", objfile->name);
226 printf_filtered ("Objfile at ");
227 gdb_print_host_address (objfile, gdb_stdout);
228 printf_filtered (", bfd at ");
229 gdb_print_host_address (objfile->obfd, gdb_stdout);
230 printf_filtered (", %d minsyms\n\n",
231 objfile->minimal_symbol_count);
233 if (objfile->psymtabs)
235 printf_filtered ("Psymtabs:\n");
236 for (psymtab = objfile->psymtabs;
238 psymtab = psymtab->next)
240 printf_filtered ("%s at ",
242 gdb_print_host_address (psymtab, gdb_stdout);
243 printf_filtered (", ");
244 if (psymtab->objfile != objfile)
246 printf_filtered ("NOT ON CHAIN! ");
250 printf_filtered ("\n\n");
253 if (objfile->symtabs)
255 printf_filtered ("Symtabs:\n");
256 for (symtab = objfile->symtabs;
258 symtab = symtab->next)
260 printf_filtered ("%s at ", symtab->filename);
261 gdb_print_host_address (symtab, gdb_stdout);
262 printf_filtered (", ");
263 if (symtab->objfile != objfile)
265 printf_filtered ("NOT ON CHAIN! ");
269 printf_filtered ("\n\n");
273 /* Print minimal symbols from this objfile. */
276 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
278 struct minimal_symbol *msymbol;
282 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
283 if (objfile->minimal_symbol_count == 0)
285 fprintf_filtered (outfile, "No minimal symbols found.\n");
288 for (index = 0, msymbol = objfile->msymbols;
289 SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
291 switch (msymbol->type)
299 case mst_solib_trampoline:
324 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
325 print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1, outfile);
326 fprintf_filtered (outfile, " %s", SYMBOL_NAME (msymbol));
327 if (SYMBOL_BFD_SECTION (msymbol))
328 fprintf_filtered (outfile, " section %s",
329 bfd_section_name (objfile->obfd,
330 SYMBOL_BFD_SECTION (msymbol)));
331 if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
333 fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol));
335 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
336 if (msymbol->filename)
337 fprintf_filtered (outfile, " %s", msymbol->filename);
339 fputs_filtered ("\n", outfile);
341 if (objfile->minimal_symbol_count != index)
343 warning ("internal error: minimal symbol count %d != %d",
344 objfile->minimal_symbol_count, index);
346 fprintf_filtered (outfile, "\n");
350 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
351 struct ui_file *outfile)
355 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
357 fprintf_filtered (outfile, "(object ");
358 gdb_print_host_address (psymtab, outfile);
359 fprintf_filtered (outfile, ")\n\n");
360 fprintf_unfiltered (outfile, " Read from object file %s (",
362 gdb_print_host_address (objfile, outfile);
363 fprintf_unfiltered (outfile, ")\n");
367 fprintf_filtered (outfile,
368 " Full symtab was read (at ");
369 gdb_print_host_address (psymtab->symtab, outfile);
370 fprintf_filtered (outfile, " by function at ");
371 gdb_print_host_address ((PTR) psymtab->read_symtab, outfile);
372 fprintf_filtered (outfile, ")\n");
375 fprintf_filtered (outfile, " Relocate symbols by ");
376 for (i = 0; i < psymtab->objfile->num_sections; ++i)
379 fprintf_filtered (outfile, ", ");
381 print_address_numeric (ANOFFSET (psymtab->section_offsets, i),
385 fprintf_filtered (outfile, "\n");
387 fprintf_filtered (outfile, " Symbols cover text addresses ");
388 print_address_numeric (psymtab->textlow, 1, outfile);
389 fprintf_filtered (outfile, "-");
390 print_address_numeric (psymtab->texthigh, 1, outfile);
391 fprintf_filtered (outfile, "\n");
392 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
393 psymtab->number_of_dependencies);
394 for (i = 0; i < psymtab->number_of_dependencies; i++)
396 fprintf_filtered (outfile, " %d ", i);
397 gdb_print_host_address (psymtab->dependencies[i], outfile);
398 fprintf_filtered (outfile, " %s\n",
399 psymtab->dependencies[i]->filename);
401 if (psymtab->n_global_syms > 0)
403 print_partial_symbols (objfile->global_psymbols.list
404 + psymtab->globals_offset,
405 psymtab->n_global_syms, "Global", outfile);
407 if (psymtab->n_static_syms > 0)
409 print_partial_symbols (objfile->static_psymbols.list
410 + psymtab->statics_offset,
411 psymtab->n_static_syms, "Static", outfile);
413 fprintf_filtered (outfile, "\n");
417 dump_symtab (struct objfile *objfile, struct symtab *symtab,
418 struct ui_file *outfile)
422 register struct linetable *l;
423 struct blockvector *bv;
425 register struct block *b;
428 fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
430 fprintf_filtered (outfile, "Compilation directory is %s\n",
432 fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
433 gdb_print_host_address (objfile, outfile);
434 fprintf_filtered (outfile, ")\n");
435 fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
437 /* First print the line table. */
438 l = LINETABLE (symtab);
441 fprintf_filtered (outfile, "\nLine table:\n\n");
443 for (i = 0; i < len; i++)
445 fprintf_filtered (outfile, " line %d at ", l->item[i].line);
446 print_address_numeric (l->item[i].pc, 1, outfile);
447 fprintf_filtered (outfile, "\n");
450 /* Now print the block info, but only for primary symtabs since we will
451 print lots of duplicate info otherwise. */
454 fprintf_filtered (outfile, "\nBlockvector:\n\n");
455 bv = BLOCKVECTOR (symtab);
456 len = BLOCKVECTOR_NBLOCKS (bv);
457 for (i = 0; i < len; i++)
459 b = BLOCKVECTOR_BLOCK (bv, i);
460 depth = block_depth (b) * 2;
461 print_spaces (depth, outfile);
462 fprintf_filtered (outfile, "block #%03d, object at ", i);
463 gdb_print_host_address (b, outfile);
464 if (BLOCK_SUPERBLOCK (b))
466 fprintf_filtered (outfile, " under ");
467 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
469 /* drow/2002-07-10: We could save the total symbols count
470 even if we're using a hashtable, but nothing else but this message
472 blen = BLOCK_BUCKETS (b);
473 if (BLOCK_HASHTABLE (b))
474 fprintf_filtered (outfile, ", %d buckets in ", blen);
476 fprintf_filtered (outfile, ", %d syms in ", blen);
477 print_address_numeric (BLOCK_START (b), 1, outfile);
478 fprintf_filtered (outfile, "..");
479 print_address_numeric (BLOCK_END (b), 1, outfile);
480 if (BLOCK_FUNCTION (b))
482 fprintf_filtered (outfile, ", function %s", SYMBOL_NAME (BLOCK_FUNCTION (b)));
483 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
485 fprintf_filtered (outfile, ", %s",
486 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
489 if (BLOCK_GCC_COMPILED (b))
490 fprintf_filtered (outfile, ", compiled with gcc%d", BLOCK_GCC_COMPILED (b));
491 fprintf_filtered (outfile, "\n");
492 /* Now print each symbol in this block (in no particular order, if
493 we're using a hashtable). */
494 ALL_BLOCK_SYMBOLS (b, j, sym)
496 struct print_symbol_args s;
500 catch_errors (print_symbol, &s, "Error printing symbol:\n",
504 fprintf_filtered (outfile, "\n");
508 fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
513 maintenance_print_symbols (char *args, int from_tty)
516 struct ui_file *outfile;
517 struct cleanup *cleanups;
518 char *symname = NULL;
519 char *filename = DEV_TTY;
520 struct objfile *objfile;
528 Arguments missing: an output file name and an optional symbol file name");
530 else if ((argv = buildargv (args)) == NULL)
534 cleanups = make_cleanup_freeargv (argv);
539 /* If a second arg is supplied, it is a source file name to match on */
546 filename = tilde_expand (filename);
547 make_cleanup (xfree, filename);
549 outfile = gdb_fopen (filename, FOPEN_WT);
551 perror_with_name (filename);
552 make_cleanup_ui_file_delete (outfile);
555 ALL_SYMTABS (objfile, s)
556 if (symname == NULL || (STREQ (symname, s->filename)))
557 dump_symtab (objfile, s, outfile);
559 do_cleanups (cleanups);
562 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
563 far to indent. ARGS is really a struct print_symbol_args *, but is
564 declared as char * to get it past catch_errors. Returns 0 for error,
568 print_symbol (PTR args)
570 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
571 int depth = ((struct print_symbol_args *) args)->depth;
572 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
574 print_spaces (depth, outfile);
575 if (SYMBOL_NAMESPACE (symbol) == LABEL_NAMESPACE)
577 fprintf_filtered (outfile, "label %s at ", SYMBOL_SOURCE_NAME (symbol));
578 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
579 if (SYMBOL_BFD_SECTION (symbol))
580 fprintf_filtered (outfile, " section %s\n",
581 bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
582 SYMBOL_BFD_SECTION (symbol)));
584 fprintf_filtered (outfile, "\n");
587 if (SYMBOL_NAMESPACE (symbol) == STRUCT_NAMESPACE)
589 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
591 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
595 fprintf_filtered (outfile, "%s %s = ",
596 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
598 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
599 ? "struct" : "union")),
600 SYMBOL_NAME (symbol));
601 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
603 fprintf_filtered (outfile, ";\n");
607 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
608 fprintf_filtered (outfile, "typedef ");
609 if (SYMBOL_TYPE (symbol))
611 /* Print details of types, except for enums where it's clutter. */
612 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_SOURCE_NAME (symbol),
614 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
616 fprintf_filtered (outfile, "; ");
619 fprintf_filtered (outfile, "%s ", SYMBOL_SOURCE_NAME (symbol));
621 switch (SYMBOL_CLASS (symbol))
624 fprintf_filtered (outfile, "const %ld (0x%lx)",
625 SYMBOL_VALUE (symbol),
626 SYMBOL_VALUE (symbol));
629 case LOC_CONST_BYTES:
632 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
633 fprintf_filtered (outfile, "const %u hex bytes:",
635 for (i = 0; i < TYPE_LENGTH (type); i++)
636 fprintf_filtered (outfile, " %02x",
637 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
642 fprintf_filtered (outfile, "static at ");
643 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
644 if (SYMBOL_BFD_SECTION (symbol))
645 fprintf_filtered (outfile, " section %s",
647 (SYMBOL_BFD_SECTION (symbol)->owner,
648 SYMBOL_BFD_SECTION (symbol)));
652 fprintf_filtered (outfile, "extern global at *(");
653 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
654 fprintf_filtered (outfile, "),");
658 fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
662 fprintf_filtered (outfile, "arg at offset 0x%lx",
663 SYMBOL_VALUE (symbol));
667 fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
668 SYMBOL_VALUE (symbol));
672 fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
676 fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
679 case LOC_REGPARM_ADDR:
680 fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
684 fprintf_filtered (outfile, "local at offset 0x%lx",
685 SYMBOL_VALUE (symbol));
689 fprintf_filtered (outfile, "local at 0x%lx from register %d",
690 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
693 case LOC_BASEREG_ARG:
694 fprintf_filtered (outfile, "arg at 0x%lx from register %d",
695 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
702 fprintf_filtered (outfile, "label at ");
703 print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
704 if (SYMBOL_BFD_SECTION (symbol))
705 fprintf_filtered (outfile, " section %s",
707 (SYMBOL_BFD_SECTION (symbol)->owner,
708 SYMBOL_BFD_SECTION (symbol)));
712 fprintf_filtered (outfile, "block object ");
713 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
714 fprintf_filtered (outfile, ", ");
715 print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
718 fprintf_filtered (outfile, "..");
719 print_address_numeric (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol)),
722 if (SYMBOL_BFD_SECTION (symbol))
723 fprintf_filtered (outfile, " section %s",
725 (SYMBOL_BFD_SECTION (symbol)->owner,
726 SYMBOL_BFD_SECTION (symbol)));
730 fprintf_filtered (outfile, "unresolved");
733 case LOC_OPTIMIZED_OUT:
734 fprintf_filtered (outfile, "optimized out");
738 fprintf_filtered (outfile, "botched symbol class %x",
739 SYMBOL_CLASS (symbol));
743 fprintf_filtered (outfile, "\n");
748 maintenance_print_psymbols (char *args, int from_tty)
751 struct ui_file *outfile;
752 struct cleanup *cleanups;
753 char *symname = NULL;
754 char *filename = DEV_TTY;
755 struct objfile *objfile;
756 struct partial_symtab *ps;
762 error ("print-psymbols takes an output file name and optional symbol file name");
764 else if ((argv = buildargv (args)) == NULL)
768 cleanups = make_cleanup_freeargv (argv);
773 /* If a second arg is supplied, it is a source file name to match on */
780 filename = tilde_expand (filename);
781 make_cleanup (xfree, filename);
783 outfile = gdb_fopen (filename, FOPEN_WT);
785 perror_with_name (filename);
786 make_cleanup_ui_file_delete (outfile);
789 ALL_PSYMTABS (objfile, ps)
790 if (symname == NULL || (STREQ (symname, ps->filename)))
791 dump_psymtab (objfile, ps, outfile);
793 do_cleanups (cleanups);
797 print_partial_symbols (struct partial_symbol **p, int count, char *what,
798 struct ui_file *outfile)
800 fprintf_filtered (outfile, " %s partial symbols:\n", what);
803 fprintf_filtered (outfile, " `%s'", SYMBOL_NAME (*p));
804 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
806 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
808 fputs_filtered (", ", outfile);
809 switch (SYMBOL_NAMESPACE (*p))
811 case UNDEF_NAMESPACE:
812 fputs_filtered ("undefined namespace, ", outfile);
815 /* This is the usual thing -- don't print it */
817 case STRUCT_NAMESPACE:
818 fputs_filtered ("struct namespace, ", outfile);
820 case LABEL_NAMESPACE:
821 fputs_filtered ("label namespace, ", outfile);
824 fputs_filtered ("<invalid namespace>, ", outfile);
827 switch (SYMBOL_CLASS (*p))
830 fputs_filtered ("undefined", outfile);
833 fputs_filtered ("constant int", outfile);
836 fputs_filtered ("static", outfile);
839 fputs_filtered ("extern global", outfile);
842 fputs_filtered ("register", outfile);
845 fputs_filtered ("pass by value", outfile);
848 fputs_filtered ("pass by reference", outfile);
851 fputs_filtered ("register parameter", outfile);
853 case LOC_REGPARM_ADDR:
854 fputs_filtered ("register address parameter", outfile);
857 fputs_filtered ("stack parameter", outfile);
860 fputs_filtered ("type", outfile);
863 fputs_filtered ("label", outfile);
866 fputs_filtered ("function", outfile);
868 case LOC_CONST_BYTES:
869 fputs_filtered ("constant bytes", outfile);
872 fputs_filtered ("shuffled arg", outfile);
875 fputs_filtered ("unresolved", outfile);
877 case LOC_OPTIMIZED_OUT:
878 fputs_filtered ("optimized out", outfile);
881 fputs_filtered ("<invalid location>", outfile);
884 fputs_filtered (", ", outfile);
885 print_address_numeric (SYMBOL_VALUE_ADDRESS (*p), 1, outfile);
886 fprintf_filtered (outfile, "\n");
892 maintenance_print_msymbols (char *args, int from_tty)
895 struct ui_file *outfile;
896 struct cleanup *cleanups;
897 char *filename = DEV_TTY;
898 char *symname = NULL;
899 struct objfile *objfile;
905 error ("print-msymbols takes an output file name and optional symbol file name");
907 else if ((argv = buildargv (args)) == NULL)
911 cleanups = make_cleanup_freeargv (argv);
916 /* If a second arg is supplied, it is a source file name to match on */
923 filename = tilde_expand (filename);
924 make_cleanup (xfree, filename);
926 outfile = gdb_fopen (filename, FOPEN_WT);
928 perror_with_name (filename);
929 make_cleanup_ui_file_delete (outfile);
932 ALL_OBJFILES (objfile)
933 if (symname == NULL || (STREQ (symname, objfile->name)))
934 dump_msymbols (objfile, outfile);
936 fprintf_filtered (outfile, "\n\n");
937 do_cleanups (cleanups);
941 maintenance_print_objfiles (char *ignore, int from_tty)
943 struct objfile *objfile;
948 ALL_OBJFILES (objfile)
949 dump_objfile (objfile);
953 /* Check consistency of psymtabs and symtabs. */
956 maintenance_check_symtabs (char *ignore, int from_tty)
958 register struct symbol *sym;
959 register struct partial_symbol **psym;
960 register struct symtab *s = NULL;
961 register struct partial_symtab *ps;
962 struct blockvector *bv;
963 register struct objfile *objfile;
964 register struct block *b;
967 ALL_PSYMTABS (objfile, ps)
969 s = PSYMTAB_TO_SYMTAB (ps);
972 bv = BLOCKVECTOR (s);
973 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
974 psym = ps->objfile->static_psymbols.list + ps->statics_offset;
975 length = ps->n_static_syms;
978 sym = lookup_block_symbol (b, SYMBOL_NAME (*psym),
979 NULL, SYMBOL_NAMESPACE (*psym));
982 printf_filtered ("Static symbol `");
983 puts_filtered (SYMBOL_NAME (*psym));
984 printf_filtered ("' only found in ");
985 puts_filtered (ps->filename);
986 printf_filtered (" psymtab\n");
990 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
991 psym = ps->objfile->global_psymbols.list + ps->globals_offset;
992 length = ps->n_global_syms;
995 sym = lookup_block_symbol (b, SYMBOL_NAME (*psym),
996 NULL, SYMBOL_NAMESPACE (*psym));
999 printf_filtered ("Global symbol `");
1000 puts_filtered (SYMBOL_NAME (*psym));
1001 printf_filtered ("' only found in ");
1002 puts_filtered (ps->filename);
1003 printf_filtered (" psymtab\n");
1007 if (ps->texthigh < ps->textlow)
1009 printf_filtered ("Psymtab ");
1010 puts_filtered (ps->filename);
1011 printf_filtered (" covers bad range ");
1012 print_address_numeric (ps->textlow, 1, gdb_stdout);
1013 printf_filtered (" - ");
1014 print_address_numeric (ps->texthigh, 1, gdb_stdout);
1015 printf_filtered ("\n");
1018 if (ps->texthigh == 0)
1020 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1022 printf_filtered ("Psymtab ");
1023 puts_filtered (ps->filename);
1024 printf_filtered (" covers ");
1025 print_address_numeric (ps->textlow, 1, gdb_stdout);
1026 printf_filtered (" - ");
1027 print_address_numeric (ps->texthigh, 1, gdb_stdout);
1028 printf_filtered (" but symtab covers only ");
1029 print_address_numeric (BLOCK_START (b), 1, gdb_stdout);
1030 printf_filtered (" - ");
1031 print_address_numeric (BLOCK_END (b), 1, gdb_stdout);
1032 printf_filtered ("\n");
1038 /* Return the nexting depth of a block within other blocks in its symtab. */
1041 block_depth (struct block *block)
1044 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1052 /* Increase the space allocated for LISTP, which is probably
1053 global_psymbols or static_psymbols. This space will eventually
1054 be freed in free_objfile(). */
1057 extend_psymbol_list (register struct psymbol_allocation_list *listp,
1058 struct objfile *objfile)
1061 if (listp->size == 0)
1064 listp->list = (struct partial_symbol **)
1065 xmmalloc (objfile->md, new_size * sizeof (struct partial_symbol *));
1069 new_size = listp->size * 2;
1070 listp->list = (struct partial_symbol **)
1071 xmrealloc (objfile->md, (char *) listp->list,
1072 new_size * sizeof (struct partial_symbol *));
1074 /* Next assumes we only went one over. Should be good if
1075 program works correctly */
1076 listp->next = listp->list + listp->size;
1077 listp->size = new_size;
1081 /* Do early runtime initializations. */
1083 _initialize_symmisc (void)