1 /* Do various things to symbol tables (other than lookup), for GDB.
2
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004 Free Software
5 Foundation, Inc.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
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.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
23
24 #include "defs.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "bfd.h"
28 #include "symfile.h"
29 #include "objfiles.h"
30 #include "breakpoint.h"
31 #include "command.h"
32 #include "gdb_obstack.h"
33 #include "exceptions.h"
34 #include "language.h"
35 #include "bcache.h"
36 #include "block.h"
37 #include "gdb_regex.h"
38 #include "gdb_stat.h"
39 #include "dictionary.h"
40
41 #include "gdb_string.h"
42 #include "readline/readline.h"
43
44 #ifndef DEV_TTY
45 #define DEV_TTY "/dev/tty"
46 #endif
47
48 /* Unfortunately for debugging, stderr is usually a macro. This is painful
49 when calling functions that take FILE *'s from the debugger.
50 So we make a variable which has the same value and which is accessible when
51 debugging GDB with itself. Because stdin et al need not be constants,
52 we initialize them in the _initialize_symmisc function at the bottom
53 of the file. */
54 FILE *std_in;
55 FILE *std_out;
56 FILE *std_err;
57
58 /* Prototypes for local functions */
59
60 static void dump_symtab (struct objfile *, struct symtab *,
61 struct ui_file *);
62
63 static void dump_psymtab (struct objfile *, struct partial_symtab *,
64 struct ui_file *);
65
66 static void dump_msymbols (struct objfile *, struct ui_file *);
67
68 static void dump_objfile (struct objfile *);
69
70 static int block_depth (struct block *);
71
72 static void print_partial_symbols (struct partial_symbol **, int,
73 char *, struct ui_file *);
74
75 static void free_symtab_block (struct objfile *, struct block *);
76
77 void _initialize_symmisc (void);
78
79 struct print_symbol_args
80 {
81 struct symbol *symbol;
82 int depth;
83 struct ui_file *outfile;
84 };
85
86 static int print_symbol (void *);
87
88 static void free_symtab_block (struct objfile *, struct block *);
89
90
91 /* Free a struct block <- B and all the symbols defined in that block. */
92
93 /* FIXME: carlton/2003-04-28: I don't believe this is currently ever
94 used. */
95
96 static void
free_symtab_block(struct objfile * objfile,struct block * b)97 free_symtab_block (struct objfile *objfile, struct block *b)
98 {
99 struct dict_iterator iter;
100 struct symbol *sym;
101
102 ALL_BLOCK_SYMBOLS (b, iter, sym)
103 {
104 xfree (DEPRECATED_SYMBOL_NAME (sym));
105 xfree (sym);
106 }
107
108 dict_free (BLOCK_DICT (b));
109 xfree (b);
110 }
111
112 /* Free all the storage associated with the struct symtab <- S.
113 Note that some symtabs have contents malloc'ed structure by structure,
114 while some have contents that all live inside one big block of memory,
115 and some share the contents of another symbol table and so you should
116 not free the contents on their behalf (except sometimes the linetable,
117 which maybe per symtab even when the rest is not).
118 It is s->free_code that says which alternative to use. */
119
120 void
free_symtab(struct symtab * s)121 free_symtab (struct symtab *s)
122 {
123 int i, n;
124 struct blockvector *bv;
125
126 switch (s->free_code)
127 {
128 case free_nothing:
129 /* All the contents are part of a big block of memory (an obstack),
130 and some other symtab is in charge of freeing that block.
131 Therefore, do nothing. */
132 break;
133
134 case free_contents:
135 /* Here all the contents were malloc'ed structure by structure
136 and must be freed that way. */
137 /* First free the blocks (and their symbols. */
138 bv = BLOCKVECTOR (s);
139 n = BLOCKVECTOR_NBLOCKS (bv);
140 for (i = 0; i < n; i++)
141 free_symtab_block (s->objfile, BLOCKVECTOR_BLOCK (bv, i));
142 /* Free the blockvector itself. */
143 xfree (bv);
144 /* Also free the linetable. */
145
146 case free_linetable:
147 /* Everything will be freed either by our `free_func'
148 or by some other symtab, except for our linetable.
149 Free that now. */
150 if (LINETABLE (s))
151 xfree (LINETABLE (s));
152 break;
153 }
154
155 /* If there is a single block of memory to free, free it. */
156 if (s->free_func != NULL)
157 s->free_func (s);
158
159 /* Free source-related stuff */
160 if (s->line_charpos != NULL)
161 xfree (s->line_charpos);
162 if (s->fullname != NULL)
163 xfree (s->fullname);
164 if (s->debugformat != NULL)
165 xfree (s->debugformat);
166 xfree (s);
167 }
168
169 void
print_symbol_bcache_statistics(void)170 print_symbol_bcache_statistics (void)
171 {
172 struct objfile *objfile;
173
174 immediate_quit++;
175 ALL_OBJFILES (objfile)
176 {
177 printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name);
178 print_bcache_statistics (objfile->psymbol_cache, "partial symbol cache");
179 }
180 immediate_quit--;
181 }
182
183 void
print_objfile_statistics(void)184 print_objfile_statistics (void)
185 {
186 struct objfile *objfile;
187 struct symtab *s;
188 struct partial_symtab *ps;
189 int i, linetables, blockvectors;
190
191 immediate_quit++;
192 ALL_OBJFILES (objfile)
193 {
194 printf_filtered (_("Statistics for '%s':\n"), objfile->name);
195 if (OBJSTAT (objfile, n_stabs) > 0)
196 printf_filtered (_(" Number of \"stab\" symbols read: %d\n"),
197 OBJSTAT (objfile, n_stabs));
198 if (OBJSTAT (objfile, n_minsyms) > 0)
199 printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"),
200 OBJSTAT (objfile, n_minsyms));
201 if (OBJSTAT (objfile, n_psyms) > 0)
202 printf_filtered (_(" Number of \"partial\" symbols read: %d\n"),
203 OBJSTAT (objfile, n_psyms));
204 if (OBJSTAT (objfile, n_syms) > 0)
205 printf_filtered (_(" Number of \"full\" symbols read: %d\n"),
206 OBJSTAT (objfile, n_syms));
207 if (OBJSTAT (objfile, n_types) > 0)
208 printf_filtered (_(" Number of \"types\" defined: %d\n"),
209 OBJSTAT (objfile, n_types));
210 i = 0;
211 ALL_OBJFILE_PSYMTABS (objfile, ps)
212 {
213 if (ps->readin == 0)
214 i++;
215 }
216 printf_filtered (_(" Number of psym tables (not yet expanded): %d\n"), i);
217 i = linetables = blockvectors = 0;
218 ALL_OBJFILE_SYMTABS (objfile, s)
219 {
220 i++;
221 if (s->linetable != NULL)
222 linetables++;
223 if (s->primary == 1)
224 blockvectors++;
225 }
226 printf_filtered (_(" Number of symbol tables: %d\n"), i);
227 printf_filtered (_(" Number of symbol tables with line tables: %d\n"),
228 linetables);
229 printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"),
230 blockvectors);
231
232 if (OBJSTAT (objfile, sz_strtab) > 0)
233 printf_filtered (_(" Space used by a.out string tables: %d\n"),
234 OBJSTAT (objfile, sz_strtab));
235 printf_filtered (_(" Total memory used for objfile obstack: %d\n"),
236 obstack_memory_used (&objfile->objfile_obstack));
237 printf_filtered (_(" Total memory used for psymbol cache: %d\n"),
238 bcache_memory_used (objfile->psymbol_cache));
239 printf_filtered (_(" Total memory used for macro cache: %d\n"),
240 bcache_memory_used (objfile->macro_cache));
241 }
242 immediate_quit--;
243 }
244
245 static void
dump_objfile(struct objfile * objfile)246 dump_objfile (struct objfile *objfile)
247 {
248 struct symtab *symtab;
249 struct partial_symtab *psymtab;
250
251 printf_filtered ("\nObject file %s: ", objfile->name);
252 printf_filtered ("Objfile at ");
253 gdb_print_host_address (objfile, gdb_stdout);
254 printf_filtered (", bfd at ");
255 gdb_print_host_address (objfile->obfd, gdb_stdout);
256 printf_filtered (", %d minsyms\n\n",
257 objfile->minimal_symbol_count);
258
259 if (objfile->psymtabs)
260 {
261 printf_filtered ("Psymtabs:\n");
262 for (psymtab = objfile->psymtabs;
263 psymtab != NULL;
264 psymtab = psymtab->next)
265 {
266 printf_filtered ("%s at ",
267 psymtab->filename);
268 gdb_print_host_address (psymtab, gdb_stdout);
269 printf_filtered (", ");
270 if (psymtab->objfile != objfile)
271 {
272 printf_filtered ("NOT ON CHAIN! ");
273 }
274 wrap_here (" ");
275 }
276 printf_filtered ("\n\n");
277 }
278
279 if (objfile->symtabs)
280 {
281 printf_filtered ("Symtabs:\n");
282 for (symtab = objfile->symtabs;
283 symtab != NULL;
284 symtab = symtab->next)
285 {
286 printf_filtered ("%s at ", symtab->filename);
287 gdb_print_host_address (symtab, gdb_stdout);
288 printf_filtered (", ");
289 if (symtab->objfile != objfile)
290 {
291 printf_filtered ("NOT ON CHAIN! ");
292 }
293 wrap_here (" ");
294 }
295 printf_filtered ("\n\n");
296 }
297 }
298
299 /* Print minimal symbols from this objfile. */
300
301 static void
dump_msymbols(struct objfile * objfile,struct ui_file * outfile)302 dump_msymbols (struct objfile *objfile, struct ui_file *outfile)
303 {
304 struct minimal_symbol *msymbol;
305 int index;
306 char ms_type;
307
308 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name);
309 if (objfile->minimal_symbol_count == 0)
310 {
311 fprintf_filtered (outfile, "No minimal symbols found.\n");
312 return;
313 }
314 for (index = 0, msymbol = objfile->msymbols;
315 DEPRECATED_SYMBOL_NAME (msymbol) != NULL; msymbol++, index++)
316 {
317 switch (msymbol->type)
318 {
319 case mst_unknown:
320 ms_type = 'u';
321 break;
322 case mst_text:
323 ms_type = 'T';
324 break;
325 case mst_solib_trampoline:
326 ms_type = 'S';
327 break;
328 case mst_data:
329 ms_type = 'D';
330 break;
331 case mst_bss:
332 ms_type = 'B';
333 break;
334 case mst_abs:
335 ms_type = 'A';
336 break;
337 case mst_file_text:
338 ms_type = 't';
339 break;
340 case mst_file_data:
341 ms_type = 'd';
342 break;
343 case mst_file_bss:
344 ms_type = 'b';
345 break;
346 default:
347 ms_type = '?';
348 break;
349 }
350 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type);
351 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (msymbol), 1, outfile);
352 fprintf_filtered (outfile, " %s", DEPRECATED_SYMBOL_NAME (msymbol));
353 if (SYMBOL_BFD_SECTION (msymbol))
354 fprintf_filtered (outfile, " section %s",
355 bfd_section_name (objfile->obfd,
356 SYMBOL_BFD_SECTION (msymbol)));
357 if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL)
358 {
359 fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol));
360 }
361 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
362 if (msymbol->filename)
363 fprintf_filtered (outfile, " %s", msymbol->filename);
364 #endif
365 fputs_filtered ("\n", outfile);
366 }
367 if (objfile->minimal_symbol_count != index)
368 {
369 warning (_("internal error: minimal symbol count %d != %d"),
370 objfile->minimal_symbol_count, index);
371 }
372 fprintf_filtered (outfile, "\n");
373 }
374
375 static void
dump_psymtab(struct objfile * objfile,struct partial_symtab * psymtab,struct ui_file * outfile)376 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
377 struct ui_file *outfile)
378 {
379 int i;
380
381 fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
382 psymtab->filename);
383 fprintf_filtered (outfile, "(object ");
384 gdb_print_host_address (psymtab, outfile);
385 fprintf_filtered (outfile, ")\n\n");
386 fprintf_unfiltered (outfile, " Read from object file %s (",
387 objfile->name);
388 gdb_print_host_address (objfile, outfile);
389 fprintf_unfiltered (outfile, ")\n");
390
391 if (psymtab->readin)
392 {
393 fprintf_filtered (outfile,
394 " Full symtab was read (at ");
395 gdb_print_host_address (psymtab->symtab, outfile);
396 fprintf_filtered (outfile, " by function at ");
397 gdb_print_host_address (psymtab->read_symtab, outfile);
398 fprintf_filtered (outfile, ")\n");
399 }
400
401 fprintf_filtered (outfile, " Relocate symbols by ");
402 for (i = 0; i < psymtab->objfile->num_sections; ++i)
403 {
404 if (i != 0)
405 fprintf_filtered (outfile, ", ");
406 wrap_here (" ");
407 deprecated_print_address_numeric (ANOFFSET (psymtab->section_offsets, i),
408 1,
409 outfile);
410 }
411 fprintf_filtered (outfile, "\n");
412
413 fprintf_filtered (outfile, " Symbols cover text addresses ");
414 deprecated_print_address_numeric (psymtab->textlow, 1, outfile);
415 fprintf_filtered (outfile, "-");
416 deprecated_print_address_numeric (psymtab->texthigh, 1, outfile);
417 fprintf_filtered (outfile, "\n");
418 fprintf_filtered (outfile, " Depends on %d other partial symtabs.\n",
419 psymtab->number_of_dependencies);
420 for (i = 0; i < psymtab->number_of_dependencies; i++)
421 {
422 fprintf_filtered (outfile, " %d ", i);
423 gdb_print_host_address (psymtab->dependencies[i], outfile);
424 fprintf_filtered (outfile, " %s\n",
425 psymtab->dependencies[i]->filename);
426 }
427 if (psymtab->n_global_syms > 0)
428 {
429 print_partial_symbols (objfile->global_psymbols.list
430 + psymtab->globals_offset,
431 psymtab->n_global_syms, "Global", outfile);
432 }
433 if (psymtab->n_static_syms > 0)
434 {
435 print_partial_symbols (objfile->static_psymbols.list
436 + psymtab->statics_offset,
437 psymtab->n_static_syms, "Static", outfile);
438 }
439 fprintf_filtered (outfile, "\n");
440 }
441
442 static void
dump_symtab_1(struct objfile * objfile,struct symtab * symtab,struct ui_file * outfile)443 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
444 struct ui_file *outfile)
445 {
446 int i;
447 struct dict_iterator iter;
448 int len, blen;
449 struct linetable *l;
450 struct blockvector *bv;
451 struct symbol *sym;
452 struct block *b;
453 int depth;
454
455 fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
456 if (symtab->dirname)
457 fprintf_filtered (outfile, "Compilation directory is %s\n",
458 symtab->dirname);
459 fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
460 gdb_print_host_address (objfile, outfile);
461 fprintf_filtered (outfile, ")\n");
462 fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
463
464 /* First print the line table. */
465 l = LINETABLE (symtab);
466 if (l)
467 {
468 fprintf_filtered (outfile, "\nLine table:\n\n");
469 len = l->nitems;
470 for (i = 0; i < len; i++)
471 {
472 fprintf_filtered (outfile, " line %d at ", l->item[i].line);
473 deprecated_print_address_numeric (l->item[i].pc, 1, outfile);
474 fprintf_filtered (outfile, "\n");
475 }
476 }
477 /* Now print the block info, but only for primary symtabs since we will
478 print lots of duplicate info otherwise. */
479 if (symtab->primary)
480 {
481 fprintf_filtered (outfile, "\nBlockvector:\n\n");
482 bv = BLOCKVECTOR (symtab);
483 len = BLOCKVECTOR_NBLOCKS (bv);
484 for (i = 0; i < len; i++)
485 {
486 b = BLOCKVECTOR_BLOCK (bv, i);
487 depth = block_depth (b) * 2;
488 print_spaces (depth, outfile);
489 fprintf_filtered (outfile, "block #%03d, object at ", i);
490 gdb_print_host_address (b, outfile);
491 if (BLOCK_SUPERBLOCK (b))
492 {
493 fprintf_filtered (outfile, " under ");
494 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
495 }
496 /* drow/2002-07-10: We could save the total symbols count
497 even if we're using a hashtable, but nothing else but this message
498 wants it. */
499 fprintf_filtered (outfile, ", %d syms/buckets in ",
500 dict_size (BLOCK_DICT (b)));
501 deprecated_print_address_numeric (BLOCK_START (b), 1, outfile);
502 fprintf_filtered (outfile, "..");
503 deprecated_print_address_numeric (BLOCK_END (b), 1, outfile);
504 if (BLOCK_FUNCTION (b))
505 {
506 fprintf_filtered (outfile, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b)));
507 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
508 {
509 fprintf_filtered (outfile, ", %s",
510 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
511 }
512 }
513 if (BLOCK_GCC_COMPILED (b))
514 fprintf_filtered (outfile, ", compiled with gcc%d", BLOCK_GCC_COMPILED (b));
515 fprintf_filtered (outfile, "\n");
516 /* Now print each symbol in this block (in no particular order, if
517 we're using a hashtable). */
518 ALL_BLOCK_SYMBOLS (b, iter, sym)
519 {
520 struct print_symbol_args s;
521 s.symbol = sym;
522 s.depth = depth + 1;
523 s.outfile = outfile;
524 catch_errors (print_symbol, &s, "Error printing symbol:\n",
525 RETURN_MASK_ALL);
526 }
527 }
528 fprintf_filtered (outfile, "\n");
529 }
530 else
531 {
532 fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
533 }
534 }
535
536 static void
dump_symtab(struct objfile * objfile,struct symtab * symtab,struct ui_file * outfile)537 dump_symtab (struct objfile *objfile, struct symtab *symtab,
538 struct ui_file *outfile)
539 {
540 enum language saved_lang;
541
542 /* Set the current language to the language of the symtab we're dumping
543 because certain routines used during dump_symtab() use the current
544 language to print an image of the symbol. We'll restore it later. */
545 saved_lang = set_language (symtab->language);
546
547 dump_symtab_1 (objfile, symtab, outfile);
548
549 set_language (saved_lang);
550 }
551
552 void
maintenance_print_symbols(char * args,int from_tty)553 maintenance_print_symbols (char *args, int from_tty)
554 {
555 char **argv;
556 struct ui_file *outfile;
557 struct cleanup *cleanups;
558 char *symname = NULL;
559 char *filename = DEV_TTY;
560 struct objfile *objfile;
561 struct symtab *s;
562
563 dont_repeat ();
564
565 if (args == NULL)
566 {
567 error (_("\
568 Arguments missing: an output file name and an optional symbol file name"));
569 }
570 else if ((argv = buildargv (args)) == NULL)
571 {
572 nomem (0);
573 }
574 cleanups = make_cleanup_freeargv (argv);
575
576 if (argv[0] != NULL)
577 {
578 filename = argv[0];
579 /* If a second arg is supplied, it is a source file name to match on */
580 if (argv[1] != NULL)
581 {
582 symname = argv[1];
583 }
584 }
585
586 filename = tilde_expand (filename);
587 make_cleanup (xfree, filename);
588
589 outfile = gdb_fopen (filename, FOPEN_WT);
590 if (outfile == 0)
591 perror_with_name (filename);
592 make_cleanup_ui_file_delete (outfile);
593
594 immediate_quit++;
595 ALL_SYMTABS (objfile, s)
596 if (symname == NULL || strcmp (symname, s->filename) == 0)
597 dump_symtab (objfile, s, outfile);
598 immediate_quit--;
599 do_cleanups (cleanups);
600 }
601
602 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how
603 far to indent. ARGS is really a struct print_symbol_args *, but is
604 declared as char * to get it past catch_errors. Returns 0 for error,
605 1 for success. */
606
607 static int
print_symbol(void * args)608 print_symbol (void *args)
609 {
610 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
611 int depth = ((struct print_symbol_args *) args)->depth;
612 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
613
614 print_spaces (depth, outfile);
615 if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
616 {
617 fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
618 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
619 if (SYMBOL_BFD_SECTION (symbol))
620 fprintf_filtered (outfile, " section %s\n",
621 bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
622 SYMBOL_BFD_SECTION (symbol)));
623 else
624 fprintf_filtered (outfile, "\n");
625 return 1;
626 }
627 if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
628 {
629 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
630 {
631 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
632 }
633 else
634 {
635 fprintf_filtered (outfile, "%s %s = ",
636 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
637 ? "enum"
638 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
639 ? "struct" : "union")),
640 DEPRECATED_SYMBOL_NAME (symbol));
641 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
642 }
643 fprintf_filtered (outfile, ";\n");
644 }
645 else
646 {
647 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
648 fprintf_filtered (outfile, "typedef ");
649 if (SYMBOL_TYPE (symbol))
650 {
651 /* Print details of types, except for enums where it's clutter. */
652 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
653 outfile,
654 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
655 depth);
656 fprintf_filtered (outfile, "; ");
657 }
658 else
659 fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
660
661 switch (SYMBOL_CLASS (symbol))
662 {
663 case LOC_CONST:
664 fprintf_filtered (outfile, "const %ld (0x%lx)",
665 SYMBOL_VALUE (symbol),
666 SYMBOL_VALUE (symbol));
667 break;
668
669 case LOC_CONST_BYTES:
670 {
671 unsigned i;
672 struct type *type = check_typedef (SYMBOL_TYPE (symbol));
673 fprintf_filtered (outfile, "const %u hex bytes:",
674 TYPE_LENGTH (type));
675 for (i = 0; i < TYPE_LENGTH (type); i++)
676 fprintf_filtered (outfile, " %02x",
677 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
678 }
679 break;
680
681 case LOC_STATIC:
682 fprintf_filtered (outfile, "static at ");
683 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
684 if (SYMBOL_BFD_SECTION (symbol))
685 fprintf_filtered (outfile, " section %s",
686 bfd_section_name
687 (SYMBOL_BFD_SECTION (symbol)->owner,
688 SYMBOL_BFD_SECTION (symbol)));
689 break;
690
691 case LOC_INDIRECT:
692 fprintf_filtered (outfile, "extern global at *(");
693 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
694 fprintf_filtered (outfile, "),");
695 break;
696
697 case LOC_REGISTER:
698 fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
699 break;
700
701 case LOC_ARG:
702 fprintf_filtered (outfile, "arg at offset 0x%lx",
703 SYMBOL_VALUE (symbol));
704 break;
705
706 case LOC_LOCAL_ARG:
707 fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
708 SYMBOL_VALUE (symbol));
709 break;
710
711 case LOC_REF_ARG:
712 fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
713 break;
714
715 case LOC_REGPARM:
716 fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
717 break;
718
719 case LOC_REGPARM_ADDR:
720 fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
721 break;
722
723 case LOC_LOCAL:
724 fprintf_filtered (outfile, "local at offset 0x%lx",
725 SYMBOL_VALUE (symbol));
726 break;
727
728 case LOC_BASEREG:
729 fprintf_filtered (outfile, "local at 0x%lx from register %d",
730 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
731 break;
732
733 case LOC_BASEREG_ARG:
734 fprintf_filtered (outfile, "arg at 0x%lx from register %d",
735 SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
736 break;
737
738 case LOC_TYPEDEF:
739 break;
740
741 case LOC_LABEL:
742 fprintf_filtered (outfile, "label at ");
743 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
744 if (SYMBOL_BFD_SECTION (symbol))
745 fprintf_filtered (outfile, " section %s",
746 bfd_section_name
747 (SYMBOL_BFD_SECTION (symbol)->owner,
748 SYMBOL_BFD_SECTION (symbol)));
749 break;
750
751 case LOC_BLOCK:
752 fprintf_filtered (outfile, "block object ");
753 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
754 fprintf_filtered (outfile, ", ");
755 deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
756 1,
757 outfile);
758 fprintf_filtered (outfile, "..");
759 deprecated_print_address_numeric (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol)),
760 1,
761 outfile);
762 if (SYMBOL_BFD_SECTION (symbol))
763 fprintf_filtered (outfile, " section %s",
764 bfd_section_name
765 (SYMBOL_BFD_SECTION (symbol)->owner,
766 SYMBOL_BFD_SECTION (symbol)));
767 break;
768
769 case LOC_COMPUTED:
770 case LOC_COMPUTED_ARG:
771 fprintf_filtered (outfile, "computed at runtime");
772 break;
773
774 case LOC_UNRESOLVED:
775 fprintf_filtered (outfile, "unresolved");
776 break;
777
778 case LOC_OPTIMIZED_OUT:
779 fprintf_filtered (outfile, "optimized out");
780 break;
781
782 default:
783 fprintf_filtered (outfile, "botched symbol class %x",
784 SYMBOL_CLASS (symbol));
785 break;
786 }
787 }
788 fprintf_filtered (outfile, "\n");
789 return 1;
790 }
791
792 void
maintenance_print_psymbols(char * args,int from_tty)793 maintenance_print_psymbols (char *args, int from_tty)
794 {
795 char **argv;
796 struct ui_file *outfile;
797 struct cleanup *cleanups;
798 char *symname = NULL;
799 char *filename = DEV_TTY;
800 struct objfile *objfile;
801 struct partial_symtab *ps;
802
803 dont_repeat ();
804
805 if (args == NULL)
806 {
807 error (_("print-psymbols takes an output file name and optional symbol file name"));
808 }
809 else if ((argv = buildargv (args)) == NULL)
810 {
811 nomem (0);
812 }
813 cleanups = make_cleanup_freeargv (argv);
814
815 if (argv[0] != NULL)
816 {
817 filename = argv[0];
818 /* If a second arg is supplied, it is a source file name to match on */
819 if (argv[1] != NULL)
820 {
821 symname = argv[1];
822 }
823 }
824
825 filename = tilde_expand (filename);
826 make_cleanup (xfree, filename);
827
828 outfile = gdb_fopen (filename, FOPEN_WT);
829 if (outfile == 0)
830 perror_with_name (filename);
831 make_cleanup_ui_file_delete (outfile);
832
833 immediate_quit++;
834 ALL_PSYMTABS (objfile, ps)
835 if (symname == NULL || strcmp (symname, ps->filename) == 0)
836 dump_psymtab (objfile, ps, outfile);
837 immediate_quit--;
838 do_cleanups (cleanups);
839 }
840
841 static void
print_partial_symbols(struct partial_symbol ** p,int count,char * what,struct ui_file * outfile)842 print_partial_symbols (struct partial_symbol **p, int count, char *what,
843 struct ui_file *outfile)
844 {
845 fprintf_filtered (outfile, " %s partial symbols:\n", what);
846 while (count-- > 0)
847 {
848 fprintf_filtered (outfile, " `%s'", DEPRECATED_SYMBOL_NAME (*p));
849 if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
850 {
851 fprintf_filtered (outfile, " `%s'", SYMBOL_DEMANGLED_NAME (*p));
852 }
853 fputs_filtered (", ", outfile);
854 switch (SYMBOL_DOMAIN (*p))
855 {
856 case UNDEF_DOMAIN:
857 fputs_filtered ("undefined domain, ", outfile);
858 break;
859 case VAR_DOMAIN:
860 /* This is the usual thing -- don't print it */
861 break;
862 case STRUCT_DOMAIN:
863 fputs_filtered ("struct domain, ", outfile);
864 break;
865 case LABEL_DOMAIN:
866 fputs_filtered ("label domain, ", outfile);
867 break;
868 default:
869 fputs_filtered ("<invalid domain>, ", outfile);
870 break;
871 }
872 switch (SYMBOL_CLASS (*p))
873 {
874 case LOC_UNDEF:
875 fputs_filtered ("undefined", outfile);
876 break;
877 case LOC_CONST:
878 fputs_filtered ("constant int", outfile);
879 break;
880 case LOC_STATIC:
881 fputs_filtered ("static", outfile);
882 break;
883 case LOC_INDIRECT:
884 fputs_filtered ("extern global", outfile);
885 break;
886 case LOC_REGISTER:
887 fputs_filtered ("register", outfile);
888 break;
889 case LOC_ARG:
890 fputs_filtered ("pass by value", outfile);
891 break;
892 case LOC_REF_ARG:
893 fputs_filtered ("pass by reference", outfile);
894 break;
895 case LOC_REGPARM:
896 fputs_filtered ("register parameter", outfile);
897 break;
898 case LOC_REGPARM_ADDR:
899 fputs_filtered ("register address parameter", outfile);
900 break;
901 case LOC_LOCAL:
902 fputs_filtered ("stack parameter", outfile);
903 break;
904 case LOC_TYPEDEF:
905 fputs_filtered ("type", outfile);
906 break;
907 case LOC_LABEL:
908 fputs_filtered ("label", outfile);
909 break;
910 case LOC_BLOCK:
911 fputs_filtered ("function", outfile);
912 break;
913 case LOC_CONST_BYTES:
914 fputs_filtered ("constant bytes", outfile);
915 break;
916 case LOC_LOCAL_ARG:
917 fputs_filtered ("shuffled arg", outfile);
918 break;
919 case LOC_UNRESOLVED:
920 fputs_filtered ("unresolved", outfile);
921 break;
922 case LOC_OPTIMIZED_OUT:
923 fputs_filtered ("optimized out", outfile);
924 break;
925 case LOC_COMPUTED:
926 case LOC_COMPUTED_ARG:
927 fputs_filtered ("computed at runtime", outfile);
928 break;
929 default:
930 fputs_filtered ("<invalid location>", outfile);
931 break;
932 }
933 fputs_filtered (", ", outfile);
934 deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (*p), 1, outfile);
935 fprintf_filtered (outfile, "\n");
936 p++;
937 }
938 }
939
940 void
maintenance_print_msymbols(char * args,int from_tty)941 maintenance_print_msymbols (char *args, int from_tty)
942 {
943 char **argv;
944 struct ui_file *outfile;
945 struct cleanup *cleanups;
946 char *filename = DEV_TTY;
947 char *symname = NULL;
948 struct objfile *objfile;
949
950 struct stat sym_st, obj_st;
951
952 dont_repeat ();
953
954 if (args == NULL)
955 {
956 error (_("print-msymbols takes an output file name and optional symbol file name"));
957 }
958 else if ((argv = buildargv (args)) == NULL)
959 {
960 nomem (0);
961 }
962 cleanups = make_cleanup_freeargv (argv);
963
964 if (argv[0] != NULL)
965 {
966 filename = argv[0];
967 /* If a second arg is supplied, it is a source file name to match on */
968 if (argv[1] != NULL)
969 {
970 symname = xfullpath (argv[1]);
971 make_cleanup (xfree, symname);
972 if (symname && stat (symname, &sym_st))
973 perror_with_name (symname);
974 }
975 }
976
977 filename = tilde_expand (filename);
978 make_cleanup (xfree, filename);
979
980 outfile = gdb_fopen (filename, FOPEN_WT);
981 if (outfile == 0)
982 perror_with_name (filename);
983 make_cleanup_ui_file_delete (outfile);
984
985 immediate_quit++;
986 ALL_OBJFILES (objfile)
987 if (symname == NULL
988 || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
989 dump_msymbols (objfile, outfile);
990 immediate_quit--;
991 fprintf_filtered (outfile, "\n\n");
992 do_cleanups (cleanups);
993 }
994
995 void
maintenance_print_objfiles(char * ignore,int from_tty)996 maintenance_print_objfiles (char *ignore, int from_tty)
997 {
998 struct objfile *objfile;
999
1000 dont_repeat ();
1001
1002 immediate_quit++;
1003 ALL_OBJFILES (objfile)
1004 dump_objfile (objfile);
1005 immediate_quit--;
1006 }
1007
1008
1009 /* List all the symbol tables whose names match REGEXP (optional). */
1010 void
maintenance_info_symtabs(char * regexp,int from_tty)1011 maintenance_info_symtabs (char *regexp, int from_tty)
1012 {
1013 struct objfile *objfile;
1014
1015 if (regexp)
1016 re_comp (regexp);
1017
1018 ALL_OBJFILES (objfile)
1019 {
1020 struct symtab *symtab;
1021
1022 /* We don't want to print anything for this objfile until we
1023 actually find a symtab whose name matches. */
1024 int printed_objfile_start = 0;
1025
1026 ALL_OBJFILE_SYMTABS (objfile, symtab)
1027 if (! regexp
1028 || re_exec (symtab->filename))
1029 {
1030 if (! printed_objfile_start)
1031 {
1032 printf_filtered ("{ objfile %s ", objfile->name);
1033 wrap_here (" ");
1034 printf_filtered ("((struct objfile *) %p)\n", objfile);
1035 printed_objfile_start = 1;
1036 }
1037
1038 printf_filtered (" { symtab %s ", symtab->filename);
1039 wrap_here (" ");
1040 printf_filtered ("((struct symtab *) %p)\n", symtab);
1041 printf_filtered (" dirname %s\n",
1042 symtab->dirname ? symtab->dirname : "(null)");
1043 printf_filtered (" fullname %s\n",
1044 symtab->fullname ? symtab->fullname : "(null)");
1045 printf_filtered (" blockvector ((struct blockvector *) %p)%s\n",
1046 symtab->blockvector,
1047 symtab->primary ? " (primary)" : "");
1048 printf_filtered (" debugformat %s\n", symtab->debugformat);
1049 printf_filtered (" }\n");
1050 }
1051
1052 if (printed_objfile_start)
1053 printf_filtered ("}\n");
1054 }
1055 }
1056
1057
1058 /* List all the partial symbol tables whose names match REGEXP (optional). */
1059 void
maintenance_info_psymtabs(char * regexp,int from_tty)1060 maintenance_info_psymtabs (char *regexp, int from_tty)
1061 {
1062 struct objfile *objfile;
1063
1064 if (regexp)
1065 re_comp (regexp);
1066
1067 ALL_OBJFILES (objfile)
1068 {
1069 struct partial_symtab *psymtab;
1070
1071 /* We don't want to print anything for this objfile until we
1072 actually find a symtab whose name matches. */
1073 int printed_objfile_start = 0;
1074
1075 ALL_OBJFILE_PSYMTABS (objfile, psymtab)
1076 if (! regexp
1077 || re_exec (psymtab->filename))
1078 {
1079 if (! printed_objfile_start)
1080 {
1081 printf_filtered ("{ objfile %s ", objfile->name);
1082 wrap_here (" ");
1083 printf_filtered ("((struct objfile *) %p)\n", objfile);
1084 printed_objfile_start = 1;
1085 }
1086
1087 printf_filtered (" { psymtab %s ", psymtab->filename);
1088 wrap_here (" ");
1089 printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
1090 printf_filtered (" readin %s\n",
1091 psymtab->readin ? "yes" : "no");
1092 printf_filtered (" fullname %s\n",
1093 psymtab->fullname ? psymtab->fullname : "(null)");
1094 printf_filtered (" text addresses ");
1095 deprecated_print_address_numeric (psymtab->textlow, 1, gdb_stdout);
1096 printf_filtered (" -- ");
1097 deprecated_print_address_numeric (psymtab->texthigh, 1, gdb_stdout);
1098 printf_filtered ("\n");
1099 printf_filtered (" globals ");
1100 if (psymtab->n_global_syms)
1101 {
1102 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1103 (psymtab->objfile->global_psymbols.list
1104 + psymtab->globals_offset),
1105 psymtab->n_global_syms);
1106 }
1107 else
1108 printf_filtered ("(none)\n");
1109 printf_filtered (" statics ");
1110 if (psymtab->n_static_syms)
1111 {
1112 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1113 (psymtab->objfile->static_psymbols.list
1114 + psymtab->statics_offset),
1115 psymtab->n_static_syms);
1116 }
1117 else
1118 printf_filtered ("(none)\n");
1119 printf_filtered (" dependencies ");
1120 if (psymtab->number_of_dependencies)
1121 {
1122 int i;
1123
1124 printf_filtered ("{\n");
1125 for (i = 0; i < psymtab->number_of_dependencies; i++)
1126 {
1127 struct partial_symtab *dep = psymtab->dependencies[i];
1128
1129 /* Note the string concatenation there --- no comma. */
1130 printf_filtered (" psymtab %s "
1131 "((struct partial_symtab *) %p)\n",
1132 dep->filename, dep);
1133 }
1134 printf_filtered (" }\n");
1135 }
1136 else
1137 printf_filtered ("(none)\n");
1138 printf_filtered (" }\n");
1139 }
1140
1141 if (printed_objfile_start)
1142 printf_filtered ("}\n");
1143 }
1144 }
1145
1146
1147 /* Check consistency of psymtabs and symtabs. */
1148
1149 void
maintenance_check_symtabs(char * ignore,int from_tty)1150 maintenance_check_symtabs (char *ignore, int from_tty)
1151 {
1152 struct symbol *sym;
1153 struct partial_symbol **psym;
1154 struct symtab *s = NULL;
1155 struct partial_symtab *ps;
1156 struct blockvector *bv;
1157 struct objfile *objfile;
1158 struct block *b;
1159 int length;
1160
1161 ALL_PSYMTABS (objfile, ps)
1162 {
1163 s = PSYMTAB_TO_SYMTAB (ps);
1164 if (s == NULL)
1165 continue;
1166 bv = BLOCKVECTOR (s);
1167 b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1168 psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1169 length = ps->n_static_syms;
1170 while (length--)
1171 {
1172 sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1173 NULL, SYMBOL_DOMAIN (*psym));
1174 if (!sym)
1175 {
1176 printf_filtered ("Static symbol `");
1177 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1178 printf_filtered ("' only found in ");
1179 puts_filtered (ps->filename);
1180 printf_filtered (" psymtab\n");
1181 }
1182 psym++;
1183 }
1184 b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1185 psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1186 length = ps->n_global_syms;
1187 while (length--)
1188 {
1189 sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1190 NULL, SYMBOL_DOMAIN (*psym));
1191 if (!sym)
1192 {
1193 printf_filtered ("Global symbol `");
1194 puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1195 printf_filtered ("' only found in ");
1196 puts_filtered (ps->filename);
1197 printf_filtered (" psymtab\n");
1198 }
1199 psym++;
1200 }
1201 if (ps->texthigh < ps->textlow)
1202 {
1203 printf_filtered ("Psymtab ");
1204 puts_filtered (ps->filename);
1205 printf_filtered (" covers bad range ");
1206 deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
1207 printf_filtered (" - ");
1208 deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
1209 printf_filtered ("\n");
1210 continue;
1211 }
1212 if (ps->texthigh == 0)
1213 continue;
1214 if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1215 {
1216 printf_filtered ("Psymtab ");
1217 puts_filtered (ps->filename);
1218 printf_filtered (" covers ");
1219 deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
1220 printf_filtered (" - ");
1221 deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
1222 printf_filtered (" but symtab covers only ");
1223 deprecated_print_address_numeric (BLOCK_START (b), 1, gdb_stdout);
1224 printf_filtered (" - ");
1225 deprecated_print_address_numeric (BLOCK_END (b), 1, gdb_stdout);
1226 printf_filtered ("\n");
1227 }
1228 }
1229 }
1230
1231
1232 /* Return the nexting depth of a block within other blocks in its symtab. */
1233
1234 static int
block_depth(struct block * block)1235 block_depth (struct block *block)
1236 {
1237 int i = 0;
1238 while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1239 {
1240 i++;
1241 }
1242 return i;
1243 }
1244
1245
1246 /* Increase the space allocated for LISTP, which is probably
1247 global_psymbols or static_psymbols. This space will eventually
1248 be freed in free_objfile(). */
1249
1250 void
extend_psymbol_list(struct psymbol_allocation_list * listp,struct objfile * objfile)1251 extend_psymbol_list (struct psymbol_allocation_list *listp,
1252 struct objfile *objfile)
1253 {
1254 int new_size;
1255 if (listp->size == 0)
1256 {
1257 new_size = 255;
1258 listp->list = (struct partial_symbol **)
1259 xmalloc (new_size * sizeof (struct partial_symbol *));
1260 }
1261 else
1262 {
1263 new_size = listp->size * 2;
1264 listp->list = (struct partial_symbol **)
1265 xrealloc ((char *) listp->list,
1266 new_size * sizeof (struct partial_symbol *));
1267 }
1268 /* Next assumes we only went one over. Should be good if
1269 program works correctly */
1270 listp->next = listp->list + listp->size;
1271 listp->size = new_size;
1272 }
1273
1274
1275 /* Do early runtime initializations. */
1276 void
_initialize_symmisc(void)1277 _initialize_symmisc (void)
1278 {
1279 std_in = stdin;
1280 std_out = stdout;
1281 std_err = stderr;
1282 }
1283