1 /* Do various things to symbol tables (other than lookup), for GDB. 2 3 Copyright (C) 1986-2000, 2002-2004, 2007-2012 Free Software 4 Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "symtab.h" 23 #include "gdbtypes.h" 24 #include "bfd.h" 25 #include "filenames.h" 26 #include "symfile.h" 27 #include "objfiles.h" 28 #include "breakpoint.h" 29 #include "command.h" 30 #include "gdb_obstack.h" 31 #include "exceptions.h" 32 #include "language.h" 33 #include "bcache.h" 34 #include "block.h" 35 #include "gdb_regex.h" 36 #include "gdb_stat.h" 37 #include "dictionary.h" 38 39 #include "gdb_string.h" 40 #include "readline/readline.h" 41 42 #include "psymtab.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_msymbols (struct objfile *, struct ui_file *); 64 65 static void dump_objfile (struct objfile *); 66 67 static int block_depth (struct block *); 68 69 void _initialize_symmisc (void); 70 71 struct print_symbol_args 72 { 73 struct gdbarch *gdbarch; 74 struct symbol *symbol; 75 int depth; 76 struct ui_file *outfile; 77 }; 78 79 static int print_symbol (void *); 80 81 82 void 83 print_symbol_bcache_statistics (void) 84 { 85 struct program_space *pspace; 86 struct objfile *objfile; 87 88 immediate_quit++; 89 ALL_PSPACES (pspace) 90 ALL_PSPACE_OBJFILES (pspace, objfile) 91 { 92 printf_filtered (_("Byte cache statistics for '%s':\n"), objfile->name); 93 print_bcache_statistics (psymbol_bcache_get_bcache (objfile->psymbol_cache), 94 "partial symbol cache"); 95 print_bcache_statistics (objfile->macro_cache, "preprocessor macro cache"); 96 print_bcache_statistics (objfile->filename_cache, "file name cache"); 97 } 98 immediate_quit--; 99 } 100 101 void 102 print_objfile_statistics (void) 103 { 104 struct program_space *pspace; 105 struct objfile *objfile; 106 struct symtab *s; 107 int i, linetables, blockvectors; 108 109 immediate_quit++; 110 ALL_PSPACES (pspace) 111 ALL_PSPACE_OBJFILES (pspace, objfile) 112 { 113 printf_filtered (_("Statistics for '%s':\n"), objfile->name); 114 if (OBJSTAT (objfile, n_stabs) > 0) 115 printf_filtered (_(" Number of \"stab\" symbols read: %d\n"), 116 OBJSTAT (objfile, n_stabs)); 117 if (OBJSTAT (objfile, n_minsyms) > 0) 118 printf_filtered (_(" Number of \"minimal\" symbols read: %d\n"), 119 OBJSTAT (objfile, n_minsyms)); 120 if (OBJSTAT (objfile, n_psyms) > 0) 121 printf_filtered (_(" Number of \"partial\" symbols read: %d\n"), 122 OBJSTAT (objfile, n_psyms)); 123 if (OBJSTAT (objfile, n_syms) > 0) 124 printf_filtered (_(" Number of \"full\" symbols read: %d\n"), 125 OBJSTAT (objfile, n_syms)); 126 if (OBJSTAT (objfile, n_types) > 0) 127 printf_filtered (_(" Number of \"types\" defined: %d\n"), 128 OBJSTAT (objfile, n_types)); 129 if (objfile->sf) 130 objfile->sf->qf->print_stats (objfile); 131 i = linetables = blockvectors = 0; 132 ALL_OBJFILE_SYMTABS (objfile, s) 133 { 134 i++; 135 if (s->linetable != NULL) 136 linetables++; 137 if (s->primary == 1) 138 blockvectors++; 139 } 140 printf_filtered (_(" Number of symbol tables: %d\n"), i); 141 printf_filtered (_(" Number of symbol tables with line tables: %d\n"), 142 linetables); 143 printf_filtered (_(" Number of symbol tables with blockvectors: %d\n"), 144 blockvectors); 145 146 if (OBJSTAT (objfile, sz_strtab) > 0) 147 printf_filtered (_(" Space used by a.out string tables: %d\n"), 148 OBJSTAT (objfile, sz_strtab)); 149 printf_filtered (_(" Total memory used for objfile obstack: %d\n"), 150 obstack_memory_used (&objfile->objfile_obstack)); 151 printf_filtered (_(" Total memory used for psymbol cache: %d\n"), 152 bcache_memory_used (psymbol_bcache_get_bcache 153 (objfile->psymbol_cache))); 154 printf_filtered (_(" Total memory used for macro cache: %d\n"), 155 bcache_memory_used (objfile->macro_cache)); 156 printf_filtered (_(" Total memory used for file name cache: %d\n"), 157 bcache_memory_used (objfile->filename_cache)); 158 } 159 immediate_quit--; 160 } 161 162 static void 163 dump_objfile (struct objfile *objfile) 164 { 165 struct symtab *symtab; 166 167 printf_filtered ("\nObject file %s: ", objfile->name); 168 printf_filtered ("Objfile at "); 169 gdb_print_host_address (objfile, gdb_stdout); 170 printf_filtered (", bfd at "); 171 gdb_print_host_address (objfile->obfd, gdb_stdout); 172 printf_filtered (", %d minsyms\n\n", 173 objfile->minimal_symbol_count); 174 175 if (objfile->sf) 176 objfile->sf->qf->dump (objfile); 177 178 if (objfile->symtabs) 179 { 180 printf_filtered ("Symtabs:\n"); 181 for (symtab = objfile->symtabs; 182 symtab != NULL; 183 symtab = symtab->next) 184 { 185 printf_filtered ("%s at ", symtab->filename); 186 gdb_print_host_address (symtab, gdb_stdout); 187 printf_filtered (", "); 188 if (symtab->objfile != objfile) 189 { 190 printf_filtered ("NOT ON CHAIN! "); 191 } 192 wrap_here (" "); 193 } 194 printf_filtered ("\n\n"); 195 } 196 } 197 198 /* Print minimal symbols from this objfile. */ 199 200 static void 201 dump_msymbols (struct objfile *objfile, struct ui_file *outfile) 202 { 203 struct gdbarch *gdbarch = get_objfile_arch (objfile); 204 struct minimal_symbol *msymbol; 205 int index; 206 char ms_type; 207 208 fprintf_filtered (outfile, "\nObject file %s:\n\n", objfile->name); 209 if (objfile->minimal_symbol_count == 0) 210 { 211 fprintf_filtered (outfile, "No minimal symbols found.\n"); 212 return; 213 } 214 index = 0; 215 ALL_OBJFILE_MSYMBOLS (objfile, msymbol) 216 { 217 struct obj_section *section = SYMBOL_OBJ_SECTION (msymbol); 218 219 switch (MSYMBOL_TYPE (msymbol)) 220 { 221 case mst_unknown: 222 ms_type = 'u'; 223 break; 224 case mst_text: 225 ms_type = 'T'; 226 break; 227 case mst_text_gnu_ifunc: 228 ms_type = 'i'; 229 break; 230 case mst_solib_trampoline: 231 ms_type = 'S'; 232 break; 233 case mst_data: 234 ms_type = 'D'; 235 break; 236 case mst_bss: 237 ms_type = 'B'; 238 break; 239 case mst_abs: 240 ms_type = 'A'; 241 break; 242 case mst_file_text: 243 ms_type = 't'; 244 break; 245 case mst_file_data: 246 ms_type = 'd'; 247 break; 248 case mst_file_bss: 249 ms_type = 'b'; 250 break; 251 default: 252 ms_type = '?'; 253 break; 254 } 255 fprintf_filtered (outfile, "[%2d] %c ", index, ms_type); 256 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msymbol)), 257 outfile); 258 fprintf_filtered (outfile, " %s", SYMBOL_LINKAGE_NAME (msymbol)); 259 if (section) 260 fprintf_filtered (outfile, " section %s", 261 bfd_section_name (objfile->obfd, 262 section->the_bfd_section)); 263 if (SYMBOL_DEMANGLED_NAME (msymbol) != NULL) 264 { 265 fprintf_filtered (outfile, " %s", SYMBOL_DEMANGLED_NAME (msymbol)); 266 } 267 if (msymbol->filename) 268 fprintf_filtered (outfile, " %s", msymbol->filename); 269 fputs_filtered ("\n", outfile); 270 index++; 271 } 272 if (objfile->minimal_symbol_count != index) 273 { 274 warning (_("internal error: minimal symbol count %d != %d"), 275 objfile->minimal_symbol_count, index); 276 } 277 fprintf_filtered (outfile, "\n"); 278 } 279 280 static void 281 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab, 282 struct ui_file *outfile) 283 { 284 struct gdbarch *gdbarch = get_objfile_arch (objfile); 285 int i; 286 struct dict_iterator iter; 287 int len; 288 struct linetable *l; 289 struct blockvector *bv; 290 struct symbol *sym; 291 struct block *b; 292 int depth; 293 294 fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename); 295 if (symtab->dirname) 296 fprintf_filtered (outfile, "Compilation directory is %s\n", 297 symtab->dirname); 298 fprintf_filtered (outfile, "Read from object file %s (", objfile->name); 299 gdb_print_host_address (objfile, outfile); 300 fprintf_filtered (outfile, ")\n"); 301 fprintf_filtered (outfile, "Language: %s\n", 302 language_str (symtab->language)); 303 304 /* First print the line table. */ 305 l = LINETABLE (symtab); 306 if (l) 307 { 308 fprintf_filtered (outfile, "\nLine table:\n\n"); 309 len = l->nitems; 310 for (i = 0; i < len; i++) 311 { 312 fprintf_filtered (outfile, " line %d at ", l->item[i].line); 313 fputs_filtered (paddress (gdbarch, l->item[i].pc), outfile); 314 fprintf_filtered (outfile, "\n"); 315 } 316 } 317 /* Now print the block info, but only for primary symtabs since we will 318 print lots of duplicate info otherwise. */ 319 if (symtab->primary) 320 { 321 fprintf_filtered (outfile, "\nBlockvector:\n\n"); 322 bv = BLOCKVECTOR (symtab); 323 len = BLOCKVECTOR_NBLOCKS (bv); 324 for (i = 0; i < len; i++) 325 { 326 b = BLOCKVECTOR_BLOCK (bv, i); 327 depth = block_depth (b) * 2; 328 print_spaces (depth, outfile); 329 fprintf_filtered (outfile, "block #%03d, object at ", i); 330 gdb_print_host_address (b, outfile); 331 if (BLOCK_SUPERBLOCK (b)) 332 { 333 fprintf_filtered (outfile, " under "); 334 gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile); 335 } 336 /* drow/2002-07-10: We could save the total symbols count 337 even if we're using a hashtable, but nothing else but this message 338 wants it. */ 339 fprintf_filtered (outfile, ", %d syms/buckets in ", 340 dict_size (BLOCK_DICT (b))); 341 fputs_filtered (paddress (gdbarch, BLOCK_START (b)), outfile); 342 fprintf_filtered (outfile, ".."); 343 fputs_filtered (paddress (gdbarch, BLOCK_END (b)), outfile); 344 if (BLOCK_FUNCTION (b)) 345 { 346 fprintf_filtered (outfile, ", function %s", 347 SYMBOL_LINKAGE_NAME (BLOCK_FUNCTION (b))); 348 if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL) 349 { 350 fprintf_filtered (outfile, ", %s", 351 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b))); 352 } 353 } 354 fprintf_filtered (outfile, "\n"); 355 /* Now print each symbol in this block (in no particular order, if 356 we're using a hashtable). */ 357 ALL_BLOCK_SYMBOLS (b, iter, sym) 358 { 359 struct print_symbol_args s; 360 361 s.gdbarch = gdbarch; 362 s.symbol = sym; 363 s.depth = depth + 1; 364 s.outfile = outfile; 365 catch_errors (print_symbol, &s, "Error printing symbol:\n", 366 RETURN_MASK_ERROR); 367 } 368 } 369 fprintf_filtered (outfile, "\n"); 370 } 371 else 372 { 373 fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n"); 374 } 375 } 376 377 static void 378 dump_symtab (struct objfile *objfile, struct symtab *symtab, 379 struct ui_file *outfile) 380 { 381 /* Set the current language to the language of the symtab we're dumping 382 because certain routines used during dump_symtab() use the current 383 language to print an image of the symbol. We'll restore it later. 384 But use only real languages, not placeholders. */ 385 if (symtab->language != language_unknown 386 && symtab->language != language_auto) 387 { 388 enum language saved_lang; 389 390 saved_lang = set_language (symtab->language); 391 392 dump_symtab_1 (objfile, symtab, outfile); 393 394 set_language (saved_lang); 395 } 396 else 397 dump_symtab_1 (objfile, symtab, outfile); 398 } 399 400 void 401 maintenance_print_symbols (char *args, int from_tty) 402 { 403 char **argv; 404 struct ui_file *outfile; 405 struct cleanup *cleanups; 406 char *symname = NULL; 407 char *filename = DEV_TTY; 408 struct objfile *objfile; 409 struct symtab *s; 410 411 dont_repeat (); 412 413 if (args == NULL) 414 { 415 error (_("Arguments missing: an output file name " 416 "and an optional symbol file name")); 417 } 418 argv = gdb_buildargv (args); 419 cleanups = make_cleanup_freeargv (argv); 420 421 if (argv[0] != NULL) 422 { 423 filename = argv[0]; 424 /* If a second arg is supplied, it is a source file name to match on. */ 425 if (argv[1] != NULL) 426 { 427 symname = argv[1]; 428 } 429 } 430 431 filename = tilde_expand (filename); 432 make_cleanup (xfree, filename); 433 434 outfile = gdb_fopen (filename, FOPEN_WT); 435 if (outfile == 0) 436 perror_with_name (filename); 437 make_cleanup_ui_file_delete (outfile); 438 439 immediate_quit++; 440 ALL_SYMTABS (objfile, s) 441 if (symname == NULL || filename_cmp (symname, s->filename) == 0) 442 dump_symtab (objfile, s, outfile); 443 immediate_quit--; 444 do_cleanups (cleanups); 445 } 446 447 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE. ARGS->DEPTH says how 448 far to indent. ARGS is really a struct print_symbol_args *, but is 449 declared as char * to get it past catch_errors. Returns 0 for error, 450 1 for success. */ 451 452 static int 453 print_symbol (void *args) 454 { 455 struct gdbarch *gdbarch = ((struct print_symbol_args *) args)->gdbarch; 456 struct symbol *symbol = ((struct print_symbol_args *) args)->symbol; 457 int depth = ((struct print_symbol_args *) args)->depth; 458 struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile; 459 struct obj_section *section = SYMBOL_OBJ_SECTION (symbol); 460 461 print_spaces (depth, outfile); 462 if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN) 463 { 464 fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol)); 465 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)), 466 outfile); 467 if (section) 468 fprintf_filtered (outfile, " section %s\n", 469 bfd_section_name (section->the_bfd_section->owner, 470 section->the_bfd_section)); 471 else 472 fprintf_filtered (outfile, "\n"); 473 return 1; 474 } 475 if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN) 476 { 477 if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol))) 478 { 479 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth); 480 } 481 else 482 { 483 fprintf_filtered (outfile, "%s %s = ", 484 (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM 485 ? "enum" 486 : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT 487 ? "struct" : "union")), 488 SYMBOL_LINKAGE_NAME (symbol)); 489 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth); 490 } 491 fprintf_filtered (outfile, ";\n"); 492 } 493 else 494 { 495 if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF) 496 fprintf_filtered (outfile, "typedef "); 497 if (SYMBOL_TYPE (symbol)) 498 { 499 /* Print details of types, except for enums where it's clutter. */ 500 LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol), 501 outfile, 502 TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM, 503 depth); 504 fprintf_filtered (outfile, "; "); 505 } 506 else 507 fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol)); 508 509 switch (SYMBOL_CLASS (symbol)) 510 { 511 case LOC_CONST: 512 fprintf_filtered (outfile, "const %ld (0x%lx)", 513 SYMBOL_VALUE (symbol), 514 SYMBOL_VALUE (symbol)); 515 break; 516 517 case LOC_CONST_BYTES: 518 { 519 unsigned i; 520 struct type *type = check_typedef (SYMBOL_TYPE (symbol)); 521 522 fprintf_filtered (outfile, "const %u hex bytes:", 523 TYPE_LENGTH (type)); 524 for (i = 0; i < TYPE_LENGTH (type); i++) 525 fprintf_filtered (outfile, " %02x", 526 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]); 527 } 528 break; 529 530 case LOC_STATIC: 531 fprintf_filtered (outfile, "static at "); 532 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)), 533 outfile); 534 if (section) 535 fprintf_filtered (outfile, " section %s", 536 bfd_section_name (section->the_bfd_section->owner, 537 section->the_bfd_section)); 538 break; 539 540 case LOC_REGISTER: 541 if (SYMBOL_IS_ARGUMENT (symbol)) 542 fprintf_filtered (outfile, "parameter register %ld", 543 SYMBOL_VALUE (symbol)); 544 else 545 fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol)); 546 break; 547 548 case LOC_ARG: 549 fprintf_filtered (outfile, "arg at offset 0x%lx", 550 SYMBOL_VALUE (symbol)); 551 break; 552 553 case LOC_REF_ARG: 554 fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol)); 555 break; 556 557 case LOC_REGPARM_ADDR: 558 fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol)); 559 break; 560 561 case LOC_LOCAL: 562 fprintf_filtered (outfile, "local at offset 0x%lx", 563 SYMBOL_VALUE (symbol)); 564 break; 565 566 case LOC_TYPEDEF: 567 break; 568 569 case LOC_LABEL: 570 fprintf_filtered (outfile, "label at "); 571 fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (symbol)), 572 outfile); 573 if (section) 574 fprintf_filtered (outfile, " section %s", 575 bfd_section_name (section->the_bfd_section->owner, 576 section->the_bfd_section)); 577 break; 578 579 case LOC_BLOCK: 580 fprintf_filtered (outfile, "block object "); 581 gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile); 582 fprintf_filtered (outfile, ", "); 583 fputs_filtered (paddress (gdbarch, 584 BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))), 585 outfile); 586 fprintf_filtered (outfile, ".."); 587 fputs_filtered (paddress (gdbarch, 588 BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))), 589 outfile); 590 if (section) 591 fprintf_filtered (outfile, " section %s", 592 bfd_section_name (section->the_bfd_section->owner, 593 section->the_bfd_section)); 594 break; 595 596 case LOC_COMPUTED: 597 fprintf_filtered (outfile, "computed at runtime"); 598 break; 599 600 case LOC_UNRESOLVED: 601 fprintf_filtered (outfile, "unresolved"); 602 break; 603 604 case LOC_OPTIMIZED_OUT: 605 fprintf_filtered (outfile, "optimized out"); 606 break; 607 608 default: 609 fprintf_filtered (outfile, "botched symbol class %x", 610 SYMBOL_CLASS (symbol)); 611 break; 612 } 613 } 614 fprintf_filtered (outfile, "\n"); 615 return 1; 616 } 617 618 void 619 maintenance_print_msymbols (char *args, int from_tty) 620 { 621 char **argv; 622 struct ui_file *outfile; 623 struct cleanup *cleanups; 624 char *filename = DEV_TTY; 625 char *symname = NULL; 626 struct program_space *pspace; 627 struct objfile *objfile; 628 629 struct stat sym_st, obj_st; 630 631 dont_repeat (); 632 633 if (args == NULL) 634 { 635 error (_("print-msymbols takes an output file " 636 "name and optional symbol file name")); 637 } 638 argv = gdb_buildargv (args); 639 cleanups = make_cleanup_freeargv (argv); 640 641 if (argv[0] != NULL) 642 { 643 filename = argv[0]; 644 /* If a second arg is supplied, it is a source file name to match on. */ 645 if (argv[1] != NULL) 646 { 647 symname = xfullpath (argv[1]); 648 make_cleanup (xfree, symname); 649 if (symname && stat (symname, &sym_st)) 650 perror_with_name (symname); 651 } 652 } 653 654 filename = tilde_expand (filename); 655 make_cleanup (xfree, filename); 656 657 outfile = gdb_fopen (filename, FOPEN_WT); 658 if (outfile == 0) 659 perror_with_name (filename); 660 make_cleanup_ui_file_delete (outfile); 661 662 immediate_quit++; 663 ALL_PSPACES (pspace) 664 ALL_PSPACE_OBJFILES (pspace, objfile) 665 if (symname == NULL || (!stat (objfile->name, &obj_st) 666 && sym_st.st_ino == obj_st.st_ino)) 667 dump_msymbols (objfile, outfile); 668 immediate_quit--; 669 fprintf_filtered (outfile, "\n\n"); 670 do_cleanups (cleanups); 671 } 672 673 void 674 maintenance_print_objfiles (char *ignore, int from_tty) 675 { 676 struct program_space *pspace; 677 struct objfile *objfile; 678 679 dont_repeat (); 680 681 immediate_quit++; 682 ALL_PSPACES (pspace) 683 ALL_PSPACE_OBJFILES (pspace, objfile) 684 dump_objfile (objfile); 685 immediate_quit--; 686 } 687 688 689 /* List all the symbol tables whose names match REGEXP (optional). */ 690 void 691 maintenance_info_symtabs (char *regexp, int from_tty) 692 { 693 struct program_space *pspace; 694 struct objfile *objfile; 695 696 if (regexp) 697 re_comp (regexp); 698 699 ALL_PSPACES (pspace) 700 ALL_PSPACE_OBJFILES (pspace, objfile) 701 { 702 struct symtab *symtab; 703 704 /* We don't want to print anything for this objfile until we 705 actually find a symtab whose name matches. */ 706 int printed_objfile_start = 0; 707 708 ALL_OBJFILE_SYMTABS (objfile, symtab) 709 { 710 QUIT; 711 712 if (! regexp 713 || re_exec (symtab->filename)) 714 { 715 if (! printed_objfile_start) 716 { 717 printf_filtered ("{ objfile %s ", objfile->name); 718 wrap_here (" "); 719 printf_filtered ("((struct objfile *) %s)\n", 720 host_address_to_string (objfile)); 721 printed_objfile_start = 1; 722 } 723 724 printf_filtered (" { symtab %s ", symtab->filename); 725 wrap_here (" "); 726 printf_filtered ("((struct symtab *) %s)\n", 727 host_address_to_string (symtab)); 728 printf_filtered (" dirname %s\n", 729 symtab->dirname ? symtab->dirname : "(null)"); 730 printf_filtered (" fullname %s\n", 731 symtab->fullname ? symtab->fullname : "(null)"); 732 printf_filtered (" " 733 "blockvector ((struct blockvector *) %s)%s\n", 734 host_address_to_string (symtab->blockvector), 735 symtab->primary ? " (primary)" : ""); 736 printf_filtered (" " 737 "linetable ((struct linetable *) %s)\n", 738 host_address_to_string (symtab->linetable)); 739 printf_filtered (" debugformat %s\n", 740 symtab->debugformat); 741 printf_filtered (" }\n"); 742 } 743 } 744 745 if (printed_objfile_start) 746 printf_filtered ("}\n"); 747 } 748 } 749 750 751 /* Return the nexting depth of a block within other blocks in its symtab. */ 752 753 static int 754 block_depth (struct block *block) 755 { 756 int i = 0; 757 758 while ((block = BLOCK_SUPERBLOCK (block)) != NULL) 759 { 760 i++; 761 } 762 return i; 763 } 764 765 766 /* Do early runtime initializations. */ 767 void 768 _initialize_symmisc (void) 769 { 770 std_in = stdin; 771 std_out = stdout; 772 std_err = stderr; 773 } 774