gdb/symmisc.c

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