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
   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)
 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   enum language saved_lang;
 500
 501   /* Set the current language to the language of the symtab we're dumping
 502      because certain routines used during dump_symtab() use the current
 503      language to print an image of the symbol.  We'll restore it later.  */
 504   saved_lang = set_language (symtab->language);
 505
 506   dump_symtab_1 (objfile, symtab, outfile);
 507
 508   set_language (saved_lang);
 509 }
 510
 511 void
 512 maintenance_print_symbols (char *args, int from_tty)
 513 {
 514   char **argv;
 515   struct ui_file *outfile;
 516   struct cleanup *cleanups;
 517   char *symname = NULL;
 518   char *filename = DEV_TTY;
 519   struct objfile *objfile;
 520   struct symtab *s;
 521
 522   dont_repeat ();
 523
 524   if (args == NULL)
 525     {
 526       error (_("\
 527 Arguments missing: an output file name and an optional symbol file name"));
 528     }
 529   else if ((argv = buildargv (args)) == NULL)
 530     {
 531       nomem (0);
 532     }
 533   cleanups = make_cleanup_freeargv (argv);
 534
 535   if (argv[0] != NULL)
 536     {
 537       filename = argv[0];
 538       /* If a second arg is supplied, it is a source file name to match on */
 539       if (argv[1] != NULL)
 540         {
 541           symname = argv[1];
 542         }
 543     }
 544
 545   filename = tilde_expand (filename);
 546   make_cleanup (xfree, filename);
 547
 548   outfile = gdb_fopen (filename, FOPEN_WT);
 549   if (outfile == 0)
 550     perror_with_name (filename);
 551   make_cleanup_ui_file_delete (outfile);
 552
 553   immediate_quit++;
 554   ALL_SYMTABS (objfile, s)
 555     if (symname == NULL || strcmp (symname, s->filename) == 0)
 556     dump_symtab (objfile, s, outfile);
 557   immediate_quit--;
 558   do_cleanups (cleanups);
 559 }
 560
 561 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 562    far to indent.  ARGS is really a struct print_symbol_args *, but is
 563    declared as char * to get it past catch_errors.  Returns 0 for error,
 564    1 for success.  */
 565
 566 static int
 567 print_symbol (void *args)
 568 {
 569   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 570   int depth = ((struct print_symbol_args *) args)->depth;
 571   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 572   struct obj_section *section = SYMBOL_OBJ_SECTION (symbol);
 573
 574   print_spaces (depth, outfile);
 575   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 576     {
 577       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 578       fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
 579       if (section)
 580         fprintf_filtered (outfile, " section %s\n",
 581                           bfd_section_name (section->the_bfd_section->owner,
 582                                             section->the_bfd_section));
 583       else
 584         fprintf_filtered (outfile, "\n");
 585       return 1;
 586     }
 587   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 588     {
 589       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 590         {
 591           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 592         }
 593       else
 594         {
 595           fprintf_filtered (outfile, "%s %s = ",
 596                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 597                           ? "enum"
 598                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 599                         ? "struct" : "union")),
 600                             SYMBOL_LINKAGE_NAME (symbol));
 601           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 602         }
 603       fprintf_filtered (outfile, ";\n");
 604     }
 605   else
 606     {
 607       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 608         fprintf_filtered (outfile, "typedef ");
 609       if (SYMBOL_TYPE (symbol))
 610         {
 611           /* Print details of types, except for enums where it's clutter.  */
 612           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 613                          outfile,
 614                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 615                          depth);
 616           fprintf_filtered (outfile, "; ");
 617         }
 618       else
 619         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 620
 621       switch (SYMBOL_CLASS (symbol))
 622         {
 623         case LOC_CONST:
 624           fprintf_filtered (outfile, "const %ld (0x%lx)",
 625                             SYMBOL_VALUE (symbol),
 626                             SYMBOL_VALUE (symbol));
 627           break;
 628
 629         case LOC_CONST_BYTES:
 630           {
 631             unsigned i;
 632             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 633             fprintf_filtered (outfile, "const %u hex bytes:",
 634                               TYPE_LENGTH (type));
 635             for (i = 0; i < TYPE_LENGTH (type); i++)
 636               fprintf_filtered (outfile, " %02x",
 637                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 638           }
 639           break;
 640
 641         case LOC_STATIC:
 642           fprintf_filtered (outfile, "static at ");
 643           fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
 644           if (section)
 645             fprintf_filtered (outfile, " section %s",
 646                               bfd_section_name (section->the_bfd_section->owner,
 647                                                 section->the_bfd_section));
 648           break;
 649
 650         case LOC_REGISTER:
 651           if (SYMBOL_IS_ARGUMENT (symbol))
 652             fprintf_filtered (outfile, "parameter register %ld",
 653                               SYMBOL_VALUE (symbol));
 654           else
 655             fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
 656           break;
 657
 658         case LOC_ARG:
 659           fprintf_filtered (outfile, "arg at offset 0x%lx",
 660                             SYMBOL_VALUE (symbol));
 661           break;
 662
 663         case LOC_REF_ARG:
 664           fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
 665           break;
 666
 667         case LOC_REGPARM_ADDR:
 668           fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
 669           break;
 670
 671         case LOC_LOCAL:
 672           fprintf_filtered (outfile, "local at offset 0x%lx",
 673                             SYMBOL_VALUE (symbol));
 674           break;
 675
 676         case LOC_TYPEDEF:
 677           break;
 678
 679         case LOC_LABEL:
 680           fprintf_filtered (outfile, "label at ");
 681           fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (symbol)), outfile);
 682           if (section)
 683             fprintf_filtered (outfile, " section %s",
 684                               bfd_section_name (section->the_bfd_section->owner,
 685                                                 section->the_bfd_section));
 686           break;
 687
 688         case LOC_BLOCK:
 689           fprintf_filtered (outfile, "block object ");
 690           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 691           fprintf_filtered (outfile, ", ");
 692           fputs_filtered (paddress (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol))),
 693                           outfile);
 694           fprintf_filtered (outfile, "..");
 695           fputs_filtered (paddress (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol))),
 696                           outfile);
 697           if (section)
 698             fprintf_filtered (outfile, " section %s",
 699                               bfd_section_name (section->the_bfd_section->owner,
 700                                                 section->the_bfd_section));
 701           break;
 702
 703         case LOC_COMPUTED:
 704           fprintf_filtered (outfile, "computed at runtime");
 705           break;
 706
 707         case LOC_UNRESOLVED:
 708           fprintf_filtered (outfile, "unresolved");
 709           break;
 710
 711         case LOC_OPTIMIZED_OUT:
 712           fprintf_filtered (outfile, "optimized out");
 713           break;
 714
 715         default:
 716           fprintf_filtered (outfile, "botched symbol class %x",
 717                             SYMBOL_CLASS (symbol));
 718           break;
 719         }
 720     }
 721   fprintf_filtered (outfile, "\n");
 722   return 1;
 723 }
 724
 725 void
 726 maintenance_print_psymbols (char *args, int from_tty)
 727 {
 728   char **argv;
 729   struct ui_file *outfile;
 730   struct cleanup *cleanups;
 731   char *symname = NULL;
 732   char *filename = DEV_TTY;
 733   struct objfile *objfile;
 734   struct partial_symtab *ps;
 735
 736   dont_repeat ();
 737
 738   if (args == NULL)
 739     {
 740       error (_("print-psymbols takes an output file name and optional symbol file name"));
 741     }
 742   else if ((argv = buildargv (args)) == NULL)
 743     {
 744       nomem (0);
 745     }
 746   cleanups = make_cleanup_freeargv (argv);
 747
 748   if (argv[0] != NULL)
 749     {
 750       filename = argv[0];
 751       /* If a second arg is supplied, it is a source file name to match on */
 752       if (argv[1] != NULL)
 753         {
 754           symname = argv[1];
 755         }
 756     }
 757
 758   filename = tilde_expand (filename);
 759   make_cleanup (xfree, filename);
 760
 761   outfile = gdb_fopen (filename, FOPEN_WT);
 762   if (outfile == 0)
 763     perror_with_name (filename);
 764   make_cleanup_ui_file_delete (outfile);
 765
 766   immediate_quit++;
 767   ALL_PSYMTABS (objfile, ps)
 768     if (symname == NULL || strcmp (symname, ps->filename) == 0)
 769     dump_psymtab (objfile, ps, outfile);
 770   immediate_quit--;
 771   do_cleanups (cleanups);
 772 }
 773
 774 static void
 775 print_partial_symbols (struct partial_symbol **p, int count, char *what,
 776                        struct ui_file *outfile)
 777 {
 778   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
 779   while (count-- > 0)
 780     {
 781       fprintf_filtered (outfile, "    `%s'", SYMBOL_LINKAGE_NAME (*p));
 782       if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
 783         {
 784           fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (*p));
 785         }
 786       fputs_filtered (", ", outfile);
 787       switch (SYMBOL_DOMAIN (*p))
 788         {
 789         case UNDEF_DOMAIN:
 790           fputs_filtered ("undefined domain, ", outfile);
 791           break;
 792         case VAR_DOMAIN:
 793           /* This is the usual thing -- don't print it */
 794           break;
 795         case STRUCT_DOMAIN:
 796           fputs_filtered ("struct domain, ", outfile);
 797           break;
 798         case LABEL_DOMAIN:
 799           fputs_filtered ("label domain, ", outfile);
 800           break;
 801         default:
 802           fputs_filtered ("<invalid domain>, ", outfile);
 803           break;
 804         }
 805       switch (SYMBOL_CLASS (*p))
 806         {
 807         case LOC_UNDEF:
 808           fputs_filtered ("undefined", outfile);
 809           break;
 810         case LOC_CONST:
 811           fputs_filtered ("constant int", outfile);
 812           break;
 813         case LOC_STATIC:
 814           fputs_filtered ("static", outfile);
 815           break;
 816         case LOC_REGISTER:
 817           fputs_filtered ("register", outfile);
 818           break;
 819         case LOC_ARG:
 820           fputs_filtered ("pass by value", outfile);
 821           break;
 822         case LOC_REF_ARG:
 823           fputs_filtered ("pass by reference", outfile);
 824           break;
 825         case LOC_REGPARM_ADDR:
 826           fputs_filtered ("register address parameter", outfile);
 827           break;
 828         case LOC_LOCAL:
 829           fputs_filtered ("stack parameter", outfile);
 830           break;
 831         case LOC_TYPEDEF:
 832           fputs_filtered ("type", outfile);
 833           break;
 834         case LOC_LABEL:
 835           fputs_filtered ("label", outfile);
 836           break;
 837         case LOC_BLOCK:
 838           fputs_filtered ("function", outfile);
 839           break;
 840         case LOC_CONST_BYTES:
 841           fputs_filtered ("constant bytes", outfile);
 842           break;
 843         case LOC_UNRESOLVED:
 844           fputs_filtered ("unresolved", outfile);
 845           break;
 846         case LOC_OPTIMIZED_OUT:
 847           fputs_filtered ("optimized out", outfile);
 848           break;
 849         case LOC_COMPUTED:
 850           fputs_filtered ("computed at runtime", outfile);
 851           break;
 852         default:
 853           fputs_filtered ("<invalid location>", outfile);
 854           break;
 855         }
 856       fputs_filtered (", ", outfile);
 857       fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (*p)), outfile);
 858       fprintf_filtered (outfile, "\n");
 859       p++;
 860     }
 861 }
 862
 863 void
 864 maintenance_print_msymbols (char *args, int from_tty)
 865 {
 866   char **argv;
 867   struct ui_file *outfile;
 868   struct cleanup *cleanups;
 869   char *filename = DEV_TTY;
 870   char *symname = NULL;
 871   struct objfile *objfile;
 872
 873   struct stat sym_st, obj_st;
 874
 875   dont_repeat ();
 876
 877   if (args == NULL)
 878     {
 879       error (_("print-msymbols takes an output file name and optional symbol file name"));
 880     }
 881   else if ((argv = buildargv (args)) == NULL)
 882     {
 883       nomem (0);
 884     }
 885   cleanups = make_cleanup_freeargv (argv);
 886
 887   if (argv[0] != NULL)
 888     {
 889       filename = argv[0];
 890       /* If a second arg is supplied, it is a source file name to match on */
 891       if (argv[1] != NULL)
 892         {
 893           symname = xfullpath (argv[1]);
 894           make_cleanup (xfree, symname);
 895           if (symname && stat (symname, &sym_st))
 896             perror_with_name (symname);
 897         }
 898     }
 899
 900   filename = tilde_expand (filename);
 901   make_cleanup (xfree, filename);
 902
 903   outfile = gdb_fopen (filename, FOPEN_WT);
 904   if (outfile == 0)
 905     perror_with_name (filename);
 906   make_cleanup_ui_file_delete (outfile);
 907
 908   immediate_quit++;
 909   ALL_OBJFILES (objfile)
 910     if (symname == NULL
 911         || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
 912       dump_msymbols (objfile, outfile);
 913   immediate_quit--;
 914   fprintf_filtered (outfile, "\n\n");
 915   do_cleanups (cleanups);
 916 }
 917
 918 void
 919 maintenance_print_objfiles (char *ignore, int from_tty)
 920 {
 921   struct objfile *objfile;
 922
 923   dont_repeat ();
 924
 925   immediate_quit++;
 926   ALL_OBJFILES (objfile)
 927     dump_objfile (objfile);
 928   immediate_quit--;
 929 }
 930
 931
 932 /* List all the symbol tables whose names match REGEXP (optional).  */
 933 void
 934 maintenance_info_symtabs (char *regexp, int from_tty)
 935 {
 936   struct objfile *objfile;
 937
 938   if (regexp)
 939     re_comp (regexp);
 940
 941   ALL_OBJFILES (objfile)
 942     {
 943       struct symtab *symtab;
 944
 945       /* We don't want to print anything for this objfile until we
 946          actually find a symtab whose name matches.  */
 947       int printed_objfile_start = 0;
 948
 949       ALL_OBJFILE_SYMTABS (objfile, symtab)
 950         if (! regexp
 951             || re_exec (symtab->filename))
 952           {
 953             if (! printed_objfile_start)
 954               {
 955                 printf_filtered ("{ objfile %s ", objfile->name);
 956                 wrap_here ("  ");
 957                 printf_filtered ("((struct objfile *) %p)\n", objfile);
 958                 printed_objfile_start = 1;
 959               }
 960
 961             printf_filtered ("  { symtab %s ", symtab->filename);
 962             wrap_here ("    ");
 963             printf_filtered ("((struct symtab *) %p)\n", symtab);
 964             printf_filtered ("    dirname %s\n",
 965                              symtab->dirname ? symtab->dirname : "(null)");
 966             printf_filtered ("    fullname %s\n",
 967                              symtab->fullname ? symtab->fullname : "(null)");
 968             printf_filtered ("    blockvector ((struct blockvector *) %p)%s\n",
 969                              symtab->blockvector,
 970                              symtab->primary ? " (primary)" : "");
 971             printf_filtered ("    linetable ((struct linetable *) %p)\n",
 972                              symtab->linetable);
 973             printf_filtered ("    debugformat %s\n", symtab->debugformat);
 974             printf_filtered ("  }\n");
 975           }
 976
 977       if (printed_objfile_start)
 978         printf_filtered ("}\n");
 979     }
 980 }
 981
 982
 983 /* List all the partial symbol tables whose names match REGEXP (optional).  */
 984 void
 985 maintenance_info_psymtabs (char *regexp, int from_tty)
 986 {
 987   struct objfile *objfile;
 988
 989   if (regexp)
 990     re_comp (regexp);
 991
 992   ALL_OBJFILES (objfile)
 993     {
 994       struct partial_symtab *psymtab;
 995
 996       /* We don't want to print anything for this objfile until we
 997          actually find a symtab whose name matches.  */
 998       int printed_objfile_start = 0;
 999
1000       ALL_OBJFILE_PSYMTABS (objfile, psymtab)
1001         if (! regexp
1002             || re_exec (psymtab->filename))
1003           {
1004             if (! printed_objfile_start)
1005               {
1006                 printf_filtered ("{ objfile %s ", objfile->name);
1007                 wrap_here ("  ");
1008                 printf_filtered ("((struct objfile *) %p)\n", objfile);
1009                 printed_objfile_start = 1;
1010               }
1011
1012             printf_filtered ("  { psymtab %s ", psymtab->filename);
1013             wrap_here ("    ");
1014             printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
1015             printf_filtered ("    readin %s\n",
1016                              psymtab->readin ? "yes" : "no");
1017             printf_filtered ("    fullname %s\n",
1018                              psymtab->fullname ? psymtab->fullname : "(null)");
1019             printf_filtered ("    text addresses ");
1020             fputs_filtered (paddress (psymtab->textlow), gdb_stdout);
1021             printf_filtered (" -- ");
1022             fputs_filtered (paddress (psymtab->texthigh), gdb_stdout);
1023             printf_filtered ("\n");
1024             printf_filtered ("    globals ");
1025             if (psymtab->n_global_syms)
1026               {
1027                 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1028                                  (psymtab->objfile->global_psymbols.list
1029                                   + psymtab->globals_offset),
1030                                  psymtab->n_global_syms);
1031               }
1032             else
1033               printf_filtered ("(none)\n");
1034             printf_filtered ("    statics ");
1035             if (psymtab->n_static_syms)
1036               {
1037                 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1038                                  (psymtab->objfile->static_psymbols.list
1039                                   + psymtab->statics_offset),
1040                                  psymtab->n_static_syms);
1041               }
1042             else
1043               printf_filtered ("(none)\n");
1044             printf_filtered ("    dependencies ");
1045             if (psymtab->number_of_dependencies)
1046               {
1047                 int i;
1048
1049                 printf_filtered ("{\n");
1050                 for (i = 0; i < psymtab->number_of_dependencies; i++)
1051                   {
1052                     struct partial_symtab *dep = psymtab->dependencies[i];
1053
1054                     /* Note the string concatenation there --- no comma.  */
1055                     printf_filtered ("      psymtab %s "
1056                                      "((struct partial_symtab *) %p)\n",
1057                                      dep->filename, dep);
1058                   }
1059                 printf_filtered ("    }\n");
1060               }
1061             else
1062               printf_filtered ("(none)\n");
1063             printf_filtered ("  }\n");
1064           }
1065
1066       if (printed_objfile_start)
1067         printf_filtered ("}\n");
1068     }
1069 }
1070
1071
1072 /* Check consistency of psymtabs and symtabs.  */
1073
1074 void
1075 maintenance_check_symtabs (char *ignore, int from_tty)
1076 {
1077   struct symbol *sym;
1078   struct partial_symbol **psym;
1079   struct symtab *s = NULL;
1080   struct partial_symtab *ps;
1081   struct blockvector *bv;
1082   struct objfile *objfile;
1083   struct block *b;
1084   int length;
1085
1086   ALL_PSYMTABS (objfile, ps)
1087   {
1088     s = PSYMTAB_TO_SYMTAB (ps);
1089     if (s == NULL)
1090       continue;
1091     bv = BLOCKVECTOR (s);
1092     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1093     psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1094     length = ps->n_static_syms;
1095     while (length--)
1096       {
1097         sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1098                                    NULL, SYMBOL_DOMAIN (*psym));
1099         if (!sym)
1100           {
1101             printf_filtered ("Static symbol `");
1102             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
1103             printf_filtered ("' only found in ");
1104             puts_filtered (ps->filename);
1105             printf_filtered (" psymtab\n");
1106           }
1107         psym++;
1108       }
1109     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1110     psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1111     length = ps->n_global_syms;
1112     while (length--)
1113       {
1114         sym = lookup_block_symbol (b, SYMBOL_LINKAGE_NAME (*psym),
1115                                    NULL, SYMBOL_DOMAIN (*psym));
1116         if (!sym)
1117           {
1118             printf_filtered ("Global symbol `");
1119             puts_filtered (SYMBOL_LINKAGE_NAME (*psym));
1120             printf_filtered ("' only found in ");
1121             puts_filtered (ps->filename);
1122             printf_filtered (" psymtab\n");
1123           }
1124         psym++;
1125       }
1126     if (ps->texthigh < ps->textlow)
1127       {
1128         printf_filtered ("Psymtab ");
1129         puts_filtered (ps->filename);
1130         printf_filtered (" covers bad range ");
1131         fputs_filtered (paddress (ps->textlow), gdb_stdout);
1132         printf_filtered (" - ");
1133         fputs_filtered (paddress (ps->texthigh), gdb_stdout);
1134         printf_filtered ("\n");
1135         continue;
1136       }
1137     if (ps->texthigh == 0)
1138       continue;
1139     if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1140       {
1141         printf_filtered ("Psymtab ");
1142         puts_filtered (ps->filename);
1143         printf_filtered (" covers ");
1144         fputs_filtered (paddress (ps->textlow), gdb_stdout);
1145         printf_filtered (" - ");
1146         fputs_filtered (paddress (ps->texthigh), gdb_stdout);
1147         printf_filtered (" but symtab covers only ");
1148         fputs_filtered (paddress (BLOCK_START (b)), gdb_stdout);
1149         printf_filtered (" - ");
1150         fputs_filtered (paddress (BLOCK_END (b)), gdb_stdout);
1151         printf_filtered ("\n");
1152       }
1153   }
1154 }
1155 \f
1156
1157 /* Return the nexting depth of a block within other blocks in its symtab.  */
1158
1159 static int
1160 block_depth (struct block *block)
1161 {
1162   int i = 0;
1163   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1164     {
1165       i++;
1166     }
1167   return i;
1168 }
1169 \f
1170
1171 /* Increase the space allocated for LISTP, which is probably
1172    global_psymbols or static_psymbols. This space will eventually
1173    be freed in free_objfile().  */
1174
1175 void
1176 extend_psymbol_list (struct psymbol_allocation_list *listp,
1177                      struct objfile *objfile)
1178 {
1179   int new_size;
1180   if (listp->size == 0)
1181     {
1182       new_size = 255;
1183       listp->list = (struct partial_symbol **)
1184         xmalloc (new_size * sizeof (struct partial_symbol *));
1185     }
1186   else
1187     {
1188       new_size = listp->size * 2;
1189       listp->list = (struct partial_symbol **)
1190         xrealloc ((char *) listp->list,
1191                   new_size * sizeof (struct partial_symbol *));
1192     }
1193   /* Next assumes we only went one over.  Should be good if
1194      program works correctly */
1195   listp->next = listp->list + listp->size;
1196   listp->size = new_size;
1197 }
1198
1199
1200 /* Do early runtime initializations. */
1201 void
1202 _initialize_symmisc (void)
1203 {
1204   std_in = stdin;
1205   std_out = stdout;
1206   std_err = stderr;
1207 }