gdb/symmisc.c

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