gdb/symmisc.c

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