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 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 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (msymbol
)), 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 if (msymbol
->filename
)
360 fprintf_filtered (outfile
, " %s", msymbol
->filename
);
361 fputs_filtered ("\n", outfile
);
363 if (objfile
->minimal_symbol_count
!= index
)
365 warning (_("internal error: minimal symbol count %d != %d"),
366 objfile
->minimal_symbol_count
, index
);
368 fprintf_filtered (outfile
, "\n");
372 dump_psymtab (struct objfile
*objfile
, struct partial_symtab
*psymtab
,
373 struct ui_file
*outfile
)
377 fprintf_filtered (outfile
, "\nPartial symtab for source file %s ",
379 fprintf_filtered (outfile
, "(object ");
380 gdb_print_host_address (psymtab
, outfile
);
381 fprintf_filtered (outfile
, ")\n\n");
382 fprintf_unfiltered (outfile
, " Read from object file %s (",
384 gdb_print_host_address (objfile
, outfile
);
385 fprintf_unfiltered (outfile
, ")\n");
389 fprintf_filtered (outfile
,
390 " Full symtab was read (at ");
391 gdb_print_host_address (psymtab
->symtab
, outfile
);
392 fprintf_filtered (outfile
, " by function at ");
393 gdb_print_host_address (psymtab
->read_symtab
, outfile
);
394 fprintf_filtered (outfile
, ")\n");
397 fprintf_filtered (outfile
, " Relocate symbols by ");
398 for (i
= 0; i
< psymtab
->objfile
->num_sections
; ++i
)
401 fprintf_filtered (outfile
, ", ");
403 fputs_filtered (paddress (ANOFFSET (psymtab
->section_offsets
, i
)),
406 fprintf_filtered (outfile
, "\n");
408 fprintf_filtered (outfile
, " Symbols cover text addresses ");
409 fputs_filtered (paddress (psymtab
->textlow
), outfile
);
410 fprintf_filtered (outfile
, "-");
411 fputs_filtered (paddress (psymtab
->texthigh
), outfile
);
412 fprintf_filtered (outfile
, "\n");
413 fprintf_filtered (outfile
, " Depends on %d other partial symtabs.\n",
414 psymtab
->number_of_dependencies
);
415 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
417 fprintf_filtered (outfile
, " %d ", i
);
418 gdb_print_host_address (psymtab
->dependencies
[i
], outfile
);
419 fprintf_filtered (outfile
, " %s\n",
420 psymtab
->dependencies
[i
]->filename
);
422 if (psymtab
->n_global_syms
> 0)
424 print_partial_symbols (objfile
->global_psymbols
.list
425 + psymtab
->globals_offset
,
426 psymtab
->n_global_syms
, "Global", outfile
);
428 if (psymtab
->n_static_syms
> 0)
430 print_partial_symbols (objfile
->static_psymbols
.list
431 + psymtab
->statics_offset
,
432 psymtab
->n_static_syms
, "Static", outfile
);
434 fprintf_filtered (outfile
, "\n");
438 dump_symtab_1 (struct objfile
*objfile
, struct symtab
*symtab
,
439 struct ui_file
*outfile
)
442 struct dict_iterator iter
;
445 struct blockvector
*bv
;
450 fprintf_filtered (outfile
, "\nSymtab for file %s\n", symtab
->filename
);
452 fprintf_filtered (outfile
, "Compilation directory is %s\n",
454 fprintf_filtered (outfile
, "Read from object file %s (", objfile
->name
);
455 gdb_print_host_address (objfile
, outfile
);
456 fprintf_filtered (outfile
, ")\n");
457 fprintf_filtered (outfile
, "Language: %s\n", language_str (symtab
->language
));
459 /* First print the line table. */
460 l
= LINETABLE (symtab
);
463 fprintf_filtered (outfile
, "\nLine table:\n\n");
465 for (i
= 0; i
< len
; i
++)
467 fprintf_filtered (outfile
, " line %d at ", l
->item
[i
].line
);
468 fputs_filtered (paddress (l
->item
[i
].pc
), outfile
);
469 fprintf_filtered (outfile
, "\n");
472 /* Now print the block info, but only for primary symtabs since we will
473 print lots of duplicate info otherwise. */
476 fprintf_filtered (outfile
, "\nBlockvector:\n\n");
477 bv
= BLOCKVECTOR (symtab
);
478 len
= BLOCKVECTOR_NBLOCKS (bv
);
479 for (i
= 0; i
< len
; i
++)
481 b
= BLOCKVECTOR_BLOCK (bv
, i
);
482 depth
= block_depth (b
) * 2;
483 print_spaces (depth
, outfile
);
484 fprintf_filtered (outfile
, "block #%03d, object at ", i
);
485 gdb_print_host_address (b
, outfile
);
486 if (BLOCK_SUPERBLOCK (b
))
488 fprintf_filtered (outfile
, " under ");
489 gdb_print_host_address (BLOCK_SUPERBLOCK (b
), outfile
);
491 /* drow/2002-07-10: We could save the total symbols count
492 even if we're using a hashtable, but nothing else but this message
494 fprintf_filtered (outfile
, ", %d syms/buckets in ",
495 dict_size (BLOCK_DICT (b
)));
496 fputs_filtered (paddress (BLOCK_START (b
)), outfile
);
497 fprintf_filtered (outfile
, "..");
498 fputs_filtered (paddress (BLOCK_END (b
)), outfile
);
499 if (BLOCK_FUNCTION (b
))
501 fprintf_filtered (outfile
, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b
)));
502 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b
)) != NULL
)
504 fprintf_filtered (outfile
, ", %s",
505 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b
)));
508 fprintf_filtered (outfile
, "\n");
509 /* Now print each symbol in this block (in no particular order, if
510 we're using a hashtable). */
511 ALL_BLOCK_SYMBOLS (b
, iter
, sym
)
513 struct print_symbol_args s
;
517 catch_errors (print_symbol
, &s
, "Error printing symbol:\n",
521 fprintf_filtered (outfile
, "\n");
525 fprintf_filtered (outfile
, "\nBlockvector same as previous symtab\n\n");
530 dump_symtab (struct objfile
*objfile
, struct symtab
*symtab
,
531 struct ui_file
*outfile
)
533 enum language saved_lang
;
535 /* Set the current language to the language of the symtab we're dumping
536 because certain routines used during dump_symtab() use the current
537 language to print an image of the symbol. We'll restore it later. */
538 saved_lang
= set_language (symtab
->language
);
540 dump_symtab_1 (objfile
, symtab
, outfile
);
542 set_language (saved_lang
);
546 maintenance_print_symbols (char *args
, int from_tty
)
549 struct ui_file
*outfile
;
550 struct cleanup
*cleanups
;
551 char *symname
= NULL
;
552 char *filename
= DEV_TTY
;
553 struct objfile
*objfile
;
561 Arguments missing: an output file name and an optional symbol file name"));
563 else if ((argv
= buildargv (args
)) == NULL
)
567 cleanups
= make_cleanup_freeargv (argv
);
572 /* If a second arg is supplied, it is a source file name to match on */
579 filename
= tilde_expand (filename
);
580 make_cleanup (xfree
, filename
);
582 outfile
= gdb_fopen (filename
, FOPEN_WT
);
584 perror_with_name (filename
);
585 make_cleanup_ui_file_delete (outfile
);
588 ALL_SYMTABS (objfile
, s
)
589 if (symname
== NULL
|| strcmp (symname
, s
->filename
) == 0)
590 dump_symtab (objfile
, s
, outfile
);
592 do_cleanups (cleanups
);
595 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
596 far to indent. ARGS is really a struct print_symbol_args *, but is
597 declared as char * to get it past catch_errors. Returns 0 for error,
601 print_symbol (void *args
)
603 struct symbol
*symbol
= ((struct print_symbol_args
*) args
)->symbol
;
604 int depth
= ((struct print_symbol_args
*) args
)->depth
;
605 struct ui_file
*outfile
= ((struct print_symbol_args
*) args
)->outfile
;
607 print_spaces (depth
, outfile
);
608 if (SYMBOL_DOMAIN (symbol
) == LABEL_DOMAIN
)
610 fprintf_filtered (outfile
, "label %s at ", SYMBOL_PRINT_NAME (symbol
));
611 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol
)), outfile
);
612 if (SYMBOL_BFD_SECTION (symbol
))
613 fprintf_filtered (outfile
, " section %s\n",
614 bfd_section_name (SYMBOL_BFD_SECTION (symbol
)->owner
,
615 SYMBOL_BFD_SECTION (symbol
)));
617 fprintf_filtered (outfile
, "\n");
620 if (SYMBOL_DOMAIN (symbol
) == STRUCT_DOMAIN
)
622 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol
)))
624 LA_PRINT_TYPE (SYMBOL_TYPE (symbol
), "", outfile
, 1, depth
);
628 fprintf_filtered (outfile
, "%s %s = ",
629 (TYPE_CODE (SYMBOL_TYPE (symbol
)) == TYPE_CODE_ENUM
631 : (TYPE_CODE (SYMBOL_TYPE (symbol
)) == TYPE_CODE_STRUCT
632 ? "struct" : "union")),
633 DEPRECATED_SYMBOL_NAME (symbol
));
634 LA_PRINT_TYPE (SYMBOL_TYPE (symbol
), "", outfile
, 1, depth
);
636 fprintf_filtered (outfile
, ";\n");
640 if (SYMBOL_CLASS (symbol
) == LOC_TYPEDEF
)
641 fprintf_filtered (outfile
, "typedef ");
642 if (SYMBOL_TYPE (symbol
))
644 /* Print details of types, except for enums where it's clutter. */
645 LA_PRINT_TYPE (SYMBOL_TYPE (symbol
), SYMBOL_PRINT_NAME (symbol
),
647 TYPE_CODE (SYMBOL_TYPE (symbol
)) != TYPE_CODE_ENUM
,
649 fprintf_filtered (outfile
, "; ");
652 fprintf_filtered (outfile
, "%s ", SYMBOL_PRINT_NAME (symbol
));
654 switch (SYMBOL_CLASS (symbol
))
657 fprintf_filtered (outfile
, "const %ld (0x%lx)",
658 SYMBOL_VALUE (symbol
),
659 SYMBOL_VALUE (symbol
));
662 case LOC_CONST_BYTES
:
665 struct type
*type
= check_typedef (SYMBOL_TYPE (symbol
));
666 fprintf_filtered (outfile
, "const %u hex bytes:",
668 for (i
= 0; i
< TYPE_LENGTH (type
); i
++)
669 fprintf_filtered (outfile
, " %02x",
670 (unsigned) SYMBOL_VALUE_BYTES (symbol
)[i
]);
675 fprintf_filtered (outfile
, "static 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
, "extern global at *(");
686 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol
)), outfile
);
687 fprintf_filtered (outfile
, "),");
691 fprintf_filtered (outfile
, "register %ld", SYMBOL_VALUE (symbol
));
695 fprintf_filtered (outfile
, "arg at offset 0x%lx",
696 SYMBOL_VALUE (symbol
));
700 fprintf_filtered (outfile
, "arg at offset 0x%lx from fp",
701 SYMBOL_VALUE (symbol
));
705 fprintf_filtered (outfile
, "reference arg at 0x%lx", SYMBOL_VALUE (symbol
));
709 fprintf_filtered (outfile
, "parameter register %ld", SYMBOL_VALUE (symbol
));
712 case LOC_REGPARM_ADDR
:
713 fprintf_filtered (outfile
, "address parameter register %ld", SYMBOL_VALUE (symbol
));
717 fprintf_filtered (outfile
, "local at offset 0x%lx",
718 SYMBOL_VALUE (symbol
));
722 fprintf_filtered (outfile
, "local at 0x%lx from register %d",
723 SYMBOL_VALUE (symbol
), SYMBOL_BASEREG (symbol
));
726 case LOC_BASEREG_ARG
:
727 fprintf_filtered (outfile
, "arg at 0x%lx from register %d",
728 SYMBOL_VALUE (symbol
), SYMBOL_BASEREG (symbol
));
735 fprintf_filtered (outfile
, "label at ");
736 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol
)), outfile
);
737 if (SYMBOL_BFD_SECTION (symbol
))
738 fprintf_filtered (outfile
, " section %s",
740 (SYMBOL_BFD_SECTION (symbol
)->owner
,
741 SYMBOL_BFD_SECTION (symbol
)));
745 fprintf_filtered (outfile
, "block object ");
746 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol
), outfile
);
747 fprintf_filtered (outfile
, ", ");
748 fputs_filtered (paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol
))),
750 fprintf_filtered (outfile
, "..");
751 fputs_filtered (paddress (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol
))),
753 if (SYMBOL_BFD_SECTION (symbol
))
754 fprintf_filtered (outfile
, " section %s",
756 (SYMBOL_BFD_SECTION (symbol
)->owner
,
757 SYMBOL_BFD_SECTION (symbol
)));
761 case LOC_COMPUTED_ARG
:
762 fprintf_filtered (outfile
, "computed at runtime");
766 fprintf_filtered (outfile
, "unresolved");
769 case LOC_OPTIMIZED_OUT
:
770 fprintf_filtered (outfile
, "optimized out");
774 fprintf_filtered (outfile
, "botched symbol class %x",
775 SYMBOL_CLASS (symbol
));
779 fprintf_filtered (outfile
, "\n");
784 maintenance_print_psymbols (char *args
, int from_tty
)
787 struct ui_file
*outfile
;
788 struct cleanup
*cleanups
;
789 char *symname
= NULL
;
790 char *filename
= DEV_TTY
;
791 struct objfile
*objfile
;
792 struct partial_symtab
*ps
;
798 error (_("print-psymbols takes an output file name and optional symbol file name"));
800 else if ((argv
= buildargv (args
)) == NULL
)
804 cleanups
= make_cleanup_freeargv (argv
);
809 /* If a second arg is supplied, it is a source file name to match on */
816 filename
= tilde_expand (filename
);
817 make_cleanup (xfree
, filename
);
819 outfile
= gdb_fopen (filename
, FOPEN_WT
);
821 perror_with_name (filename
);
822 make_cleanup_ui_file_delete (outfile
);
825 ALL_PSYMTABS (objfile
, ps
)
826 if (symname
== NULL
|| strcmp (symname
, ps
->filename
) == 0)
827 dump_psymtab (objfile
, ps
, outfile
);
829 do_cleanups (cleanups
);
833 print_partial_symbols (struct partial_symbol
**p
, int count
, char *what
,
834 struct ui_file
*outfile
)
836 fprintf_filtered (outfile
, " %s partial symbols:\n", what
);
839 fprintf_filtered (outfile
, " `%s'", DEPRECATED_SYMBOL_NAME (*p
));
840 if (SYMBOL_DEMANGLED_NAME (*p
) != NULL
)
842 fprintf_filtered (outfile
, " `%s'", SYMBOL_DEMANGLED_NAME (*p
));
844 fputs_filtered (", ", outfile
);
845 switch (SYMBOL_DOMAIN (*p
))
848 fputs_filtered ("undefined domain, ", outfile
);
851 /* This is the usual thing -- don't print it */
854 fputs_filtered ("struct domain, ", outfile
);
857 fputs_filtered ("label domain, ", outfile
);
860 fputs_filtered ("<invalid domain>, ", outfile
);
863 switch (SYMBOL_CLASS (*p
))
866 fputs_filtered ("undefined", outfile
);
869 fputs_filtered ("constant int", outfile
);
872 fputs_filtered ("static", outfile
);
875 fputs_filtered ("extern global", outfile
);
878 fputs_filtered ("register", outfile
);
881 fputs_filtered ("pass by value", outfile
);
884 fputs_filtered ("pass by reference", outfile
);
887 fputs_filtered ("register parameter", outfile
);
889 case LOC_REGPARM_ADDR
:
890 fputs_filtered ("register address parameter", outfile
);
893 fputs_filtered ("stack parameter", outfile
);
896 fputs_filtered ("type", outfile
);
899 fputs_filtered ("label", outfile
);
902 fputs_filtered ("function", outfile
);
904 case LOC_CONST_BYTES
:
905 fputs_filtered ("constant bytes", outfile
);
908 fputs_filtered ("shuffled arg", outfile
);
911 fputs_filtered ("unresolved", outfile
);
913 case LOC_OPTIMIZED_OUT
:
914 fputs_filtered ("optimized out", outfile
);
917 case LOC_COMPUTED_ARG
:
918 fputs_filtered ("computed at runtime", outfile
);
921 fputs_filtered ("<invalid location>", outfile
);
924 fputs_filtered (", ", outfile
);
925 fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (*p
)), outfile
);
926 fprintf_filtered (outfile
, "\n");
932 maintenance_print_msymbols (char *args
, int from_tty
)
935 struct ui_file
*outfile
;
936 struct cleanup
*cleanups
;
937 char *filename
= DEV_TTY
;
938 char *symname
= NULL
;
939 struct objfile
*objfile
;
941 struct stat sym_st
, obj_st
;
947 error (_("print-msymbols takes an output file name and optional symbol file name"));
949 else if ((argv
= buildargv (args
)) == NULL
)
953 cleanups
= make_cleanup_freeargv (argv
);
958 /* If a second arg is supplied, it is a source file name to match on */
961 symname
= xfullpath (argv
[1]);
962 make_cleanup (xfree
, symname
);
963 if (symname
&& stat (symname
, &sym_st
))
964 perror_with_name (symname
);
968 filename
= tilde_expand (filename
);
969 make_cleanup (xfree
, filename
);
971 outfile
= gdb_fopen (filename
, FOPEN_WT
);
973 perror_with_name (filename
);
974 make_cleanup_ui_file_delete (outfile
);
977 ALL_OBJFILES (objfile
)
979 || (!stat (objfile
->name
, &obj_st
) && sym_st
.st_ino
== obj_st
.st_ino
))
980 dump_msymbols (objfile
, outfile
);
982 fprintf_filtered (outfile
, "\n\n");
983 do_cleanups (cleanups
);
987 maintenance_print_objfiles (char *ignore
, int from_tty
)
989 struct objfile
*objfile
;
994 ALL_OBJFILES (objfile
)
995 dump_objfile (objfile
);
1000 /* List all the symbol tables whose names match REGEXP (optional). */
1002 maintenance_info_symtabs (char *regexp
, int from_tty
)
1004 struct objfile
*objfile
;
1009 ALL_OBJFILES (objfile
)
1011 struct symtab
*symtab
;
1013 /* We don't want to print anything for this objfile until we
1014 actually find a symtab whose name matches. */
1015 int printed_objfile_start
= 0;
1017 ALL_OBJFILE_SYMTABS (objfile
, symtab
)
1019 || re_exec (symtab
->filename
))
1021 if (! printed_objfile_start
)
1023 printf_filtered ("{ objfile %s ", objfile
->name
);
1025 printf_filtered ("((struct objfile *) %p)\n", objfile
);
1026 printed_objfile_start
= 1;
1029 printf_filtered (" { symtab %s ", symtab
->filename
);
1031 printf_filtered ("((struct symtab *) %p)\n", symtab
);
1032 printf_filtered (" dirname %s\n",
1033 symtab
->dirname
? symtab
->dirname
: "(null)");
1034 printf_filtered (" fullname %s\n",
1035 symtab
->fullname
? symtab
->fullname
: "(null)");
1036 printf_filtered (" blockvector ((struct blockvector *) %p)%s\n",
1037 symtab
->blockvector
,
1038 symtab
->primary
? " (primary)" : "");
1039 printf_filtered (" linetable ((struct linetable *) %p)\n",
1041 printf_filtered (" debugformat %s\n", symtab
->debugformat
);
1042 printf_filtered (" }\n");
1045 if (printed_objfile_start
)
1046 printf_filtered ("}\n");
1051 /* List all the partial symbol tables whose names match REGEXP (optional). */
1053 maintenance_info_psymtabs (char *regexp
, int from_tty
)
1055 struct objfile
*objfile
;
1060 ALL_OBJFILES (objfile
)
1062 struct partial_symtab
*psymtab
;
1064 /* We don't want to print anything for this objfile until we
1065 actually find a symtab whose name matches. */
1066 int printed_objfile_start
= 0;
1068 ALL_OBJFILE_PSYMTABS (objfile
, psymtab
)
1070 || re_exec (psymtab
->filename
))
1072 if (! printed_objfile_start
)
1074 printf_filtered ("{ objfile %s ", objfile
->name
);
1076 printf_filtered ("((struct objfile *) %p)\n", objfile
);
1077 printed_objfile_start
= 1;
1080 printf_filtered (" { psymtab %s ", psymtab
->filename
);
1082 printf_filtered ("((struct partial_symtab *) %p)\n", psymtab
);
1083 printf_filtered (" readin %s\n",
1084 psymtab
->readin
? "yes" : "no");
1085 printf_filtered (" fullname %s\n",
1086 psymtab
->fullname
? psymtab
->fullname
: "(null)");
1087 printf_filtered (" text addresses ");
1088 fputs_filtered (paddress (psymtab
->textlow
), gdb_stdout
);
1089 printf_filtered (" -- ");
1090 fputs_filtered (paddress (psymtab
->texthigh
), gdb_stdout
);
1091 printf_filtered ("\n");
1092 printf_filtered (" globals ");
1093 if (psymtab
->n_global_syms
)
1095 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1096 (psymtab
->objfile
->global_psymbols
.list
1097 + psymtab
->globals_offset
),
1098 psymtab
->n_global_syms
);
1101 printf_filtered ("(none)\n");
1102 printf_filtered (" statics ");
1103 if (psymtab
->n_static_syms
)
1105 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1106 (psymtab
->objfile
->static_psymbols
.list
1107 + psymtab
->statics_offset
),
1108 psymtab
->n_static_syms
);
1111 printf_filtered ("(none)\n");
1112 printf_filtered (" dependencies ");
1113 if (psymtab
->number_of_dependencies
)
1117 printf_filtered ("{\n");
1118 for (i
= 0; i
< psymtab
->number_of_dependencies
; i
++)
1120 struct partial_symtab
*dep
= psymtab
->dependencies
[i
];
1122 /* Note the string concatenation there --- no comma. */
1123 printf_filtered (" psymtab %s "
1124 "((struct partial_symtab *) %p)\n",
1125 dep
->filename
, dep
);
1127 printf_filtered (" }\n");
1130 printf_filtered ("(none)\n");
1131 printf_filtered (" }\n");
1134 if (printed_objfile_start
)
1135 printf_filtered ("}\n");
1140 /* Check consistency of psymtabs and symtabs. */
1143 maintenance_check_symtabs (char *ignore
, int from_tty
)
1146 struct partial_symbol
**psym
;
1147 struct symtab
*s
= NULL
;
1148 struct partial_symtab
*ps
;
1149 struct blockvector
*bv
;
1150 struct objfile
*objfile
;
1154 ALL_PSYMTABS (objfile
, ps
)
1156 s
= PSYMTAB_TO_SYMTAB (ps
);
1159 bv
= BLOCKVECTOR (s
);
1160 b
= BLOCKVECTOR_BLOCK (bv
, STATIC_BLOCK
);
1161 psym
= ps
->objfile
->static_psymbols
.list
+ ps
->statics_offset
;
1162 length
= ps
->n_static_syms
;
1165 sym
= lookup_block_symbol (b
, DEPRECATED_SYMBOL_NAME (*psym
),
1166 NULL
, SYMBOL_DOMAIN (*psym
));
1169 printf_filtered ("Static symbol `");
1170 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym
));
1171 printf_filtered ("' only found in ");
1172 puts_filtered (ps
->filename
);
1173 printf_filtered (" psymtab\n");
1177 b
= BLOCKVECTOR_BLOCK (bv
, GLOBAL_BLOCK
);
1178 psym
= ps
->objfile
->global_psymbols
.list
+ ps
->globals_offset
;
1179 length
= ps
->n_global_syms
;
1182 sym
= lookup_block_symbol (b
, DEPRECATED_SYMBOL_NAME (*psym
),
1183 NULL
, SYMBOL_DOMAIN (*psym
));
1186 printf_filtered ("Global symbol `");
1187 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym
));
1188 printf_filtered ("' only found in ");
1189 puts_filtered (ps
->filename
);
1190 printf_filtered (" psymtab\n");
1194 if (ps
->texthigh
< ps
->textlow
)
1196 printf_filtered ("Psymtab ");
1197 puts_filtered (ps
->filename
);
1198 printf_filtered (" covers bad range ");
1199 fputs_filtered (paddress (ps
->textlow
), gdb_stdout
);
1200 printf_filtered (" - ");
1201 fputs_filtered (paddress (ps
->texthigh
), gdb_stdout
);
1202 printf_filtered ("\n");
1205 if (ps
->texthigh
== 0)
1207 if (ps
->textlow
< BLOCK_START (b
) || ps
->texthigh
> BLOCK_END (b
))
1209 printf_filtered ("Psymtab ");
1210 puts_filtered (ps
->filename
);
1211 printf_filtered (" covers ");
1212 fputs_filtered (paddress (ps
->textlow
), gdb_stdout
);
1213 printf_filtered (" - ");
1214 fputs_filtered (paddress (ps
->texthigh
), gdb_stdout
);
1215 printf_filtered (" but symtab covers only ");
1216 fputs_filtered (paddress (BLOCK_START (b
)), gdb_stdout
);
1217 printf_filtered (" - ");
1218 fputs_filtered (paddress (BLOCK_END (b
)), gdb_stdout
);
1219 printf_filtered ("\n");
1225 /* Return the nexting depth of a block within other blocks in its symtab. */
1228 block_depth (struct block
*block
)
1231 while ((block
= BLOCK_SUPERBLOCK (block
)) != NULL
)
1239 /* Increase the space allocated for LISTP, which is probably
1240 global_psymbols or static_psymbols. This space will eventually
1241 be freed in free_objfile(). */
1244 extend_psymbol_list (struct psymbol_allocation_list
*listp
,
1245 struct objfile
*objfile
)
1248 if (listp
->size
== 0)
1251 listp
->list
= (struct partial_symbol
**)
1252 xmalloc (new_size
* sizeof (struct partial_symbol
*));
1256 new_size
= listp
->size
* 2;
1257 listp
->list
= (struct partial_symbol
**)
1258 xrealloc ((char *) listp
->list
,
1259 new_size
* sizeof (struct partial_symbol
*));
1261 /* Next assumes we only went one over. Should be good if
1262 program works correctly */
1263 listp
->next
= listp
->list
+ listp
->size
;
1264 listp
->size
= new_size
;
1268 /* Do early runtime initializations. */
1270 _initialize_symmisc (void)
This page took 0.054987 seconds and 4 git commands to generate.