projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Make gdb.mi/user-selected-context-sync.exp use proc_with_prefix
[deliverable/binutils-gdb.git] / gdb / symmisc.c
... / ...
CommitLineData
1/* Do various things to symbol tables (other than lookup), for GDB.
2
3 Copyright (C) 1986-2016 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "symtab.h"
22#include "gdbtypes.h"
23#include "bfd.h"
24#include "filenames.h"
25#include "symfile.h"
26#include "objfiles.h"
27#include "breakpoint.h"
28#include "command.h"
29#include "gdb_obstack.h"
30#include "language.h"
31#include "bcache.h"
32#include "block.h"
33#include "gdb_regex.h"
34#include <sys/stat.h>
35#include "dictionary.h"
36#include "typeprint.h"
37#include "gdbcmd.h"
38#include "source.h"
39#include "readline/readline.h"
40
41#include "psymtab.h"
42
43#ifndef DEV_TTY
44#define DEV_TTY "/dev/tty"
45#endif
46
47/* Unfortunately for debugging, stderr is usually a macro. This is painful
48 when calling functions that take FILE *'s from the debugger.
49 So we make a variable which has the same value and which is accessible when
50 debugging GDB with itself. Because stdin et al need not be constants,
51 we initialize them in the _initialize_symmisc function at the bottom
52 of the file. */
53FILE *std_in;
54FILE *std_out;
55FILE *std_err;
56
57/* Prototypes for local functions */
58
59static int block_depth (struct block *);
60
61void _initialize_symmisc (void);
62
63struct print_symbol_args
64 {
65 struct gdbarch *gdbarch;
66 struct symbol *symbol;
67 int depth;
68 struct ui_file *outfile;
69 };
70
71static int print_symbol (void *);
72\f
73
74void
75print_symbol_bcache_statistics (void)
76{
77 struct program_space *pspace;
78 struct objfile *objfile;
79
80 ALL_PSPACES (pspace)
81 ALL_PSPACE_OBJFILES (pspace, objfile)
82 {
83 QUIT;
84 printf_filtered (_("Byte cache statistics for '%s':\n"),
85 objfile_name (objfile));
86 print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache),
87 "partial symbol cache");
88 print_bcache_statistics (objfile->per_bfd->macro_cache,
89 "preprocessor macro cache");
90 print_bcache_statistics (objfile->per_bfd->filename_cache,
91 "file name cache");
92 }
93}
94
95void
96print_objfile_statistics (void)
97{
98 struct program_space *pspace;
99 struct objfile *objfile;
100 struct compunit_symtab *cu;
101 struct symtab *s;
102 int i, linetables, blockvectors;
103
104 ALL_PSPACES (pspace)
105 ALL_PSPACE_OBJFILES (pspace, objfile)
106 {
107 QUIT;
108 printf_filtered (_("Statistics for '%s':\n"), objfile_name (objfile));
109 if (OBJSTAT (objfile, n_stabs) > 0)
110 printf_filtered (_(" Number of \"stab\" symbols read: %d\n"),
111 OBJSTAT (objfile, n_stabs));
112 if (objfile->per_bfd->n_minsyms > 0)
113 printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"),
114 objfile->per_bfd->n_minsyms);
115 if (OBJSTAT (objfile, n_psyms) > 0)
116 printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
117 OBJSTAT (objfile, n_psyms));
118 if (OBJSTAT (objfile, n_syms) > 0)
119 printf_filtered (_(" Number of \"full\" symbols read: %d\n"),
120 OBJSTAT (objfile, n_syms));
121 if (OBJSTAT (objfile, n_types) > 0)
122 printf_filtered (_(" Number of \"types\" defined: %d\n"),
123 OBJSTAT (objfile, n_types));
124 if (objfile->sf)
125 objfile->sf->qf->print_stats (objfile);
126 i = linetables = blockvectors = 0;
127 ALL_OBJFILE_FILETABS (objfile, cu, s)
128 {
129 i++;
130 if (SYMTAB_LINETABLE (s) != NULL)
131 linetables++;
132 }
133 ALL_OBJFILE_COMPUNITS (objfile, cu)
134 blockvectors++;
135 printf_filtered (_(" Number of symbol tables: %d\n"), i);
136 printf_filtered (_(" Number of symbol tables with line tables: %d\n"),
137 linetables);
138 printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"),
139 blockvectors);
140
141 if (OBJSTAT (objfile, sz_strtab) > 0)
142 printf_filtered (_(" Space used by a.out string tables: %d\n"),
143 OBJSTAT (objfile, sz_strtab));
144 printf_filtered (_(" Total memory used for objfile obstack: %s\n"),
145 pulongest (obstack_memory_used (&objfile
146 ->objfile_obstack)));
147 printf_filtered (_(" Total memory used for BFD obstack: %s\n"),
148 pulongest (obstack_memory_used (&objfile->per_bfd
149 ->storage_obstack)));
150 printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
151 bcache_memory_used (psymbol_bcache_get_bcache
152 (objfile->psymbol_cache)));
153 printf_filtered (_(" Total memory used for macro cache: %d\n"),
154 bcache_memory_used (objfile->per_bfd->macro_cache));
155 printf_filtered (_(" Total memory used for file name cache: %d\n"),
156 bcache_memory_used (objfile->per_bfd->filename_cache));
157 }
158}
159
160static void
161dump_objfile (struct objfile *objfile)
162{
163 struct compunit_symtab *cust;
164 struct symtab *symtab;
165
166 printf_filtered ("\nObject file %s: ", objfile_name (objfile));
167 printf_filtered ("Objfile at ");
168 gdb_print_host_address (objfile, gdb_stdout);
169 printf_filtered (", bfd at ");
170 gdb_print_host_address (objfile->obfd, gdb_stdout);
171 printf_filtered (", %d minsyms\n\n",
172 objfile->per_bfd->minimal_symbol_count);
173
174 if (objfile->sf)
175 objfile->sf->qf->dump (objfile);
176
177 if (objfile->compunit_symtabs != NULL)
178 {
179 printf_filtered ("Symtabs:\n");
180 ALL_OBJFILE_FILETABS (objfile, cust, symtab)
181 {
182 printf_filtered ("%s at ", symtab_to_filename_for_display (symtab));
183 gdb_print_host_address (symtab, gdb_stdout);
184 printf_filtered (", ");
185 if (SYMTAB_OBJFILE (symtab) != objfile)
186 {
187 printf_filtered ("NOT ON CHAIN! ");
188 }
189 wrap_here (" ");
190 }
191 printf_filtered ("\n\n");
192 }
193}
194
195/* Print minimal symbols from this objfile. */
196
197static void
198dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
199{
200 struct gdbarch *gdbarch = get_objfile_arch (objfile);
201 struct minimal_symbol *msymbol;
202 int index;
203 char ms_type;
204
205 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
206 if (objfile->per_bfd->minimal_symbol_count == 0)
207 {
208 fprintf_filtered (outfile, "No minimal symbols found.\n");
209 return;
210 }
211 index = 0;
212 ALL_OBJFILE_MSYMBOLS (objfile, msymbol)
213 {
214 struct obj_section *section = MSYMBOL_OBJ_SECTION (objfile, msymbol);
215
216 switch (MSYMBOL_TYPE (msymbol))
217 {
218 case mst_unknown:
219 ms_type = 'u';
220 break;
221 case mst_text:
222 ms_type = 'T';
223 break;
224 case mst_text_gnu_ifunc:
225 ms_type = 'i';
226 break;
227 case mst_solib_trampoline:
228 ms_type = 'S';
229 break;
230 case mst_data:
231 ms_type = 'D';
232 break;
233 case mst_bss:
234 ms_type = 'B';
235 break;
236 case mst_abs:
237 ms_type = 'A';
238 break;
239 case mst_file_text:
240 ms_type = 't';
241 break;
242 case mst_file_data:
243 ms_type = 'd';
244 break;
245 case mst_file_bss:
246 ms_type = 'b';
247 break;
248 default:
249 ms_type = '?';
250 break;
251 }
252 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
253 fputs_filtered (paddress (gdbarch, MSYMBOL_VALUE_ADDRESS (objfile,
254 msymbol)),
255 outfile);
256 fprintf_filtered (outfile, " %s", MSYMBOL_LINKAGE_NAME (msymbol));
257 if (section)
258 {
259 if (section->the_bfd_section != NULL)
260 fprintf_filtered (outfile, " section %s",
261 bfd_section_name (objfile->obfd,
262 section->the_bfd_section));
263 else
264 fprintf_filtered (outfile, " spurious section %ld",
265 (long) (section - objfile->sections));
266 }
267 if (MSYMBOL_DEMANGLED_NAME (msymbol) != NULL)
268 {
269 fprintf_filtered (outfile, " %s", MSYMBOL_DEMANGLED_NAME (msymbol));
270 }
271 if (msymbol->filename)
272 fprintf_filtered (outfile, " %s", msymbol->filename);
273 fputs_filtered ("\n", outfile);
274 index++;
275 }
276 if (objfile->per_bfd->minimal_symbol_count != index)
277 {
278 warning (_("internal error: minimal symbol count %d != %d"),
279 objfile->per_bfd->minimal_symbol_count, index);
280 }
281 fprintf_filtered (outfile, "\n");
282}
283
284static void
285dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
286{
287 struct objfile *objfile = SYMTAB_OBJFILE (symtab);
288 struct gdbarch *gdbarch = get_objfile_arch (objfile);
289 int i;
290 struct dict_iterator iter;
291 int len;
292 struct linetable *l;
293 const struct blockvector *bv;
294 struct symbol *sym;
295 struct block *b;
296 int depth;
297
298 fprintf_filtered (outfile, "\nSymtab for file %s\n",
299 symtab_to_filename_for_display (symtab));
300 if (SYMTAB_DIRNAME (symtab) != NULL)
301 fprintf_filtered (outfile, "Compilation directory is %s\n",
302 SYMTAB_DIRNAME (symtab));
303 fprintf_filtered (outfile, "Read from object file %s (",
304 objfile_name (objfile));
305 gdb_print_host_address (objfile, outfile);
306 fprintf_filtered (outfile, ")\n");
307 fprintf_filtered (outfile, "Language: %s\n",
308 language_str (symtab->language));
309
310 /* First print the line table. */
311 l = SYMTAB_LINETABLE (symtab);
312 if (l)
313 {
314 fprintf_filtered (outfile, "\nLine table:\n\n");
315 len = l->nitems;
316 for (i = 0; i < len; i++)
317 {
318 fprintf_filtered (outfile, " line %d at ", l->item[i].line);
319 fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile);
320 fprintf_filtered (outfile, "\n");
321 }
322 }
323 /* Now print the block info, but only for compunit symtabs since we will
324 print lots of duplicate info otherwise. */
325 if (symtab == COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)))
326 {
327 fprintf_filtered (outfile, "\nBlockvector:\n\n");
328 bv = SYMTAB_BLOCKVECTOR (symtab);
329 len = BLOCKVECTOR_NBLOCKS (bv);
330 for (i = 0; i < len; i++)
331 {
332 b = BLOCKVECTOR_BLOCK (bv, i);
333 depth = block_depth (b) * 2;
334 print_spaces (depth, outfile);
335 fprintf_filtered (outfile, "block #%03d, object at ", i);
336 gdb_print_host_address (b, outfile);
337 if (BLOCK_SUPERBLOCK (b))
338 {
339 fprintf_filtered (outfile, " under ");
340 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
341 }
342 /* drow/2002-07-10: We could save the total symbols count
343 even if we're using a hashtable, but nothing else but this message
344 wants it. */
345 fprintf_filtered (outfile, ", %d syms/buckets in ",
346 dict_size (BLOCK_DICT (b)));
347 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile);
348 fprintf_filtered (outfile, "..");
349 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile);
350 if (BLOCK_FUNCTION (b))
351 {
352 fprintf_filtered (outfile, ", function %s",
353 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b)));
354 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
355 {
356 fprintf_filtered (outfile, ", %s",
357 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
358 }
359 }
360 fprintf_filtered (outfile, "\n");
361 /* Now print each symbol in this block (in no particular order, if
362 we're using a hashtable). Note that we only want this
363 block, not any blocks from included symtabs. */
364 ALL_DICT_SYMBOLS (BLOCK_DICT (b), iter, sym)
365 {
366 struct print_symbol_args s;
367
368 s.gdbarch = gdbarch;
369 s.symbol = sym;
370 s.depth = depth + 1;
371 s.outfile = outfile;
372 catch_errors (print_symbol, &s, "Error printing symbol:\n",
373 RETURN_MASK_ERROR);
374 }
375 }
376 fprintf_filtered (outfile, "\n");
377 }
378 else
379 {
380 const char *compunit_filename
381 = symtab_to_filename_for_display (COMPUNIT_FILETABS (SYMTAB_COMPUNIT (symtab)));
382
383 fprintf_filtered (outfile,
384 "\nBlockvector same as owning compunit: %s\n\n",
385 compunit_filename);
386 }
387}
388
389static void
390dump_symtab (struct symtab *symtab, struct ui_file *outfile)
391{
392 /* Set the current language to the language of the symtab we're dumping
393 because certain routines used during dump_symtab() use the current
394 language to print an image of the symbol. We'll restore it later.
395 But use only real languages, not placeholders. */
396 if (symtab->language != language_unknown
397 && symtab->language != language_auto)
398 {
399 enum language saved_lang;
400
401 saved_lang = set_language (symtab->language);
402
403 dump_symtab_1 (symtab, outfile);
404
405 set_language (saved_lang);
406 }
407 else
408 dump_symtab_1 (symtab, outfile);
409}
410
411static void
412maintenance_print_symbols (char *args, int from_tty)
413{
414 char **argv;
415 struct ui_file *outfile;
416 struct cleanup *cleanups;
417 char *symname = NULL;
418 char *filename = DEV_TTY;
419 struct objfile *objfile;
420 struct compunit_symtab *cu;
421 struct symtab *s;
422
423 dont_repeat ();
424
425 if (args == NULL)
426 {
427 error (_("Arguments missing: an output file name "
428 "and an optional symbol file name"));
429 }
430 argv = gdb_buildargv (args);
431 cleanups = make_cleanup_freeargv (argv);
432
433 if (argv[0] != NULL)
434 {
435 filename = argv[0];
436 /* If a second arg is supplied, it is a source file name to match on. */
437 if (argv[1] != NULL)
438 {
439 symname = argv[1];
440 }
441 }
442
443 filename = tilde_expand (filename);
444 make_cleanup (xfree, filename);
445
446 outfile = gdb_fopen (filename, FOPEN_WT);
447 if (outfile == 0)
448 perror_with_name (filename);
449 make_cleanup_ui_file_delete (outfile);
450
451 ALL_FILETABS (objfile, cu, s)
452 {
453 QUIT;
454 if (symname == NULL
455 || filename_cmp (symname, symtab_to_filename_for_display (s)) == 0)
456 dump_symtab (s, outfile);
457 }
458 do_cleanups (cleanups);
459}
460
461/* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
462 far to indent. ARGS is really a struct print_symbol_args *, but is
463 declared as char * to get it past catch_errors. Returns 0 for error,
464 1 for success. */
465
466static int
467print_symbol (void *args)
468{
469 struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch;
470 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
471 int depth = ((struct print_symbol_args *) args)->depth;
472 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
473 struct obj_section *section;
474
475 if (SYMBOL_OBJFILE_OWNED (symbol))
476 section = SYMBOL_OBJ_SECTION (symbol_objfile (symbol), symbol);
477 else
478 section = NULL;
479
480 print_spaces (depth, outfile);
481 if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
482 {
483 fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
484 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
485 outfile);
486 if (section)
487 fprintf_filtered (outfile, " section %s\n",
488 bfd_section_name (section->the_bfd_section->owner,
489 section->the_bfd_section));
490 else
491 fprintf_filtered (outfile, "\n");
492 return 1;
493 }
494 if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
495 {
496 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
497 {
498 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
499 &type_print_raw_options);
500 }
501 else
502 {
503 fprintf_filtered (outfile, "%s %s = ",
504 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
505 ? "enum"
506 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
507 ? "struct" : "union")),
508 SYMBOL_LINKAGE_NAME (symbol));
509 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth,
510 &type_print_raw_options);
511 }
512 fprintf_filtered (outfile, ";\n");
513 }
514 else
515 {
516 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
517 fprintf_filtered (outfile, "typedef ");
518 if (SYMBOL_TYPE (symbol))
519 {
520 /* Print details of types, except for enums where it's clutter. */
521 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
522 outfile,
523 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
524 depth,
525 &type_print_raw_options);
526 fprintf_filtered (outfile, "; ");
527 }
528 else
529 fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
530
531 switch (SYMBOL_CLASS (symbol))
532 {
533 case LOC_CONST:
534 fprintf_filtered (outfile, "const %s (%s)",
535 plongest (SYMBOL_VALUE (symbol)),
536 hex_string (SYMBOL_VALUE (symbol)));
537 break;
538
539 case LOC_CONST_BYTES:
540 {
541 unsigned i;
542 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
543
544 fprintf_filtered (outfile, "const %u hex bytes:",
545 TYPE_LENGTH (type));
546 for (i = 0; i < TYPE_LENGTH (type); i++)
547 fprintf_filtered (outfile, " %02x",
548 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
549 }
550 break;
551
552 case LOC_STATIC:
553 fprintf_filtered (outfile, "static at ");
554 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
555 outfile);
556 if (section)
557 fprintf_filtered (outfile, " section %s",
558 bfd_section_name (section->the_bfd_section->owner,
559 section->the_bfd_section));
560 break;
561
562 case LOC_REGISTER:
563 if (SYMBOL_IS_ARGUMENT (symbol))
564 fprintf_filtered (outfile, "parameter register %s",
565 plongest (SYMBOL_VALUE (symbol)));
566 else
567 fprintf_filtered (outfile, "register %s",
568 plongest (SYMBOL_VALUE (symbol)));
569 break;
570
571 case LOC_ARG:
572 fprintf_filtered (outfile, "arg at offset %s",
573 hex_string (SYMBOL_VALUE (symbol)));
574 break;
575
576 case LOC_REF_ARG:
577 fprintf_filtered (outfile, "reference arg at %s",
578 hex_string (SYMBOL_VALUE (symbol)));
579 break;
580
581 case LOC_REGPARM_ADDR:
582 fprintf_filtered (outfile, "address parameter register %s",
583 plongest (SYMBOL_VALUE (symbol)));
584 break;
585
586 case LOC_LOCAL:
587 fprintf_filtered (outfile, "local at offset %s",
588 hex_string (SYMBOL_VALUE (symbol)));
589 break;
590
591 case LOC_TYPEDEF:
592 break;
593
594 case LOC_LABEL:
595 fprintf_filtered (outfile, "label at ");
596 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)),
597 outfile);
598 if (section)
599 fprintf_filtered (outfile, " section %s",
600 bfd_section_name (section->the_bfd_section->owner,
601 section->the_bfd_section));
602 break;
603
604 case LOC_BLOCK:
605 fprintf_filtered (outfile, "block object ");
606 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
607 fprintf_filtered (outfile, ", ");
608 fputs_filtered (paddress (gdbarch,
609 BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
610 outfile);
611 fprintf_filtered (outfile, "..");
612 fputs_filtered (paddress (gdbarch,
613 BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
614 outfile);
615 if (section)
616 fprintf_filtered (outfile, " section %s",
617 bfd_section_name (section->the_bfd_section->owner,
618 section->the_bfd_section));
619 break;
620
621 case LOC_COMPUTED:
622 fprintf_filtered (outfile, "computed at runtime");
623 break;
624
625 case LOC_UNRESOLVED:
626 fprintf_filtered (outfile, "unresolved");
627 break;
628
629 case LOC_OPTIMIZED_OUT:
630 fprintf_filtered (outfile, "optimized out");
631 break;
632
633 default:
634 fprintf_filtered (outfile, "botched symbol class %x",
635 SYMBOL_CLASS (symbol));
636 break;
637 }
638 }
639 fprintf_filtered (outfile, "\n");
640 return 1;
641}
642
643static void
644maintenance_print_msymbols (char *args, int from_tty)
645{
646 char **argv;
647 struct ui_file *outfile;
648 struct cleanup *cleanups;
649 char *filename = DEV_TTY;
650 char *symname = NULL;
651 struct program_space *pspace;
652 struct objfile *objfile;
653
654 struct stat sym_st, obj_st;
655
656 dont_repeat ();
657
658 if (args == NULL)
659 {
660 error (_("print-msymbols takes an output file "
661 "name and optional symbol file name"));
662 }
663 argv = gdb_buildargv (args);
664 cleanups = make_cleanup_freeargv (argv);
665
666 if (argv[0] != NULL)
667 {
668 filename = argv[0];
669 /* If a second arg is supplied, it is a source file name to match on. */
670 if (argv[1] != NULL)
671 {
672 symname = gdb_realpath (argv[1]);
673 make_cleanup (xfree, symname);
674 if (symname && stat (symname, &sym_st))
675 perror_with_name (symname);
676 }
677 }
678
679 filename = tilde_expand (filename);
680 make_cleanup (xfree, filename);
681
682 outfile = gdb_fopen (filename, FOPEN_WT);
683 if (outfile == 0)
684 perror_with_name (filename);
685 make_cleanup_ui_file_delete (outfile);
686
687 ALL_PSPACES (pspace)
688 ALL_PSPACE_OBJFILES (pspace, objfile)
689 {
690 QUIT;
691 if (symname == NULL || (!stat (objfile_name (objfile), &obj_st)
692 && sym_st.st_dev == obj_st.st_dev
693 && sym_st.st_ino == obj_st.st_ino))
694 dump_msymbols (objfile, outfile);
695 }
696 fprintf_filtered (outfile, "\n\n");
697 do_cleanups (cleanups);
698}
699
700static void
701maintenance_print_objfiles (char *regexp, int from_tty)
702{
703 struct program_space *pspace;
704 struct objfile *objfile;
705
706 dont_repeat ();
707
708 if (regexp)
709 re_comp (regexp);
710
711 ALL_PSPACES (pspace)
712 ALL_PSPACE_OBJFILES (pspace, objfile)
713 {
714 QUIT;
715 if (! regexp
716 || re_exec (objfile_name (objfile)))
717 dump_objfile (objfile);
718 }
719}
720
721/* List all the symbol tables whose names match REGEXP (optional). */
722
723static void
724maintenance_info_symtabs (char *regexp, int from_tty)
725{
726 struct program_space *pspace;
727 struct objfile *objfile;
728
729 dont_repeat ();
730
731 if (regexp)
732 re_comp (regexp);
733
734 ALL_PSPACES (pspace)
735 ALL_PSPACE_OBJFILES (pspace, objfile)
736 {
737 struct compunit_symtab *cust;
738 struct symtab *symtab;
739
740 /* We don't want to print anything for this objfile until we
741 actually find a symtab whose name matches. */
742 int printed_objfile_start = 0;
743
744 ALL_OBJFILE_COMPUNITS (objfile, cust)
745 {
746 int printed_compunit_symtab_start = 0;
747
748 ALL_COMPUNIT_FILETABS (cust, symtab)
749 {
750 QUIT;
751
752 if (! regexp
753 || re_exec (symtab_to_filename_for_display (symtab)))
754 {
755 if (! printed_objfile_start)
756 {
757 printf_filtered ("{ objfile %s ", objfile_name (objfile));
758 wrap_here (" ");
759 printf_filtered ("((struct objfile *) %s)\n",
760 host_address_to_string (objfile));
761 printed_objfile_start = 1;
762 }
763 if (! printed_compunit_symtab_start)
764 {
765 printf_filtered (" { ((struct compunit_symtab *) %s)\n",
766 host_address_to_string (cust));
767 printf_filtered (" debugformat %s\n",
768 COMPUNIT_DEBUGFORMAT (cust));
769 printf_filtered (" producer %s\n",
770 COMPUNIT_PRODUCER (cust) != NULL
771 ? COMPUNIT_PRODUCER (cust)
772 : "(null)");
773 printf_filtered (" dirname %s\n",
774 COMPUNIT_DIRNAME (cust) != NULL
775 ? COMPUNIT_DIRNAME (cust)
776 : "(null)");
777 printf_filtered (" blockvector"
778 " ((struct blockvector *) %s)\n",
779 host_address_to_string
780 (COMPUNIT_BLOCKVECTOR (cust)));
781 printed_compunit_symtab_start = 1;
782 }
783
784 printf_filtered ("\t{ symtab %s ",
785 symtab_to_filename_for_display (symtab));
786 wrap_here (" ");
787 printf_filtered ("((struct symtab *) %s)\n",
788 host_address_to_string (symtab));
789 printf_filtered ("\t fullname %s\n",
790 symtab->fullname != NULL
791 ? symtab->fullname
792 : "(null)");
793 printf_filtered ("\t "
794 "linetable ((struct linetable *) %s)\n",
795 host_address_to_string (symtab->linetable));
796 printf_filtered ("\t}\n");
797 }
798 }
799
800 if (printed_compunit_symtab_start)
801 printf_filtered (" }\n");
802 }
803
804 if (printed_objfile_start)
805 printf_filtered ("}\n");
806 }
807}
808
809/* Check consistency of symtabs.
810 An example of what this checks for is NULL blockvectors.
811 They can happen if there's a bug during debug info reading.
812 GDB assumes they are always non-NULL.
813
814 Note: This does not check for psymtab vs symtab consistency.
815 Use "maint check-psymtabs" for that. */
816
817static void
818maintenance_check_symtabs (char *ignore, int from_tty)
819{
820 struct program_space *pspace;
821 struct objfile *objfile;
822
823 ALL_PSPACES (pspace)
824 ALL_PSPACE_OBJFILES (pspace, objfile)
825 {
826 struct compunit_symtab *cust;
827
828 /* We don't want to print anything for this objfile until we
829 actually find something worth printing. */
830 int printed_objfile_start = 0;
831
832 ALL_OBJFILE_COMPUNITS (objfile, cust)
833 {
834 int found_something = 0;
835 struct symtab *symtab = compunit_primary_filetab (cust);
836
837 QUIT;
838
839 if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
840 found_something = 1;
841 /* Add more checks here. */
842
843 if (found_something)
844 {
845 if (! printed_objfile_start)
846 {
847 printf_filtered ("{ objfile %s ", objfile_name (objfile));
848 wrap_here (" ");
849 printf_filtered ("((struct objfile *) %s)\n",
850 host_address_to_string (objfile));
851 printed_objfile_start = 1;
852 }
853 printf_filtered (" { symtab %s\n",
854 symtab_to_filename_for_display (symtab));
855 if (COMPUNIT_BLOCKVECTOR (cust) == NULL)
856 printf_filtered (" NULL blockvector\n");
857 printf_filtered (" }\n");
858 }
859 }
860
861 if (printed_objfile_start)
862 printf_filtered ("}\n");
863 }
864}
865
866/* Helper function for maintenance_expand_symtabs.
867 This is the name_matcher function for expand_symtabs_matching. */
868
869static int
870maintenance_expand_name_matcher (const char *symname, void *data)
871{
872 /* Since we're not searching on symbols, just return TRUE. */
873 return 1;
874}
875
876/* Helper function for maintenance_expand_symtabs.
877 This is the file_matcher function for expand_symtabs_matching. */
878
879static int
880maintenance_expand_file_matcher (const char *filename, void *data,
881 int basenames)
882{
883 const char *regexp = (const char *) data;
884
885 QUIT;
886
887 /* KISS: Only apply the regexp to the complete file name. */
888 if (basenames)
889 return 0;
890
891 if (regexp == NULL || re_exec (filename))
892 return 1;
893
894 return 0;
895}
896
897/* Expand all symbol tables whose name matches an optional regexp. */
898
899static void
900maintenance_expand_symtabs (char *args, int from_tty)
901{
902 struct program_space *pspace;
903 struct objfile *objfile;
904 struct cleanup *cleanups;
905 char **argv;
906 char *regexp = NULL;
907
908 /* We use buildargv here so that we handle spaces in the regexp
909 in a way that allows adding more arguments later. */
910 argv = gdb_buildargv (args);
911 cleanups = make_cleanup_freeargv (argv);
912
913 if (argv != NULL)
914 {
915 if (argv[0] != NULL)
916 {
917 regexp = argv[0];
918 if (argv[1] != NULL)
919 error (_("Extra arguments after regexp."));
920 }
921 }
922
923 if (regexp)
924 re_comp (regexp);
925
926 ALL_PSPACES (pspace)
927 ALL_PSPACE_OBJFILES (pspace, objfile)
928 {
929 if (objfile->sf)
930 {
931 objfile->sf->qf->expand_symtabs_matching
932 (objfile, maintenance_expand_file_matcher,
933 maintenance_expand_name_matcher, NULL, ALL_DOMAIN, regexp);
934 }
935 }
936
937 do_cleanups (cleanups);
938}
939\f
940
941/* Return the nexting depth of a block within other blocks in its symtab. */
942
943static int
944block_depth (struct block *block)
945{
946 int i = 0;
947
948 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
949 {
950 i++;
951 }
952 return i;
953}
954\f
955
956/* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
957 single line table. */
958
959static int
960maintenance_print_one_line_table (struct symtab *symtab, void *data)
961{
962 struct linetable *linetable;
963 struct objfile *objfile;
964
965 objfile = symtab->compunit_symtab->objfile;
966 printf_filtered (_("objfile: %s ((struct objfile *) %s)\n"),
967 objfile_name (objfile),
968 host_address_to_string (objfile));
969 printf_filtered (_("compunit_symtab: ((struct compunit_symtab *) %s)\n"),
970 host_address_to_string (symtab->compunit_symtab));
971 printf_filtered (_("symtab: %s ((struct symtab *) %s)\n"),
972 symtab_to_fullname (symtab),
973 host_address_to_string (symtab));
974 linetable = SYMTAB_LINETABLE (symtab);
975 printf_filtered (_("linetable: ((struct linetable *) %s):\n"),
976 host_address_to_string (linetable));
977
978 if (linetable == NULL)
979 printf_filtered (_("No line table.\n"));
980 else if (linetable->nitems <= 0)
981 printf_filtered (_("Line table has no lines.\n"));
982 else
983 {
984 int i;
985
986 /* Leave space for 6 digits of index and line number. After that the
987 tables will just not format as well. */
988 printf_filtered (_("%-6s %6s %s\n"),
989 _("INDEX"), _("LINE"), _("ADDRESS"));
990
991 for (i = 0; i < linetable->nitems; ++i)
992 {
993 struct linetable_entry *item;
994
995 item = &linetable->item [i];
996 printf_filtered (_("%-6d %6d %s\n"), i, item->line,
997 core_addr_to_string (item->pc));
998 }
999 }
1000
1001 return 0;
1002}
1003
1004/* Implement the 'maint info line-table' command. */
1005
1006static void
1007maintenance_info_line_tables (char *regexp, int from_tty)
1008{
1009 struct program_space *pspace;
1010 struct objfile *objfile;
1011
1012 dont_repeat ();
1013
1014 if (regexp != NULL)
1015 re_comp (regexp);
1016
1017 ALL_PSPACES (pspace)
1018 ALL_PSPACE_OBJFILES (pspace, objfile)
1019 {
1020 struct compunit_symtab *cust;
1021 struct symtab *symtab;
1022
1023 ALL_OBJFILE_COMPUNITS (objfile, cust)
1024 {
1025 ALL_COMPUNIT_FILETABS (cust, symtab)
1026 {
1027 QUIT;
1028
1029 if (regexp == NULL
1030 || re_exec (symtab_to_filename_for_display (symtab)))
1031 maintenance_print_one_line_table (symtab, NULL);
1032 }
1033 }
1034 }
1035}
1036
1037\f
1038
1039/* Do early runtime initializations. */
1040
1041void
1042_initialize_symmisc (void)
1043{
1044 std_in = stdin;
1045 std_out = stdout;
1046 std_err = stderr;
1047
1048 add_cmd ("symbols", class_maintenance, maintenance_print_symbols, _("\
1049Print dump of current symbol definitions.\n\
1050Entries in the full symbol table are dumped to file OUTFILE.\n\
1051If a SOURCE file is specified, dump only that file's symbols."),
1052 &maintenanceprintlist);
1053
1054 add_cmd ("msymbols", class_maintenance, maintenance_print_msymbols, _("\
1055Print dump of current minimal symbol definitions.\n\
1056Entries in the minimal symbol table are dumped to file OUTFILE.\n\
1057If a SOURCE file is specified, dump only that file's minimal symbols."),
1058 &maintenanceprintlist);
1059
1060 add_cmd ("objfiles", class_maintenance, maintenance_print_objfiles,
1061 _("Print dump of current object file definitions.\n\
1062With an argument REGEXP, list the object files with matching names."),
1063 &maintenanceprintlist);
1064
1065 add_cmd ("symtabs", class_maintenance, maintenance_info_symtabs, _("\
1066List the full symbol tables for all object files.\n\
1067This does not include information about individual symbols, blocks, or\n\
1068linetables --- just the symbol table structures themselves.\n\
1069With an argument REGEXP, list the symbol tables with matching names."),
1070 &maintenanceinfolist);
1071
1072 add_cmd ("line-table", class_maintenance, maintenance_info_line_tables, _("\
1073List the contents of all line tables, from all symbol tables.\n\
1074With an argument REGEXP, list just the line tables for the symbol\n\
1075tables with matching names."),
1076 &maintenanceinfolist);
1077
1078 add_cmd ("check-symtabs", class_maintenance, maintenance_check_symtabs,
1079 _("\
1080Check consistency of currently expanded symtabs."),
1081 &maintenancelist);
1082
1083 add_cmd ("expand-symtabs", class_maintenance, maintenance_expand_symtabs,
1084 _("Expand symbol tables.\n\
1085With an argument REGEXP, only expand the symbol tables with matching names."),
1086 &maintenancelist);
1087}
GDB Binutils - Deliverables
This page took 0.027388 seconds and 4 git commands to generate.