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