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 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
 360       if (msymbol->filename)
 361         fprintf_filtered (outfile, "  %s", msymbol->filename);
 362 #endif
 363       fputs_filtered ("\n", outfile);
 364     }
 365   if (objfile->minimal_symbol_count != index)
 366     {
 367       warning (_("internal error:  minimal symbol count %d != %d"),
 368                objfile->minimal_symbol_count, index);
 369     }
 370   fprintf_filtered (outfile, "\n");
 371 }
 372
 373 static void
 374 dump_psymtab (struct objfile *objfile, struct partial_symtab *psymtab,
 375               struct ui_file *outfile)
 376 {
 377   int i;
 378
 379   fprintf_filtered (outfile, "\nPartial symtab for source file %s ",
 380                     psymtab->filename);
 381   fprintf_filtered (outfile, "(object ");
 382   gdb_print_host_address (psymtab, outfile);
 383   fprintf_filtered (outfile, ")\n\n");
 384   fprintf_unfiltered (outfile, "  Read from object file %s (",
 385                       objfile->name);
 386   gdb_print_host_address (objfile, outfile);
 387   fprintf_unfiltered (outfile, ")\n");
 388
 389   if (psymtab->readin)
 390     {
 391       fprintf_filtered (outfile,
 392                         "  Full symtab was read (at ");
 393       gdb_print_host_address (psymtab->symtab, outfile);
 394       fprintf_filtered (outfile, " by function at ");
 395       gdb_print_host_address (psymtab->read_symtab, outfile);
 396       fprintf_filtered (outfile, ")\n");
 397     }
 398
 399   fprintf_filtered (outfile, "  Relocate symbols by ");
 400   for (i = 0; i < psymtab->objfile->num_sections; ++i)
 401     {
 402       if (i != 0)
 403         fprintf_filtered (outfile, ", ");
 404       wrap_here ("    ");
 405       deprecated_print_address_numeric (ANOFFSET (psymtab->section_offsets, i),
 406                              1,
 407                              outfile);
 408     }
 409   fprintf_filtered (outfile, "\n");
 410
 411   fprintf_filtered (outfile, "  Symbols cover text addresses ");
 412   deprecated_print_address_numeric (psymtab->textlow, 1, outfile);
 413   fprintf_filtered (outfile, "-");
 414   deprecated_print_address_numeric (psymtab->texthigh, 1, outfile);
 415   fprintf_filtered (outfile, "\n");
 416   fprintf_filtered (outfile, "  Depends on %d other partial symtabs.\n",
 417                     psymtab->number_of_dependencies);
 418   for (i = 0; i < psymtab->number_of_dependencies; i++)
 419     {
 420       fprintf_filtered (outfile, "    %d ", i);
 421       gdb_print_host_address (psymtab->dependencies[i], outfile);
 422       fprintf_filtered (outfile, " %s\n",
 423                         psymtab->dependencies[i]->filename);
 424     }
 425   if (psymtab->n_global_syms > 0)
 426     {
 427       print_partial_symbols (objfile->global_psymbols.list
 428                              + psymtab->globals_offset,
 429                              psymtab->n_global_syms, "Global", outfile);
 430     }
 431   if (psymtab->n_static_syms > 0)
 432     {
 433       print_partial_symbols (objfile->static_psymbols.list
 434                              + psymtab->statics_offset,
 435                              psymtab->n_static_syms, "Static", outfile);
 436     }
 437   fprintf_filtered (outfile, "\n");
 438 }
 439
 440 static void
 441 dump_symtab_1 (struct objfile *objfile, struct symtab *symtab,
 442                struct ui_file *outfile)
 443 {
 444   int i;
 445   struct dict_iterator iter;
 446   int len, blen;
 447   struct linetable *l;
 448   struct blockvector *bv;
 449   struct symbol *sym;
 450   struct block *b;
 451   int depth;
 452
 453   fprintf_filtered (outfile, "\nSymtab for file %s\n", symtab->filename);
 454   if (symtab->dirname)
 455     fprintf_filtered (outfile, "Compilation directory is %s\n",
 456                       symtab->dirname);
 457   fprintf_filtered (outfile, "Read from object file %s (", objfile->name);
 458   gdb_print_host_address (objfile, outfile);
 459   fprintf_filtered (outfile, ")\n");
 460   fprintf_filtered (outfile, "Language: %s\n", language_str (symtab->language));
 461
 462   /* First print the line table.  */
 463   l = LINETABLE (symtab);
 464   if (l)
 465     {
 466       fprintf_filtered (outfile, "\nLine table:\n\n");
 467       len = l->nitems;
 468       for (i = 0; i < len; i++)
 469         {
 470           fprintf_filtered (outfile, " line %d at ", l->item[i].line);
 471           deprecated_print_address_numeric (l->item[i].pc, 1, outfile);
 472           fprintf_filtered (outfile, "\n");
 473         }
 474     }
 475   /* Now print the block info, but only for primary symtabs since we will
 476      print lots of duplicate info otherwise. */
 477   if (symtab->primary)
 478     {
 479       fprintf_filtered (outfile, "\nBlockvector:\n\n");
 480       bv = BLOCKVECTOR (symtab);
 481       len = BLOCKVECTOR_NBLOCKS (bv);
 482       for (i = 0; i < len; i++)
 483         {
 484           b = BLOCKVECTOR_BLOCK (bv, i);
 485           depth = block_depth (b) * 2;
 486           print_spaces (depth, outfile);
 487           fprintf_filtered (outfile, "block #%03d, object at ", i);
 488           gdb_print_host_address (b, outfile);
 489           if (BLOCK_SUPERBLOCK (b))
 490             {
 491               fprintf_filtered (outfile, " under ");
 492               gdb_print_host_address (BLOCK_SUPERBLOCK (b), outfile);
 493             }
 494           /* drow/2002-07-10: We could save the total symbols count
 495              even if we're using a hashtable, but nothing else but this message
 496              wants it.  */
 497           fprintf_filtered (outfile, ", %d syms/buckets in ",
 498                             dict_size (BLOCK_DICT (b)));
 499           deprecated_print_address_numeric (BLOCK_START (b), 1, outfile);
 500           fprintf_filtered (outfile, "..");
 501           deprecated_print_address_numeric (BLOCK_END (b), 1, outfile);
 502           if (BLOCK_FUNCTION (b))
 503             {
 504               fprintf_filtered (outfile, ", function %s", DEPRECATED_SYMBOL_NAME (BLOCK_FUNCTION (b)));
 505               if (SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)) != NULL)
 506                 {
 507                   fprintf_filtered (outfile, ", %s",
 508                                 SYMBOL_DEMANGLED_NAME (BLOCK_FUNCTION (b)));
 509                 }
 510             }
 511           fprintf_filtered (outfile, "\n");
 512           /* Now print each symbol in this block (in no particular order, if
 513              we're using a hashtable).  */
 514           ALL_BLOCK_SYMBOLS (b, iter, sym)
 515             {
 516               struct print_symbol_args s;
 517               s.symbol = sym;
 518               s.depth = depth + 1;
 519               s.outfile = outfile;
 520               catch_errors (print_symbol, &s, "Error printing symbol:\n",
 521                             RETURN_MASK_ALL);
 522             }
 523         }
 524       fprintf_filtered (outfile, "\n");
 525     }
 526   else
 527     {
 528       fprintf_filtered (outfile, "\nBlockvector same as previous symtab\n\n");
 529     }
 530 }
 531
 532 static void
 533 dump_symtab (struct objfile *objfile, struct symtab *symtab,
 534              struct ui_file *outfile)
 535 {
 536   enum language saved_lang;
 537
 538   /* Set the current language to the language of the symtab we're dumping
 539      because certain routines used during dump_symtab() use the current
 540      language to print an image of the symbol.  We'll restore it later.  */
 541   saved_lang = set_language (symtab->language);
 542
 543   dump_symtab_1 (objfile, symtab, outfile);
 544
 545   set_language (saved_lang);
 546 }
 547
 548 void
 549 maintenance_print_symbols (char *args, int from_tty)
 550 {
 551   char **argv;
 552   struct ui_file *outfile;
 553   struct cleanup *cleanups;
 554   char *symname = NULL;
 555   char *filename = DEV_TTY;
 556   struct objfile *objfile;
 557   struct symtab *s;
 558
 559   dont_repeat ();
 560
 561   if (args == NULL)
 562     {
 563       error (_("\
 564 Arguments missing: an output file name and an optional symbol file name"));
 565     }
 566   else if ((argv = buildargv (args)) == NULL)
 567     {
 568       nomem (0);
 569     }
 570   cleanups = make_cleanup_freeargv (argv);
 571
 572   if (argv[0] != NULL)
 573     {
 574       filename = argv[0];
 575       /* If a second arg is supplied, it is a source file name to match on */
 576       if (argv[1] != NULL)
 577         {
 578           symname = argv[1];
 579         }
 580     }
 581
 582   filename = tilde_expand (filename);
 583   make_cleanup (xfree, filename);
 584
 585   outfile = gdb_fopen (filename, FOPEN_WT);
 586   if (outfile == 0)
 587     perror_with_name (filename);
 588   make_cleanup_ui_file_delete (outfile);
 589
 590   immediate_quit++;
 591   ALL_SYMTABS (objfile, s)
 592     if (symname == NULL || strcmp (symname, s->filename) == 0)
 593     dump_symtab (objfile, s, outfile);
 594   immediate_quit--;
 595   do_cleanups (cleanups);
 596 }
 597
 598 /* Print symbol ARGS->SYMBOL on ARGS->OUTFILE.  ARGS->DEPTH says how
 599    far to indent.  ARGS is really a struct print_symbol_args *, but is
 600    declared as char * to get it past catch_errors.  Returns 0 for error,
 601    1 for success.  */
 602
 603 static int
 604 print_symbol (void *args)
 605 {
 606   struct symbol *symbol = ((struct print_symbol_args *) args)->symbol;
 607   int depth = ((struct print_symbol_args *) args)->depth;
 608   struct ui_file *outfile = ((struct print_symbol_args *) args)->outfile;
 609
 610   print_spaces (depth, outfile);
 611   if (SYMBOL_DOMAIN (symbol) == LABEL_DOMAIN)
 612     {
 613       fprintf_filtered (outfile, "label %s at ", SYMBOL_PRINT_NAME (symbol));
 614       deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
 615       if (SYMBOL_BFD_SECTION (symbol))
 616         fprintf_filtered (outfile, " section %s\n",
 617                        bfd_section_name (SYMBOL_BFD_SECTION (symbol)->owner,
 618                                          SYMBOL_BFD_SECTION (symbol)));
 619       else
 620         fprintf_filtered (outfile, "\n");
 621       return 1;
 622     }
 623   if (SYMBOL_DOMAIN (symbol) == STRUCT_DOMAIN)
 624     {
 625       if (TYPE_TAG_NAME (SYMBOL_TYPE (symbol)))
 626         {
 627           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 628         }
 629       else
 630         {
 631           fprintf_filtered (outfile, "%s %s = ",
 632                          (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_ENUM
 633                           ? "enum"
 634                      : (TYPE_CODE (SYMBOL_TYPE (symbol)) == TYPE_CODE_STRUCT
 635                         ? "struct" : "union")),
 636                             DEPRECATED_SYMBOL_NAME (symbol));
 637           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), "", outfile, 1, depth);
 638         }
 639       fprintf_filtered (outfile, ";\n");
 640     }
 641   else
 642     {
 643       if (SYMBOL_CLASS (symbol) == LOC_TYPEDEF)
 644         fprintf_filtered (outfile, "typedef ");
 645       if (SYMBOL_TYPE (symbol))
 646         {
 647           /* Print details of types, except for enums where it's clutter.  */
 648           LA_PRINT_TYPE (SYMBOL_TYPE (symbol), SYMBOL_PRINT_NAME (symbol),
 649                          outfile,
 650                          TYPE_CODE (SYMBOL_TYPE (symbol)) != TYPE_CODE_ENUM,
 651                          depth);
 652           fprintf_filtered (outfile, "; ");
 653         }
 654       else
 655         fprintf_filtered (outfile, "%s ", SYMBOL_PRINT_NAME (symbol));
 656
 657       switch (SYMBOL_CLASS (symbol))
 658         {
 659         case LOC_CONST:
 660           fprintf_filtered (outfile, "const %ld (0x%lx)",
 661                             SYMBOL_VALUE (symbol),
 662                             SYMBOL_VALUE (symbol));
 663           break;
 664
 665         case LOC_CONST_BYTES:
 666           {
 667             unsigned i;
 668             struct type *type = check_typedef (SYMBOL_TYPE (symbol));
 669             fprintf_filtered (outfile, "const %u hex bytes:",
 670                               TYPE_LENGTH (type));
 671             for (i = 0; i < TYPE_LENGTH (type); i++)
 672               fprintf_filtered (outfile, " %02x",
 673                                 (unsigned) SYMBOL_VALUE_BYTES (symbol)[i]);
 674           }
 675           break;
 676
 677         case LOC_STATIC:
 678           fprintf_filtered (outfile, "static at ");
 679           deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
 680           if (SYMBOL_BFD_SECTION (symbol))
 681             fprintf_filtered (outfile, " section %s",
 682                               bfd_section_name
 683                               (SYMBOL_BFD_SECTION (symbol)->owner,
 684                                SYMBOL_BFD_SECTION (symbol)));
 685           break;
 686
 687         case LOC_INDIRECT:
 688           fprintf_filtered (outfile, "extern global at *(");
 689           deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
 690           fprintf_filtered (outfile, "),");
 691           break;
 692
 693         case LOC_REGISTER:
 694           fprintf_filtered (outfile, "register %ld", SYMBOL_VALUE (symbol));
 695           break;
 696
 697         case LOC_ARG:
 698           fprintf_filtered (outfile, "arg at offset 0x%lx",
 699                             SYMBOL_VALUE (symbol));
 700           break;
 701
 702         case LOC_LOCAL_ARG:
 703           fprintf_filtered (outfile, "arg at offset 0x%lx from fp",
 704                             SYMBOL_VALUE (symbol));
 705           break;
 706
 707         case LOC_REF_ARG:
 708           fprintf_filtered (outfile, "reference arg at 0x%lx", SYMBOL_VALUE (symbol));
 709           break;
 710
 711         case LOC_REGPARM:
 712           fprintf_filtered (outfile, "parameter register %ld", SYMBOL_VALUE (symbol));
 713           break;
 714
 715         case LOC_REGPARM_ADDR:
 716           fprintf_filtered (outfile, "address parameter register %ld", SYMBOL_VALUE (symbol));
 717           break;
 718
 719         case LOC_LOCAL:
 720           fprintf_filtered (outfile, "local at offset 0x%lx",
 721                             SYMBOL_VALUE (symbol));
 722           break;
 723
 724         case LOC_BASEREG:
 725           fprintf_filtered (outfile, "local at 0x%lx from register %d",
 726                             SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
 727           break;
 728
 729         case LOC_BASEREG_ARG:
 730           fprintf_filtered (outfile, "arg at 0x%lx from register %d",
 731                             SYMBOL_VALUE (symbol), SYMBOL_BASEREG (symbol));
 732           break;
 733
 734         case LOC_TYPEDEF:
 735           break;
 736
 737         case LOC_LABEL:
 738           fprintf_filtered (outfile, "label at ");
 739           deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (symbol), 1, outfile);
 740           if (SYMBOL_BFD_SECTION (symbol))
 741             fprintf_filtered (outfile, " section %s",
 742                               bfd_section_name
 743                               (SYMBOL_BFD_SECTION (symbol)->owner,
 744                                SYMBOL_BFD_SECTION (symbol)));
 745           break;
 746
 747         case LOC_BLOCK:
 748           fprintf_filtered (outfile, "block object ");
 749           gdb_print_host_address (SYMBOL_BLOCK_VALUE (symbol), outfile);
 750           fprintf_filtered (outfile, ", ");
 751           deprecated_print_address_numeric (BLOCK_START (SYMBOL_BLOCK_VALUE (symbol)),
 752                                  1,
 753                                  outfile);
 754           fprintf_filtered (outfile, "..");
 755           deprecated_print_address_numeric (BLOCK_END (SYMBOL_BLOCK_VALUE (symbol)),
 756                                  1,
 757                                  outfile);
 758           if (SYMBOL_BFD_SECTION (symbol))
 759             fprintf_filtered (outfile, " section %s",
 760                               bfd_section_name
 761                               (SYMBOL_BFD_SECTION (symbol)->owner,
 762                                SYMBOL_BFD_SECTION (symbol)));
 763           break;
 764
 765         case LOC_COMPUTED:
 766         case LOC_COMPUTED_ARG:
 767           fprintf_filtered (outfile, "computed at runtime");
 768           break;
 769
 770         case LOC_UNRESOLVED:
 771           fprintf_filtered (outfile, "unresolved");
 772           break;
 773
 774         case LOC_OPTIMIZED_OUT:
 775           fprintf_filtered (outfile, "optimized out");
 776           break;
 777
 778         default:
 779           fprintf_filtered (outfile, "botched symbol class %x",
 780                             SYMBOL_CLASS (symbol));
 781           break;
 782         }
 783     }
 784   fprintf_filtered (outfile, "\n");
 785   return 1;
 786 }
 787
 788 void
 789 maintenance_print_psymbols (char *args, int from_tty)
 790 {
 791   char **argv;
 792   struct ui_file *outfile;
 793   struct cleanup *cleanups;
 794   char *symname = NULL;
 795   char *filename = DEV_TTY;
 796   struct objfile *objfile;
 797   struct partial_symtab *ps;
 798
 799   dont_repeat ();
 800
 801   if (args == NULL)
 802     {
 803       error (_("print-psymbols takes an output file name and optional symbol file name"));
 804     }
 805   else if ((argv = buildargv (args)) == NULL)
 806     {
 807       nomem (0);
 808     }
 809   cleanups = make_cleanup_freeargv (argv);
 810
 811   if (argv[0] != NULL)
 812     {
 813       filename = argv[0];
 814       /* If a second arg is supplied, it is a source file name to match on */
 815       if (argv[1] != NULL)
 816         {
 817           symname = argv[1];
 818         }
 819     }
 820
 821   filename = tilde_expand (filename);
 822   make_cleanup (xfree, filename);
 823
 824   outfile = gdb_fopen (filename, FOPEN_WT);
 825   if (outfile == 0)
 826     perror_with_name (filename);
 827   make_cleanup_ui_file_delete (outfile);
 828
 829   immediate_quit++;
 830   ALL_PSYMTABS (objfile, ps)
 831     if (symname == NULL || strcmp (symname, ps->filename) == 0)
 832     dump_psymtab (objfile, ps, outfile);
 833   immediate_quit--;
 834   do_cleanups (cleanups);
 835 }
 836
 837 static void
 838 print_partial_symbols (struct partial_symbol **p, int count, char *what,
 839                        struct ui_file *outfile)
 840 {
 841   fprintf_filtered (outfile, "  %s partial symbols:\n", what);
 842   while (count-- > 0)
 843     {
 844       fprintf_filtered (outfile, "    `%s'", DEPRECATED_SYMBOL_NAME (*p));
 845       if (SYMBOL_DEMANGLED_NAME (*p) != NULL)
 846         {
 847           fprintf_filtered (outfile, "  `%s'", SYMBOL_DEMANGLED_NAME (*p));
 848         }
 849       fputs_filtered (", ", outfile);
 850       switch (SYMBOL_DOMAIN (*p))
 851         {
 852         case UNDEF_DOMAIN:
 853           fputs_filtered ("undefined domain, ", outfile);
 854           break;
 855         case VAR_DOMAIN:
 856           /* This is the usual thing -- don't print it */
 857           break;
 858         case STRUCT_DOMAIN:
 859           fputs_filtered ("struct domain, ", outfile);
 860           break;
 861         case LABEL_DOMAIN:
 862           fputs_filtered ("label domain, ", outfile);
 863           break;
 864         default:
 865           fputs_filtered ("<invalid domain>, ", outfile);
 866           break;
 867         }
 868       switch (SYMBOL_CLASS (*p))
 869         {
 870         case LOC_UNDEF:
 871           fputs_filtered ("undefined", outfile);
 872           break;
 873         case LOC_CONST:
 874           fputs_filtered ("constant int", outfile);
 875           break;
 876         case LOC_STATIC:
 877           fputs_filtered ("static", outfile);
 878           break;
 879         case LOC_INDIRECT:
 880           fputs_filtered ("extern global", outfile);
 881           break;
 882         case LOC_REGISTER:
 883           fputs_filtered ("register", outfile);
 884           break;
 885         case LOC_ARG:
 886           fputs_filtered ("pass by value", outfile);
 887           break;
 888         case LOC_REF_ARG:
 889           fputs_filtered ("pass by reference", outfile);
 890           break;
 891         case LOC_REGPARM:
 892           fputs_filtered ("register parameter", outfile);
 893           break;
 894         case LOC_REGPARM_ADDR:
 895           fputs_filtered ("register address parameter", outfile);
 896           break;
 897         case LOC_LOCAL:
 898           fputs_filtered ("stack parameter", outfile);
 899           break;
 900         case LOC_TYPEDEF:
 901           fputs_filtered ("type", outfile);
 902           break;
 903         case LOC_LABEL:
 904           fputs_filtered ("label", outfile);
 905           break;
 906         case LOC_BLOCK:
 907           fputs_filtered ("function", outfile);
 908           break;
 909         case LOC_CONST_BYTES:
 910           fputs_filtered ("constant bytes", outfile);
 911           break;
 912         case LOC_LOCAL_ARG:
 913           fputs_filtered ("shuffled arg", outfile);
 914           break;
 915         case LOC_UNRESOLVED:
 916           fputs_filtered ("unresolved", outfile);
 917           break;
 918         case LOC_OPTIMIZED_OUT:
 919           fputs_filtered ("optimized out", outfile);
 920           break;
 921         case LOC_COMPUTED:
 922         case LOC_COMPUTED_ARG:
 923           fputs_filtered ("computed at runtime", outfile);
 924           break;
 925         default:
 926           fputs_filtered ("<invalid location>", outfile);
 927           break;
 928         }
 929       fputs_filtered (", ", outfile);
 930       deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (*p), 1, outfile);
 931       fprintf_filtered (outfile, "\n");
 932       p++;
 933     }
 934 }
 935
 936 void
 937 maintenance_print_msymbols (char *args, int from_tty)
 938 {
 939   char **argv;
 940   struct ui_file *outfile;
 941   struct cleanup *cleanups;
 942   char *filename = DEV_TTY;
 943   char *symname = NULL;
 944   struct objfile *objfile;
 945
 946   struct stat sym_st, obj_st;
 947
 948   dont_repeat ();
 949
 950   if (args == NULL)
 951     {
 952       error (_("print-msymbols takes an output file name and optional symbol file name"));
 953     }
 954   else if ((argv = buildargv (args)) == NULL)
 955     {
 956       nomem (0);
 957     }
 958   cleanups = make_cleanup_freeargv (argv);
 959
 960   if (argv[0] != NULL)
 961     {
 962       filename = argv[0];
 963       /* If a second arg is supplied, it is a source file name to match on */
 964       if (argv[1] != NULL)
 965         {
 966           symname = xfullpath (argv[1]);
 967           make_cleanup (xfree, symname);
 968           if (symname && stat (symname, &sym_st))
 969             perror_with_name (symname);
 970         }
 971     }
 972
 973   filename = tilde_expand (filename);
 974   make_cleanup (xfree, filename);
 975
 976   outfile = gdb_fopen (filename, FOPEN_WT);
 977   if (outfile == 0)
 978     perror_with_name (filename);
 979   make_cleanup_ui_file_delete (outfile);
 980
 981   immediate_quit++;
 982   ALL_OBJFILES (objfile)
 983     if (symname == NULL
 984         || (!stat (objfile->name, &obj_st) && sym_st.st_ino == obj_st.st_ino))
 985       dump_msymbols (objfile, outfile);
 986   immediate_quit--;
 987   fprintf_filtered (outfile, "\n\n");
 988   do_cleanups (cleanups);
 989 }
 990
 991 void
 992 maintenance_print_objfiles (char *ignore, int from_tty)
 993 {
 994   struct objfile *objfile;
 995
 996   dont_repeat ();
 997
 998   immediate_quit++;
 999   ALL_OBJFILES (objfile)
1000     dump_objfile (objfile);
1001   immediate_quit--;
1002 }
1003
1004
1005 /* List all the symbol tables whose names match REGEXP (optional).  */
1006 void
1007 maintenance_info_symtabs (char *regexp, int from_tty)
1008 {
1009   struct objfile *objfile;
1010
1011   if (regexp)
1012     re_comp (regexp);
1013
1014   ALL_OBJFILES (objfile)
1015     {
1016       struct symtab *symtab;
1017
1018       /* We don't want to print anything for this objfile until we
1019          actually find a symtab whose name matches.  */
1020       int printed_objfile_start = 0;
1021
1022       ALL_OBJFILE_SYMTABS (objfile, symtab)
1023         if (! regexp
1024             || re_exec (symtab->filename))
1025           {
1026             if (! printed_objfile_start)
1027               {
1028                 printf_filtered ("{ objfile %s ", objfile->name);
1029                 wrap_here ("  ");
1030                 printf_filtered ("((struct objfile *) %p)\n", objfile);
1031                 printed_objfile_start = 1;
1032               }
1033
1034             printf_filtered ("  { symtab %s ", symtab->filename);
1035             wrap_here ("    ");
1036             printf_filtered ("((struct symtab *) %p)\n", symtab);
1037             printf_filtered ("    dirname %s\n",
1038                              symtab->dirname ? symtab->dirname : "(null)");
1039             printf_filtered ("    fullname %s\n",
1040                              symtab->fullname ? symtab->fullname : "(null)");
1041             printf_filtered ("    blockvector ((struct blockvector *) %p)%s\n",
1042                              symtab->blockvector,
1043                              symtab->primary ? " (primary)" : "");
1044             printf_filtered ("    debugformat %s\n", symtab->debugformat);
1045             printf_filtered ("  }\n");
1046           }
1047
1048       if (printed_objfile_start)
1049         printf_filtered ("}\n");
1050     }
1051 }
1052
1053
1054 /* List all the partial symbol tables whose names match REGEXP (optional).  */
1055 void
1056 maintenance_info_psymtabs (char *regexp, int from_tty)
1057 {
1058   struct objfile *objfile;
1059
1060   if (regexp)
1061     re_comp (regexp);
1062
1063   ALL_OBJFILES (objfile)
1064     {
1065       struct partial_symtab *psymtab;
1066
1067       /* We don't want to print anything for this objfile until we
1068          actually find a symtab whose name matches.  */
1069       int printed_objfile_start = 0;
1070
1071       ALL_OBJFILE_PSYMTABS (objfile, psymtab)
1072         if (! regexp
1073             || re_exec (psymtab->filename))
1074           {
1075             if (! printed_objfile_start)
1076               {
1077                 printf_filtered ("{ objfile %s ", objfile->name);
1078                 wrap_here ("  ");
1079                 printf_filtered ("((struct objfile *) %p)\n", objfile);
1080                 printed_objfile_start = 1;
1081               }
1082
1083             printf_filtered ("  { psymtab %s ", psymtab->filename);
1084             wrap_here ("    ");
1085             printf_filtered ("((struct partial_symtab *) %p)\n", psymtab);
1086             printf_filtered ("    readin %s\n",
1087                              psymtab->readin ? "yes" : "no");
1088             printf_filtered ("    fullname %s\n",
1089                              psymtab->fullname ? psymtab->fullname : "(null)");
1090             printf_filtered ("    text addresses ");
1091             deprecated_print_address_numeric (psymtab->textlow, 1, gdb_stdout);
1092             printf_filtered (" -- ");
1093             deprecated_print_address_numeric (psymtab->texthigh, 1, gdb_stdout);
1094             printf_filtered ("\n");
1095             printf_filtered ("    globals ");
1096             if (psymtab->n_global_syms)
1097               {
1098                 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1099                                  (psymtab->objfile->global_psymbols.list
1100                                   + psymtab->globals_offset),
1101                                  psymtab->n_global_syms);
1102               }
1103             else
1104               printf_filtered ("(none)\n");
1105             printf_filtered ("    statics ");
1106             if (psymtab->n_static_syms)
1107               {
1108                 printf_filtered ("(* (struct partial_symbol **) %p @ %d)\n",
1109                                  (psymtab->objfile->static_psymbols.list
1110                                   + psymtab->statics_offset),
1111                                  psymtab->n_static_syms);
1112               }
1113             else
1114               printf_filtered ("(none)\n");
1115             printf_filtered ("    dependencies ");
1116             if (psymtab->number_of_dependencies)
1117               {
1118                 int i;
1119
1120                 printf_filtered ("{\n");
1121                 for (i = 0; i < psymtab->number_of_dependencies; i++)
1122                   {
1123                     struct partial_symtab *dep = psymtab->dependencies[i];
1124
1125                     /* Note the string concatenation there --- no comma.  */
1126                     printf_filtered ("      psymtab %s "
1127                                      "((struct partial_symtab *) %p)\n",
1128                                      dep->filename, dep);
1129                   }
1130                 printf_filtered ("    }\n");
1131               }
1132             else
1133               printf_filtered ("(none)\n");
1134             printf_filtered ("  }\n");
1135           }
1136
1137       if (printed_objfile_start)
1138         printf_filtered ("}\n");
1139     }
1140 }
1141
1142
1143 /* Check consistency of psymtabs and symtabs.  */
1144
1145 void
1146 maintenance_check_symtabs (char *ignore, int from_tty)
1147 {
1148   struct symbol *sym;
1149   struct partial_symbol **psym;
1150   struct symtab *s = NULL;
1151   struct partial_symtab *ps;
1152   struct blockvector *bv;
1153   struct objfile *objfile;
1154   struct block *b;
1155   int length;
1156
1157   ALL_PSYMTABS (objfile, ps)
1158   {
1159     s = PSYMTAB_TO_SYMTAB (ps);
1160     if (s == NULL)
1161       continue;
1162     bv = BLOCKVECTOR (s);
1163     b = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
1164     psym = ps->objfile->static_psymbols.list + ps->statics_offset;
1165     length = ps->n_static_syms;
1166     while (length--)
1167       {
1168         sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1169                                    NULL, SYMBOL_DOMAIN (*psym));
1170         if (!sym)
1171           {
1172             printf_filtered ("Static symbol `");
1173             puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1174             printf_filtered ("' only found in ");
1175             puts_filtered (ps->filename);
1176             printf_filtered (" psymtab\n");
1177           }
1178         psym++;
1179       }
1180     b = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
1181     psym = ps->objfile->global_psymbols.list + ps->globals_offset;
1182     length = ps->n_global_syms;
1183     while (length--)
1184       {
1185         sym = lookup_block_symbol (b, DEPRECATED_SYMBOL_NAME (*psym),
1186                                    NULL, SYMBOL_DOMAIN (*psym));
1187         if (!sym)
1188           {
1189             printf_filtered ("Global symbol `");
1190             puts_filtered (DEPRECATED_SYMBOL_NAME (*psym));
1191             printf_filtered ("' only found in ");
1192             puts_filtered (ps->filename);
1193             printf_filtered (" psymtab\n");
1194           }
1195         psym++;
1196       }
1197     if (ps->texthigh < ps->textlow)
1198       {
1199         printf_filtered ("Psymtab ");
1200         puts_filtered (ps->filename);
1201         printf_filtered (" covers bad range ");
1202         deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
1203         printf_filtered (" - ");
1204         deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
1205         printf_filtered ("\n");
1206         continue;
1207       }
1208     if (ps->texthigh == 0)
1209       continue;
1210     if (ps->textlow < BLOCK_START (b) || ps->texthigh > BLOCK_END (b))
1211       {
1212         printf_filtered ("Psymtab ");
1213         puts_filtered (ps->filename);
1214         printf_filtered (" covers ");
1215         deprecated_print_address_numeric (ps->textlow, 1, gdb_stdout);
1216         printf_filtered (" - ");
1217         deprecated_print_address_numeric (ps->texthigh, 1, gdb_stdout);
1218         printf_filtered (" but symtab covers only ");
1219         deprecated_print_address_numeric (BLOCK_START (b), 1, gdb_stdout);
1220         printf_filtered (" - ");
1221         deprecated_print_address_numeric (BLOCK_END (b), 1, gdb_stdout);
1222         printf_filtered ("\n");
1223       }
1224   }
1225 }
1226 \f
1227
1228 /* Return the nexting depth of a block within other blocks in its symtab.  */
1229
1230 static int
1231 block_depth (struct block *block)
1232 {
1233   int i = 0;
1234   while ((block = BLOCK_SUPERBLOCK (block)) != NULL)
1235     {
1236       i++;
1237     }
1238   return i;
1239 }
1240 \f
1241
1242 /* Increase the space allocated for LISTP, which is probably
1243    global_psymbols or static_psymbols. This space will eventually
1244    be freed in free_objfile().  */
1245
1246 void
1247 extend_psymbol_list (struct psymbol_allocation_list *listp,
1248                      struct objfile *objfile)
1249 {
1250   int new_size;
1251   if (listp->size == 0)
1252     {
1253       new_size = 255;
1254       listp->list = (struct partial_symbol **)
1255         xmalloc (new_size * sizeof (struct partial_symbol *));
1256     }
1257   else
1258     {
1259       new_size = listp->size * 2;
1260       listp->list = (struct partial_symbol **)
1261         xrealloc ((char *) listp->list,
1262                   new_size * sizeof (struct partial_symbol *));
1263     }
1264   /* Next assumes we only went one over.  Should be good if
1265      program works correctly */
1266   listp->next = listp->list + listp->size;
1267   listp->size = new_size;
1268 }
1269
1270
1271 /* Do early runtime initializations. */
1272 void
1273 _initialize_symmisc (void)
1274 {
1275   std_in = stdin;
1276   std_out = stdout;
1277   std_err = stderr;
1278 }