GDB (xrefs)
Loading...
Searching...
No Matches
symmisc.c
Go to the documentation of this file.
1/* Do various things to symbol tables (other than lookup), for GDB.
2
3 Copyright (C) 1986-2023 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 "gdbsupport/gdb_obstack.h"
30#include "language.h"
31#include "bcache.h"
32#include "block.h"
33#include "gdbsupport/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/tilde.h"
40#include <cli/cli-style.h>
41#include "gdbsupport/buildargv.h"
42
43/* Prototypes for local functions */
44
45static int block_depth (const struct block *);
46
47static void print_symbol (struct gdbarch *gdbarch, struct symbol *symbol,
48 int depth, ui_file *outfile);
49
50
51void
53{
54 int i, linetables, blockvectors;
55
56 for (struct program_space *pspace : program_spaces)
57 for (objfile *objfile : pspace->objfiles ())
58 {
59 QUIT;
60 gdb_printf (_("Statistics for '%s':\n"), objfile_name (objfile));
61 if (OBJSTAT (objfile, n_stabs) > 0)
62 gdb_printf (_(" Number of \"stab\" symbols read: %d\n"),
63 OBJSTAT (objfile, n_stabs));
64 if (objfile->per_bfd->n_minsyms > 0)
65 gdb_printf (_(" Number of \"minimal\" symbols read: %d\n"),
67 if (OBJSTAT (objfile, n_syms) > 0)
68 gdb_printf (_(" Number of \"full\" symbols read: %d\n"),
69 OBJSTAT (objfile, n_syms));
70 if (OBJSTAT (objfile, n_types) > 0)
71 gdb_printf (_(" Number of \"types\" defined: %d\n"),
72 OBJSTAT (objfile, n_types));
73
74 i = linetables = 0;
75 for (compunit_symtab *cu : objfile->compunits ())
76 {
77 for (symtab *s : cu->filetabs ())
78 {
79 i++;
80 if (s->linetable () != NULL)
81 linetables++;
82 }
83 }
84 blockvectors = std::distance (objfile->compunits ().begin (),
85 objfile->compunits ().end ());
86 gdb_printf (_(" Number of symbol tables: %d\n"), i);
87 gdb_printf (_(" Number of symbol tables with line tables: %d\n"),
88 linetables);
89 gdb_printf (_(" Number of symbol tables with blockvectors: %d\n"),
90 blockvectors);
91
92 objfile->print_stats (false);
93
94 if (OBJSTAT (objfile, sz_strtab) > 0)
95 gdb_printf (_(" Space used by string tables: %d\n"),
96 OBJSTAT (objfile, sz_strtab));
97 gdb_printf (_(" Total memory used for objfile obstack: %s\n"),
98 pulongest (obstack_memory_used (&objfile
99 ->objfile_obstack)));
100 gdb_printf (_(" Total memory used for BFD obstack: %s\n"),
101 pulongest (obstack_memory_used (&objfile->per_bfd
102 ->storage_obstack)));
103
104 gdb_printf (_(" Total memory used for string cache: %d\n"),
106 gdb_printf (_("Byte cache statistics for '%s':\n"),
108 objfile->per_bfd->string_cache.print_statistics ("string cache");
109 objfile->print_stats (true);
110 }
111}
112
113static void
115{
116 gdb_printf ("\nObject file %s: ", objfile_name (objfile));
117 gdb_printf ("Objfile at %s, bfd at %s, %d minsyms\n\n",
118 host_address_to_string (objfile),
119 host_address_to_string (objfile->obfd.get ()),
121
122 objfile->dump ();
123
124 if (objfile->compunit_symtabs != NULL)
125 {
126 gdb_printf ("Symtabs:\n");
127 for (compunit_symtab *cu : objfile->compunits ())
128 {
129 for (symtab *symtab : cu->filetabs ())
130 {
131 gdb_printf ("%s at %s",
133 host_address_to_string (symtab));
134 if (symtab->compunit ()->objfile () != objfile)
135 gdb_printf (", NOT ON CHAIN!");
136 gdb_printf ("\n");
137 }
138 }
139 gdb_printf ("\n\n");
140 }
141}
142
143/* Print minimal symbols from this objfile. */
144
145static void
146dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
147{
148 struct gdbarch *gdbarch = objfile->arch ();
149 int index;
150 char ms_type;
151
152 gdb_printf (outfile, "\nObject file %s:\n\n", objfile_name (objfile));
154 {
155 gdb_printf (outfile, "No minimal symbols found.\n");
156 return;
157 }
158 index = 0;
159 for (minimal_symbol *msymbol : objfile->msymbols ())
160 {
161 struct obj_section *section = msymbol->obj_section (objfile);
162
163 switch (msymbol->type ())
164 {
165 case mst_unknown:
166 ms_type = 'u';
167 break;
168 case mst_text:
169 ms_type = 'T';
170 break;
173 ms_type = 'i';
174 break;
176 ms_type = 'S';
177 break;
178 case mst_data:
179 ms_type = 'D';
180 break;
181 case mst_bss:
182 ms_type = 'B';
183 break;
184 case mst_abs:
185 ms_type = 'A';
186 break;
187 case mst_file_text:
188 ms_type = 't';
189 break;
190 case mst_file_data:
191 ms_type = 'd';
192 break;
193 case mst_file_bss:
194 ms_type = 'b';
195 break;
196 default:
197 ms_type = '?';
198 break;
199 }
200 gdb_printf (outfile, "[%2d] %c ", index, ms_type);
201
202 /* Use the relocated address as shown in the symbol here -- do
203 not try to respect copy relocations. */
204 CORE_ADDR addr = (CORE_ADDR (msymbol->unrelocated_address ())
205 + objfile->section_offsets[msymbol->section_index ()]);
206 gdb_puts (paddress (gdbarch, addr), outfile);
207 gdb_printf (outfile, " %s", msymbol->linkage_name ());
208 if (section)
209 {
210 if (section->the_bfd_section != NULL)
211 gdb_printf (outfile, " section %s",
212 bfd_section_name (section->the_bfd_section));
213 else
214 gdb_printf (outfile, " spurious section %ld",
215 (long) (section - objfile->sections_start));
216 }
217 if (msymbol->demangled_name () != NULL)
218 {
219 gdb_printf (outfile, " %s", msymbol->demangled_name ());
220 }
221 if (msymbol->filename)
222 gdb_printf (outfile, " %s", msymbol->filename);
223 gdb_puts ("\n", outfile);
224 index++;
225 }
226 if (objfile->per_bfd->minimal_symbol_count != index)
227 {
228 warning (_("internal error: minimal symbol count %d != %d"),
230 }
231 gdb_printf (outfile, "\n");
232}
233
234static void
235dump_symtab_1 (struct symtab *symtab, struct ui_file *outfile)
236{
237 struct objfile *objfile = symtab->compunit ()->objfile ();
238 struct gdbarch *gdbarch = objfile->arch ();
239 const struct linetable *l;
240 int depth;
241
242 gdb_printf (outfile, "\nSymtab for file %s at %s\n",
244 host_address_to_string (symtab));
245
246 if (symtab->compunit ()->dirname () != NULL)
247 gdb_printf (outfile, "Compilation directory is %s\n",
248 symtab->compunit ()->dirname ());
249 gdb_printf (outfile, "Read from object file %s (%s)\n",
251 host_address_to_string (objfile));
252 gdb_printf (outfile, "Language: %s\n",
254
255 /* First print the line table. */
256 l = symtab->linetable ();
257 if (l)
258 {
259 gdb_printf (outfile, "\nLine table:\n\n");
260 int len = l->nitems;
261 for (int i = 0; i < len; i++)
262 {
263 gdb_printf (outfile, " line %d at ", l->item[i].line);
264 gdb_puts (paddress (gdbarch, l->item[i].pc (objfile)), outfile);
265 if (l->item[i].is_stmt)
266 gdb_printf (outfile, "\t(stmt)");
267 gdb_printf (outfile, "\n");
268 }
269 }
270 /* Now print the block info, but only for compunit symtabs since we will
271 print lots of duplicate info otherwise. */
273 {
274 gdb_printf (outfile, "\nBlockvector:\n\n");
275 const blockvector *bv = symtab->compunit ()->blockvector ();
276 for (int i = 0; i < bv->num_blocks (); i++)
277 {
278 const block *b = bv->block (i);
279 depth = block_depth (b) * 2;
280 gdb_printf (outfile, "%*sblock #%03d, object at %s",
281 depth, "", i,
282 host_address_to_string (b));
283 if (b->superblock ())
284 gdb_printf (outfile, " under %s",
285 host_address_to_string (b->superblock ()));
286 /* drow/2002-07-10: We could save the total symbols count
287 even if we're using a hashtable, but nothing else but this message
288 wants it. */
289 gdb_printf (outfile, ", %d symbols in ",
290 mdict_size (b->multidict ()));
291 gdb_puts (paddress (gdbarch, b->start ()), outfile);
292 gdb_printf (outfile, "..");
293 gdb_puts (paddress (gdbarch, b->end ()), outfile);
294 if (b->function ())
295 {
296 gdb_printf (outfile, ", function %s",
297 b->function ()->linkage_name ());
298 if (b->function ()->demangled_name () != NULL)
299 {
300 gdb_printf (outfile, ", %s",
301 b->function ()->demangled_name ());
302 }
303 }
304 gdb_printf (outfile, "\n");
305 /* Now print each symbol in this block (in no particular order, if
306 we're using a hashtable). Note that we only want this
307 block, not any blocks from included symtabs. */
308 for (struct symbol *sym : b->multidict_symbols ())
309 {
310 try
311 {
312 print_symbol (gdbarch, sym, depth + 1, outfile);
313 }
314 catch (const gdb_exception_error &ex)
315 {
317 "Error printing symbol:\n");
318 }
319 }
320 }
321 gdb_printf (outfile, "\n");
322 }
323 else
324 {
325 compunit_symtab *compunit = symtab->compunit ();
326 const char *compunit_filename
328
329 gdb_printf (outfile,
330 "\nBlockvector same as owning compunit: %s\n\n",
331 compunit_filename);
332 }
333
334 /* Print info about the user of this compunit_symtab, and the
335 compunit_symtabs included by this one. */
337 {
338 struct compunit_symtab *cust = symtab->compunit ();
339
340 if (cust->user != nullptr)
341 {
342 const char *addr
343 = host_address_to_string (cust->user->primary_filetab ());
344 gdb_printf (outfile, "Compunit user: %s\n", addr);
345 }
346 if (cust->includes != nullptr)
347 for (int i = 0; ; ++i)
348 {
349 struct compunit_symtab *include = cust->includes[i];
350 if (include == nullptr)
351 break;
352 const char *addr
353 = host_address_to_string (include->primary_filetab ());
354 gdb_printf (outfile, "Compunit include: %s\n", addr);
355 }
356 }
357}
358
359static void
360dump_symtab (struct symtab *symtab, struct ui_file *outfile)
361{
362 /* Set the current language to the language of the symtab we're dumping
363 because certain routines used during dump_symtab() use the current
364 language to print an image of the symbol. We'll restore it later.
365 But use only real languages, not placeholders. */
367 {
370 dump_symtab_1 (symtab, outfile);
371 }
372 else
373 dump_symtab_1 (symtab, outfile);
374}
375
376static void
377maintenance_print_symbols (const char *args, int from_tty)
378{
379 struct ui_file *outfile = gdb_stdout;
380 char *address_arg = NULL, *source_arg = NULL, *objfile_arg = NULL;
381 int i, outfile_idx;
382
383 dont_repeat ();
384
385 gdb_argv argv (args);
386
387 for (i = 0; argv != NULL && argv[i] != NULL; ++i)
388 {
389 if (strcmp (argv[i], "-pc") == 0)
390 {
391 if (argv[i + 1] == NULL)
392 error (_("Missing pc value"));
393 address_arg = argv[++i];
394 }
395 else if (strcmp (argv[i], "-source") == 0)
396 {
397 if (argv[i + 1] == NULL)
398 error (_("Missing source file"));
399 source_arg = argv[++i];
400 }
401 else if (strcmp (argv[i], "-objfile") == 0)
402 {
403 if (argv[i + 1] == NULL)
404 error (_("Missing objfile name"));
405 objfile_arg = argv[++i];
406 }
407 else if (strcmp (argv[i], "--") == 0)
408 {
409 /* End of options. */
410 ++i;
411 break;
412 }
413 else if (argv[i][0] == '-')
414 {
415 /* Future proofing: Don't allow OUTFILE to begin with "-". */
416 error (_("Unknown option: %s"), argv[i]);
417 }
418 else
419 break;
420 }
421 outfile_idx = i;
422
423 if (address_arg != NULL && source_arg != NULL)
424 error (_("Must specify at most one of -pc and -source"));
425
426 stdio_file arg_outfile;
427
428 if (argv != NULL && argv[outfile_idx] != NULL)
429 {
430 if (argv[outfile_idx + 1] != NULL)
431 error (_("Junk at end of command"));
432 gdb::unique_xmalloc_ptr<char> outfile_name
433 (tilde_expand (argv[outfile_idx]));
434 if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
435 perror_with_name (outfile_name.get ());
436 outfile = &arg_outfile;
437 }
438
439 if (address_arg != NULL)
440 {
441 CORE_ADDR pc = parse_and_eval_address (address_arg);
442 struct symtab *s = find_pc_line_symtab (pc);
443
444 if (s == NULL)
445 error (_("No symtab for address: %s"), address_arg);
446 dump_symtab (s, outfile);
447 }
448 else
449 {
450 int found = 0;
451
453 {
454 int print_for_objfile = 1;
455
456 if (objfile_arg != NULL)
457 print_for_objfile
459 objfile_arg);
460 if (!print_for_objfile)
461 continue;
462
463 for (compunit_symtab *cu : objfile->compunits ())
464 {
465 for (symtab *s : cu->filetabs ())
466 {
467 int print_for_source = 0;
468
469 QUIT;
470 if (source_arg != NULL)
471 {
472 print_for_source
474 (symtab_to_filename_for_display (s), source_arg);
475 found = 1;
476 }
477 if (source_arg == NULL
478 || print_for_source)
479 dump_symtab (s, outfile);
480 }
481 }
482 }
483
484 if (source_arg != NULL && !found)
485 error (_("No symtab for source file: %s"), source_arg);
486 }
487}
488
489/* Print symbol SYMBOL on OUTFILE. DEPTH says how far to indent. */
490
491static void
493 int depth, ui_file *outfile)
494{
495 struct obj_section *section;
496
497 if (symbol->is_objfile_owned ())
498 section = symbol->obj_section (symbol->objfile ());
499 else
500 section = NULL;
501
502 print_spaces (depth, outfile);
503 if (symbol->domain () == LABEL_DOMAIN)
504 {
505 gdb_printf (outfile, "label %s at ", symbol->print_name ());
507 outfile);
508 if (section)
509 gdb_printf (outfile, " section %s\n",
510 bfd_section_name (section->the_bfd_section));
511 else
512 gdb_printf (outfile, "\n");
513 return;
514 }
515
516 if (symbol->domain () == STRUCT_DOMAIN)
517 {
518 if (symbol->type ()->name ())
519 {
520 current_language->print_type (symbol->type (), "", outfile, 1, depth,
522 }
523 else
524 {
525 gdb_printf (outfile, "%s %s = ",
526 (symbol->type ()->code () == TYPE_CODE_ENUM
527 ? "enum"
528 : (symbol->type ()->code () == TYPE_CODE_STRUCT
529 ? "struct" : "union")),
530 symbol->linkage_name ());
531 current_language->print_type (symbol->type (), "", outfile, 1, depth,
533 }
534 gdb_printf (outfile, ";\n");
535 }
536 else
537 {
538 if (symbol->aclass () == LOC_TYPEDEF)
539 gdb_printf (outfile, "typedef ");
540 if (symbol->type ())
541 {
542 /* Print details of types, except for enums where it's clutter. */
544 outfile,
545 symbol->type ()->code () != TYPE_CODE_ENUM,
546 depth,
548 gdb_printf (outfile, "; ");
549 }
550 else
551 gdb_printf (outfile, "%s ", symbol->print_name ());
552
553 switch (symbol->aclass ())
554 {
555 case LOC_CONST:
556 gdb_printf (outfile, "const %s (%s)",
557 plongest (symbol->value_longest ()),
558 hex_string (symbol->value_longest ()));
559 break;
560
561 case LOC_CONST_BYTES:
562 {
563 unsigned i;
564 struct type *type = check_typedef (symbol->type ());
565
566 gdb_printf (outfile, "const %s hex bytes:",
567 pulongest (type->length ()));
568 for (i = 0; i < type->length (); i++)
569 gdb_printf (outfile, " %02x",
570 (unsigned) symbol->value_bytes ()[i]);
571 }
572 break;
573
574 case LOC_STATIC:
575 gdb_printf (outfile, "static at ");
576 gdb_puts (paddress (gdbarch, symbol->value_address ()), outfile);
577 if (section)
578 gdb_printf (outfile, " section %s",
579 bfd_section_name (section->the_bfd_section));
580 break;
581
582 case LOC_REGISTER:
583 if (symbol->is_argument ())
584 gdb_printf (outfile, "parameter register %s",
585 plongest (symbol->value_longest ()));
586 else
587 gdb_printf (outfile, "register %s",
588 plongest (symbol->value_longest ()));
589 break;
590
591 case LOC_ARG:
592 gdb_printf (outfile, "arg at offset %s",
593 hex_string (symbol->value_longest ()));
594 break;
595
596 case LOC_REF_ARG:
597 gdb_printf (outfile, "reference arg at %s",
598 hex_string (symbol->value_longest ()));
599 break;
600
601 case LOC_REGPARM_ADDR:
602 gdb_printf (outfile, "address parameter register %s",
603 plongest (symbol->value_longest ()));
604 break;
605
606 case LOC_LOCAL:
607 gdb_printf (outfile, "local at offset %s",
608 hex_string (symbol->value_longest ()));
609 break;
610
611 case LOC_TYPEDEF:
612 break;
613
614 case LOC_LABEL:
615 gdb_printf (outfile, "label at ");
616 gdb_puts (paddress (gdbarch, symbol->value_address ()), outfile);
617 if (section)
618 gdb_printf (outfile, " section %s",
619 bfd_section_name (section->the_bfd_section));
620 break;
621
622 case LOC_BLOCK:
624 (outfile, "block object %s, %s..%s",
625 host_address_to_string (symbol->value_block ()),
628 if (section)
629 gdb_printf (outfile, " section %s",
630 bfd_section_name (section->the_bfd_section));
631 break;
632
633 case LOC_COMPUTED:
634 gdb_printf (outfile, "computed at runtime");
635 break;
636
637 case LOC_UNRESOLVED:
638 gdb_printf (outfile, "unresolved");
639 break;
640
642 gdb_printf (outfile, "optimized out");
643 break;
644
645 default:
646 gdb_printf (outfile, "botched symbol class %x",
647 symbol->aclass ());
648 break;
649 }
650 }
651 gdb_printf (outfile, "\n");
652}
653
654static void
655maintenance_print_msymbols (const char *args, int from_tty)
656{
657 struct ui_file *outfile = gdb_stdout;
658 char *objfile_arg = NULL;
659 int i, outfile_idx;
660
661 dont_repeat ();
662
663 gdb_argv argv (args);
664
665 for (i = 0; argv != NULL && argv[i] != NULL; ++i)
666 {
667 if (strcmp (argv[i], "-objfile") == 0)
668 {
669 if (argv[i + 1] == NULL)
670 error (_("Missing objfile name"));
671 objfile_arg = argv[++i];
672 }
673 else if (strcmp (argv[i], "--") == 0)
674 {
675 /* End of options. */
676 ++i;
677 break;
678 }
679 else if (argv[i][0] == '-')
680 {
681 /* Future proofing: Don't allow OUTFILE to begin with "-". */
682 error (_("Unknown option: %s"), argv[i]);
683 }
684 else
685 break;
686 }
687 outfile_idx = i;
688
689 stdio_file arg_outfile;
690
691 if (argv != NULL && argv[outfile_idx] != NULL)
692 {
693 if (argv[outfile_idx + 1] != NULL)
694 error (_("Junk at end of command"));
695 gdb::unique_xmalloc_ptr<char> outfile_name
696 (tilde_expand (argv[outfile_idx]));
697 if (!arg_outfile.open (outfile_name.get (), FOPEN_WT))
698 perror_with_name (outfile_name.get ());
699 outfile = &arg_outfile;
700 }
701
703 {
704 QUIT;
705 if (objfile_arg == NULL
707 dump_msymbols (objfile, outfile);
708 }
709}
710
711static void
712maintenance_print_objfiles (const char *regexp, int from_tty)
713{
714 dont_repeat ();
715
716 if (regexp)
717 re_comp (regexp);
718
719 for (struct program_space *pspace : program_spaces)
720 for (objfile *objfile : pspace->objfiles ())
721 {
722 QUIT;
723 if (! regexp
724 || re_exec (objfile_name (objfile)))
726 }
727}
728
729/* List all the symbol tables whose names match REGEXP (optional). */
730
731static void
732maintenance_info_symtabs (const char *regexp, int from_tty)
733{
734 dont_repeat ();
735
736 if (regexp)
737 re_comp (regexp);
738
739 for (struct program_space *pspace : program_spaces)
740 for (objfile *objfile : pspace->objfiles ())
741 {
742 /* We don't want to print anything for this objfile until we
743 actually find a symtab whose name matches. */
744 int printed_objfile_start = 0;
745
746 for (compunit_symtab *cust : objfile->compunits ())
747 {
748 int printed_compunit_symtab_start = 0;
749
750 for (symtab *symtab : cust->filetabs ())
751 {
752 QUIT;
753
754 if (! regexp
756 {
757 if (! printed_objfile_start)
758 {
759 gdb_printf ("{ objfile %s ", objfile_name (objfile));
760 gdb_stdout->wrap_here (2);
761 gdb_printf ("((struct objfile *) %s)\n",
762 host_address_to_string (objfile));
763 printed_objfile_start = 1;
764 }
765 if (! printed_compunit_symtab_start)
766 {
767 gdb_printf (" { ((struct compunit_symtab *) %s)\n",
768 host_address_to_string (cust));
769 gdb_printf (" debugformat %s\n",
770 cust->debugformat ());
771 gdb_printf (" producer %s\n",
772 (cust->producer () != nullptr
773 ? cust->producer () : "(null)"));
774 gdb_printf (" name %s\n", cust->name);
775 gdb_printf (" dirname %s\n",
776 (cust->dirname () != NULL
777 ? cust->dirname () : "(null)"));
778 gdb_printf (" blockvector"
779 " ((struct blockvector *) %s)\n",
780 host_address_to_string
781 (cust->blockvector ()));
782 gdb_printf (" user"
783 " ((struct compunit_symtab *) %s)\n",
784 cust->user != nullptr
785 ? host_address_to_string (cust->user)
786 : "(null)");
787 if (cust->includes != nullptr)
788 {
789 gdb_printf (" ( includes\n");
790 for (int i = 0; ; ++i)
791 {
792 struct compunit_symtab *include
793 = cust->includes[i];
794 if (include == nullptr)
795 break;
796 const char *addr
797 = host_address_to_string (include);
798 gdb_printf (" (%s %s)\n",
799 "(struct compunit_symtab *)",
800 addr);
801 }
802 gdb_printf (" )\n");
803 }
804 printed_compunit_symtab_start = 1;
805 }
806
807 gdb_printf ("\t{ symtab %s ",
809 gdb_stdout->wrap_here (4);
810 gdb_printf ("((struct symtab *) %s)\n",
811 host_address_to_string (symtab));
812 gdb_printf ("\t fullname %s\n",
813 symtab->fullname != NULL
815 : "(null)");
816 gdb_printf ("\t "
817 "linetable ((struct linetable *) %s)\n",
818 host_address_to_string
819 (symtab->linetable ()));
820 gdb_printf ("\t}\n");
821 }
822 }
823
824 if (printed_compunit_symtab_start)
825 gdb_printf (" }\n");
826 }
827
828 if (printed_objfile_start)
829 gdb_printf ("}\n");
830 }
831}
832
833/* Check consistency of symtabs.
834 An example of what this checks for is NULL blockvectors.
835 They can happen if there's a bug during debug info reading.
836 GDB assumes they are always non-NULL.
837
838 Note: This does not check for psymtab vs symtab consistency.
839 Use "maint check-psymtabs" for that. */
840
841static void
842maintenance_check_symtabs (const char *ignore, int from_tty)
843{
844 for (struct program_space *pspace : program_spaces)
845 for (objfile *objfile : pspace->objfiles ())
846 {
847 /* We don't want to print anything for this objfile until we
848 actually find something worth printing. */
849 int printed_objfile_start = 0;
850
851 for (compunit_symtab *cust : objfile->compunits ())
852 {
853 int found_something = 0;
854 struct symtab *symtab = cust->primary_filetab ();
855
856 QUIT;
857
858 if (cust->blockvector () == NULL)
859 found_something = 1;
860 /* Add more checks here. */
861
862 if (found_something)
863 {
864 if (! printed_objfile_start)
865 {
866 gdb_printf ("{ objfile %s ", objfile_name (objfile));
867 gdb_stdout->wrap_here (2);
868 gdb_printf ("((struct objfile *) %s)\n",
869 host_address_to_string (objfile));
870 printed_objfile_start = 1;
871 }
872 gdb_printf (" { symtab %s\n",
874 if (cust->blockvector () == NULL)
875 gdb_printf (" NULL blockvector\n");
876 gdb_printf (" }\n");
877 }
878 }
879
880 if (printed_objfile_start)
881 gdb_printf ("}\n");
882 }
883}
884
885/* Expand all symbol tables whose name matches an optional regexp. */
886
887static void
888maintenance_expand_symtabs (const char *args, int from_tty)
889{
890 char *regexp = NULL;
891
892 /* We use buildargv here so that we handle spaces in the regexp
893 in a way that allows adding more arguments later. */
894 gdb_argv argv (args);
895
896 if (argv != NULL)
897 {
898 if (argv[0] != NULL)
899 {
900 regexp = argv[0];
901 if (argv[1] != NULL)
902 error (_("Extra arguments after regexp."));
903 }
904 }
905
906 if (regexp)
907 re_comp (regexp);
908
909 for (struct program_space *pspace : program_spaces)
910 for (objfile *objfile : pspace->objfiles ())
912 ([&] (const char *filename, bool basenames)
913 {
914 /* KISS: Only apply the regexp to the complete file name. */
915 return (!basenames
916 && (regexp == NULL || re_exec (filename)));
917 },
918 NULL,
919 NULL,
920 NULL,
923 ALL_DOMAIN);
924}
925
926
927/* Return the nexting depth of a block within other blocks in its symtab. */
928
929static int
930block_depth (const struct block *block)
931{
932 int i = 0;
933
934 while ((block = block->superblock ()) != NULL)
935 {
936 i++;
937 }
938 return i;
939}
940
941
942/* Used by MAINTENANCE_INFO_LINE_TABLES to print the information about a
943 single line table. */
944
945static int
947{
948 const struct linetable *linetable;
949 struct objfile *objfile;
950
951 objfile = symtab->compunit ()->objfile ();
952 gdb_printf (_("objfile: %ps ((struct objfile *) %s)\n"),
955 host_address_to_string (objfile));
956 gdb_printf (_("compunit_symtab: %s ((struct compunit_symtab *) %s)\n"),
957 symtab->compunit ()->name,
958 host_address_to_string (symtab->compunit ()));
959 gdb_printf (_("symtab: %ps ((struct symtab *) %s)\n"),
962 host_address_to_string (symtab));
964 gdb_printf (_("linetable: ((struct linetable *) %s):\n"),
965 host_address_to_string (linetable));
966
967 if (linetable == NULL)
968 gdb_printf (_("No line table.\n"));
969 else if (linetable->nitems <= 0)
970 gdb_printf (_("Line table has no lines.\n"));
971 else
972 {
973 /* Leave space for 6 digits of index and line number. After that the
974 tables will just not format as well. */
975 struct ui_out *uiout = current_uiout;
976 ui_out_emit_table table_emitter (uiout, 6, -1, "line-table");
977 uiout->table_header (6, ui_left, "index", _("INDEX"));
978 uiout->table_header (6, ui_left, "line", _("LINE"));
979 uiout->table_header (18, ui_left, "rel-address", _("REL-ADDRESS"));
980 uiout->table_header (18, ui_left, "unrel-address", _("UNREL-ADDRESS"));
981 uiout->table_header (7, ui_left, "is-stmt", _("IS-STMT"));
982 uiout->table_header (12, ui_left, "prologue-end", _("PROLOGUE-END"));
983 uiout->table_body ();
984
985 for (int i = 0; i < linetable->nitems; ++i)
986 {
987 const linetable_entry *item;
988
989 item = &linetable->item [i];
990 ui_out_emit_tuple tuple_emitter (uiout, nullptr);
991 uiout->field_signed ("index", i);
992 if (item->line > 0)
993 uiout->field_signed ("line", item->line);
994 else
995 uiout->field_string ("line", _("END"));
996 uiout->field_core_addr ("rel-address", objfile->arch (),
997 item->pc (objfile));
998 uiout->field_core_addr ("unrel-address", objfile->arch (),
999 CORE_ADDR (item->unrelocated_pc ()));
1000 uiout->field_string ("is-stmt", item->is_stmt ? "Y" : "");
1001 uiout->field_string ("prologue-end", item->prologue_end ? "Y" : "");
1002 uiout->text ("\n");
1003 }
1004 }
1005
1006 return 0;
1007}
1008
1009/* Implement the 'maint info line-table' command. */
1010
1011static void
1012maintenance_info_line_tables (const char *regexp, int from_tty)
1013{
1014 dont_repeat ();
1015
1016 if (regexp != NULL)
1017 re_comp (regexp);
1018
1019 for (struct program_space *pspace : program_spaces)
1020 for (objfile *objfile : pspace->objfiles ())
1021 {
1022 for (compunit_symtab *cust : objfile->compunits ())
1023 {
1024 for (symtab *symtab : cust->filetabs ())
1025 {
1026 QUIT;
1027
1028 if (regexp == NULL
1030 {
1032 gdb_printf ("\n");
1033 }
1034 }
1035 }
1036 }
1037}
1038
1039
1040
1041/* Do early runtime initializations. */
1042
1043void _initialize_symmisc ();
1044void
1046{
1048Print dump of current symbol definitions.\n\
1049Usage: mt print symbols [-pc ADDRESS] [--] [OUTFILE]\n\
1050 mt print symbols [-objfile OBJFILE] [-source SOURCE] [--] [OUTFILE]\n\
1051Entries in the full symbol table are dumped to file OUTFILE,\n\
1052or the terminal if OUTFILE is unspecified.\n\
1053If ADDRESS is provided, dump only the symbols for the file with code at that address.\n\
1054If SOURCE is provided, dump only that file's symbols.\n\
1055If OBJFILE is provided, dump only that object file's symbols."),
1057
1059Print dump of current minimal symbol definitions.\n\
1060Usage: mt print msymbols [-objfile OBJFILE] [--] [OUTFILE]\n\
1061Entries in the minimal symbol table are dumped to file OUTFILE,\n\
1062or the terminal if OUTFILE is unspecified.\n\
1063If OBJFILE is provided, dump only that file's minimal symbols."),
1065
1067 _("Print dump of current object file definitions.\n\
1068With an argument REGEXP, list the object files with matching names."),
1070
1072List the full symbol tables for all object files.\n\
1073This does not include information about individual symbols, blocks, or\n\
1074linetables --- just the symbol table structures themselves.\n\
1075With an argument REGEXP, list the symbol tables with matching names."),
1077
1079List the contents of all line tables, from all symbol tables.\n\
1080With an argument REGEXP, list just the line tables for the symbol\n\
1081tables with matching names."),
1083
1085 _("\
1086Check consistency of currently expanded symtabs."),
1088
1090 _("Expand symbol tables.\n\
1091With an argument REGEXP, only expand the symbol tables with matching names."),
1093}
ui_file_style style() const
Definition cli-style.c:169
bool open(const char *name, const char *mode)
Definition ui-file.c:263
void field_core_addr(const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition ui-out.c:478
void field_string(const char *fldname, const char *string, const ui_file_style &style=ui_file_style())
Definition ui-out.c:511
void field_signed(const char *fldname, LONGEST value)
Definition ui-out.c:437
void text(const char *string)
Definition ui-out.c:566
void table_header(int width, ui_align align, const std::string &col_name, const std::string &col_hdr)
Definition ui-out.c:363
void table_body()
Definition ui-out.c:376
struct cmd_list_element * maintenanceprintlist
Definition cli-cmds.c:151
struct cmd_list_element * maintenancelist
Definition cli-cmds.c:143
struct cmd_list_element * maintenanceinfolist
Definition cli-cmds.c:147
struct cmd_list_element * add_cmd(const char *name, enum command_class theclass, const char *doc, struct cmd_list_element **list)
Definition cli-decode.c:233
cli_style_option file_name_style
void dont_repeat()
Definition top.c:696
@ class_maintenance
Definition command.h:65
EXTERN_C char * re_comp(const char *)
@ language_unknown
Definition defs.h:212
#define QUIT
Definition defs.h:187
int mdict_size(const struct multidictionary *mdict)
CORE_ADDR parse_and_eval_address(const char *exp)
Definition eval.c:52
void exception_fprintf(struct ui_file *file, const struct gdb_exception &e, const char *prefix,...)
Definition exceptions.c:116
struct type * check_typedef(struct type *type)
Definition gdbtypes.c:2966
static void set_language(const char *language)
Definition language.c:140
const char * language_str(enum language lang)
Definition language.c:449
const struct language_defn * current_language
Definition language.c:82
const char * objfile_name(const struct objfile *objfile)
Definition objfiles.c:1259
#define OBJSTAT(objfile, expr)
Definition objfiles.h:169
struct program_space * current_program_space
Definition progspace.c:40
std::vector< struct program_space * > program_spaces
Definition progspace.c:37
@ SEARCH_GLOBAL_BLOCK
@ SEARCH_STATIC_BLOCK
const char * symtab_to_fullname(struct symtab *s)
Definition source.c:1234
const char * symtab_to_filename_for_display(struct symtab *symtab)
Definition source.c:1269
Definition block.h:109
const block * superblock() const
Definition block.h:135
multidictionary * multidict() const
Definition block.h:143
CORE_ADDR start() const
Definition block.h:111
iterator_range< mdict_iterator_wrapper > multidict_symbols() const
Definition block.h:147
CORE_ADDR end() const
Definition block.h:119
symbol * function() const
Definition block.h:127
struct block * block(size_t i)
Definition block.h:374
int num_blocks() const
Definition block.h:393
symtab * primary_filetab() const
Definition symtab.c:415
struct blockvector * blockvector()
Definition symtab.h:1847
struct compunit_symtab * user
Definition symtab.h:1981
const char * name
Definition symtab.h:1919
struct compunit_symtab ** includes
Definition symtab.h:1975
struct objfile * objfile() const
Definition symtab.h:1788
const char * dirname() const
Definition symtab.h:1837
void print_statistics(const char *type)
Definition bcache.c:259
int memory_used()
Definition bcache.c:384
const char * demangled_name
Definition symtab.h:589
const char * print_name() const
Definition symtab.h:475
struct obj_section * obj_section(const struct objfile *objfile) const
Definition symtab.c:1117
const char * linkage_name() const
Definition symtab.h:460
virtual void print_type(struct type *type, const char *varstring, struct ui_file *stream, int show, int level, const struct type_print_options *flags) const =0
Definition symtab.h:1596
bool is_stmt
Definition symtab.h:1625
int line
Definition symtab.h:1622
CORE_ADDR pc(const struct objfile *objfile) const
Definition symtab.c:336
unrelocated_addr unrelocated_pc() const
Definition symtab.h:1602
bool prologue_end
Definition symtab.h:1629
int nitems
Definition symtab.h:1656
struct linetable_entry item[1]
Definition symtab.h:1661
CORE_ADDR addr() const
Definition objfiles.h:385
struct bfd_section * the_bfd_section
Definition objfiles.h:398
auto_obstack storage_obstack
Definition objfiles.h:256
gdb::bcache string_cache
Definition objfiles.h:260
struct obj_section * sections_start
Definition objfiles.h:812
struct compunit_symtab * compunit_symtabs
Definition objfiles.h:733
struct gdbarch * arch() const
Definition objfiles.h:507
struct objfile_per_bfd_storage * per_bfd
Definition objfiles.h:744
bool expand_symtabs_matching(gdb::function_view< expand_symtabs_file_matcher_ftype > file_matcher, const lookup_name_info *lookup_name, gdb::function_view< expand_symtabs_symbol_matcher_ftype > symbol_matcher, gdb::function_view< expand_symtabs_exp_notify_ftype > expansion_notify, block_search_flags search_flags, domain_enum domain, enum search_domain kind)
void print_stats(bool print_bcache)
objfile(gdb_bfd_ref_ptr, const char *, objfile_flags)
Definition objfiles.c:313
gdb_bfd_ref_ptr obfd
Definition objfiles.h:740
compunit_symtab_range compunits()
Definition objfiles.h:451
void dump()
::section_offsets section_offsets
Definition objfiles.h:786
msymbols_range msymbols()
Definition objfiles.h:464
objfiles_range objfiles()
Definition progspace.h:209
const block * value_block() const
Definition symtab.h:1549
address_class aclass() const
Definition symtab.h:1274
struct type * type() const
Definition symtab.h:1331
domain_enum domain() const
Definition symtab.h:1286
LONGEST value_longest() const
Definition symtab.h:1351
const gdb_byte * value_bytes() const
Definition symtab.h:1374
bool is_objfile_owned() const
Definition symtab.h:1296
bool is_argument() const
Definition symtab.h:1306
CORE_ADDR value_address() const
Definition symtab.h:1361
struct objfile * objfile() const
Definition symtab.c:6482
enum language language() const
Definition symtab.h:1697
char * fullname
Definition symtab.h:1744
struct compunit_symtab * compunit() const
Definition symtab.h:1677
const struct linetable * linetable() const
Definition symtab.h:1687
const char * filename
Definition symtab.h:1725
type_code code() const
Definition gdbtypes.h:956
ULONGEST length() const
Definition gdbtypes.h:983
const char * name() const
Definition gdbtypes.h:968
static void print_symbol(struct gdbarch *gdbarch, struct symbol *symbol, int depth, ui_file *outfile)
Definition symmisc.c:492
static void maintenance_expand_symtabs(const char *args, int from_tty)
Definition symmisc.c:888
static void maintenance_print_msymbols(const char *args, int from_tty)
Definition symmisc.c:655
static void dump_objfile(struct objfile *objfile)
Definition symmisc.c:114
static int block_depth(const struct block *)
Definition symmisc.c:930
static void dump_msymbols(struct objfile *objfile, struct ui_file *outfile)
Definition symmisc.c:146
void print_objfile_statistics(void)
Definition symmisc.c:52
static void maintenance_print_symbols(const char *args, int from_tty)
Definition symmisc.c:377
static void maintenance_check_symtabs(const char *ignore, int from_tty)
Definition symmisc.c:842
static int maintenance_print_one_line_table(struct symtab *symtab, void *data)
Definition symmisc.c:946
static void maintenance_print_objfiles(const char *regexp, int from_tty)
Definition symmisc.c:712
static void dump_symtab_1(struct symtab *symtab, struct ui_file *outfile)
Definition symmisc.c:235
static void maintenance_info_symtabs(const char *regexp, int from_tty)
Definition symmisc.c:732
void _initialize_symmisc()
Definition symmisc.c:1045
static void dump_symtab(struct symtab *symtab, struct ui_file *outfile)
Definition symmisc.c:360
static void maintenance_info_line_tables(const char *regexp, int from_tty)
Definition symmisc.c:1012
struct symtab * find_pc_line_symtab(CORE_ADDR pc)
Definition symtab.c:3317
bool compare_filenames_for_search(const char *filename, const char *search_name)
Definition symtab.c:489
@ ALL_DOMAIN
Definition symtab.h:960
static bool is_main_symtab_of_compunit_symtab(struct symtab *symtab)
Definition symtab.h:1989
@ LOC_STATIC
Definition symtab.h:979
@ LOC_BLOCK
Definition symtab.h:1028
@ LOC_LABEL
Definition symtab.h:1022
@ LOC_REGISTER
Definition symtab.h:993
@ LOC_REF_ARG
Definition symtab.h:1001
@ LOC_UNRESOLVED
Definition symtab.h:1057
@ LOC_LOCAL
Definition symtab.h:1013
@ LOC_CONST
Definition symtab.h:975
@ LOC_CONST_BYTES
Definition symtab.h:1033
@ LOC_OPTIMIZED_OUT
Definition symtab.h:1062
@ LOC_TYPEDEF
Definition symtab.h:1018
@ LOC_REGPARM_ADDR
Definition symtab.h:1009
@ LOC_COMPUTED
Definition symtab.h:1066
@ LOC_ARG
Definition symtab.h:997
@ mst_data_gnu_ifunc
Definition symtab.h:690
@ mst_abs
Definition symtab.h:696
@ mst_bss
Definition symtab.h:695
@ mst_data
Definition symtab.h:694
@ mst_unknown
Definition symtab.h:671
@ mst_solib_trampoline
Definition symtab.h:705
@ mst_file_text
Definition symtab.h:708
@ mst_file_data
Definition symtab.h:709
@ mst_text
Definition symtab.h:672
@ mst_text_gnu_ifunc
Definition symtab.h:681
@ mst_file_bss
Definition symtab.h:710
@ STRUCT_DOMAIN
Definition symtab.h:916
@ LABEL_DOMAIN
Definition symtab.h:924
@ UNDEF_DOMAIN
Definition symtab.h:905
const struct type_print_options type_print_raw_options
Definition typeprint.c:41
static styled_string_s * styled_string(const ui_file_style &style, const char *str, styled_string_s &&tmp={})
Definition ui-out.h:151
@ ui_left
Definition ui-out.h:45
#define current_uiout
Definition ui-out.h:40
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition utils.c:3166
void print_spaces(int n, struct ui_file *stream)
Definition utils.c:1968
void gdb_printf(struct ui_file *stream, const char *format,...)
Definition utils.c:1886
void gdb_puts(const char *linebuffer, struct ui_file *stream)
Definition utils.c:1809
#define gdb_stderr
Definition utils.h:187
#define gdb_stdout
Definition utils.h:182