gdb/dbxread.c

   1 /* Read dbx symbol tables and convert to internal format, for GDB.
   2    Copyright 1986, 1987, 1988, 1989, 1990, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 /* This module provides three functions: dbx_symfile_init,
  21    which initializes to read a symbol file; dbx_new_init, which
  22    discards existing cached information when all symbols are being
  23    discarded; and dbx_symfile_read, which reads a symbol table
  24    from a file.
  25
  26    dbx_symfile_read only does the minimum work necessary for letting the
  27    user "name" things symbolically; it does not read the entire symtab.
  28    Instead, it reads the external and static symbols and puts them in partial
  29    symbol tables.  When more extensive information is requested of a
  30    file, the corresponding partial symbol table is mutated into a full
  31    fledged symbol table by going back and reading the symbols
  32    for real.  dbx_psymtab_to_symtab() is the function that does this */
  33
  34 #include "defs.h"
  35 #include <string.h>
  36
  37 #if defined(USG) || defined(__CYGNUSCLIB__)
  38 #include <sys/types.h>
  39 #include <fcntl.h>
  40 #define L_SET 0
  41 #define L_INCR 1
  42 #endif
  43
  44 #ifdef hp9000s800
  45 /* We don't want to use HP-UX's nlists. */
  46 #define _NLIST_INCLUDED
  47 #endif
  48
  49 #include <obstack.h>
  50 #include <sys/param.h>
  51 #ifndef NO_SYS_FILE
  52 #include <sys/file.h>
  53 #endif
  54 #include <sys/stat.h>
  55 #include <ctype.h>
  56 #include "symtab.h"
  57 #include "breakpoint.h"
  58 #include "command.h"
  59 #include "target.h"
  60 #include "gdbcore.h"            /* for bfd stuff */
  61 #include "libbfd.h"             /* FIXME Secret internal BFD stuff (bfd_read) */
  62 #ifdef hp9000s800
  63 #include "libhppa.h"
  64 #include "syms.h"
  65 #else
  66 #include "libaout.h"            /* FIXME Secret internal BFD stuff for a.out */
  67 #endif
  68 #include "symfile.h"
  69 #include "objfiles.h"
  70 #include "buildsym.h"
  71 #include "gdb-stabs.h"
  72
  73 #include "aout/aout64.h"
  74 #include "aout/stab_gnu.h"      /* We always use GNU stabs, not native, now */
  75
  76 /* Each partial symbol table entry contains a pointer to private data for the
  77    read_symtab() function to use when expanding a partial symbol table entry
  78    to a full symbol table entry.
  79
  80    For dbxread this structure contains the offset within the file symbol table
  81    of first local symbol for this file, and length (in bytes) of the section
  82    of the symbol table devoted to this file's symbols (actually, the section
  83    bracketed may contain more than just this file's symbols).  It also contains
  84    further information needed to locate the symbols if they are in an ELF file.
  85
  86    If ldsymlen is 0, the only reason for this thing's existence is the
  87    dependency list.  Nothing else will happen when it is read in.  */
  88
  89 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
  90 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
  91 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
  92 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
  93 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
  94 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
  95 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
  96
  97 struct symloc {
  98   int ldsymoff;
  99   int ldsymlen;
 100   int symbol_size;
 101   int symbol_offset;
 102   int string_offset;
 103   int file_string_offset;
 104 };
 105
 106 /* Macro to determine which symbols to ignore when reading the first symbol
 107    of a file.  Some machines override this definition. */
 108 #ifndef IGNORE_SYMBOL
 109 /* This code is used on Ultrix systems.  Ignore it */
 110 #define IGNORE_SYMBOL(type)  (type == (int)N_NSYMS)
 111 #endif
 112
 113 /* Macro for name of symbol to indicate a file compiled with gcc. */
 114 #ifndef GCC_COMPILED_FLAG_SYMBOL
 115 #define GCC_COMPILED_FLAG_SYMBOL "gcc_compiled."
 116 #endif
 117
 118 /* Macro for name of symbol to indicate a file compiled with gcc2. */
 119 #ifndef GCC2_COMPILED_FLAG_SYMBOL
 120 #define GCC2_COMPILED_FLAG_SYMBOL "gcc2_compiled."
 121 #endif
 122
 123 /* Define this as 1 if a pcc declaration of a char or short argument
 124    gives the correct address.  Otherwise assume pcc gives the
 125    address of the corresponding int, which is not the same on a
 126    big-endian machine.  */
 127
 128 #ifndef BELIEVE_PCC_PROMOTION
 129 #define BELIEVE_PCC_PROMOTION 0
 130 #endif
 131
 132 /* Nonzero means give verbose info on gdb action.  From main.c.  */
 133 extern int info_verbose;
 134
 135 /* The BFD for this file -- implicit parameter to next_symbol_text.  */
 136
 137 static bfd *symfile_bfd;
 138
 139 /* The size of each symbol in the symbol file (in external form).
 140    This is set by dbx_symfile_read when building psymtabs, and by
 141    dbx_psymtab_to_symtab when building symtabs.  */
 142
 143 static unsigned symbol_size;
 144
 145 /* This is the offset of the symbol table in the executable file */
 146 static unsigned symbol_table_offset;
 147
 148 /* This is the offset of the string table in the executable file */
 149 static unsigned string_table_offset;
 150
 151 /* For elf+stab executables, the n_strx field is not a simple index
 152    into the string table.  Instead, each .o file has a base offset
 153    in the string table, and the associated symbols contain offsets
 154    from this base.  The following two variables contain the base
 155    offset for the current and next .o files. */
 156 static unsigned int file_string_table_offset;
 157 static unsigned int next_file_string_table_offset;
 158
 159 /* Complaints about the symbols we have encountered.  */
 160
 161 struct complaint lbrac_complaint =
 162   {"bad block start address patched", 0, 0};
 163
 164 struct complaint string_table_offset_complaint =
 165   {"bad string table offset in symbol %d", 0, 0};
 166
 167 struct complaint unknown_symtype_complaint =
 168   {"unknown symbol type %s", 0, 0};
 169
 170 struct complaint lbrac_rbrac_complaint =
 171   {"block start larger than block end", 0, 0};
 172
 173 struct complaint lbrac_unmatched_complaint =
 174   {"unmatched N_LBRAC before symtab pos %d", 0, 0};
 175
 176 struct complaint lbrac_mismatch_complaint =
 177   {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
 178
 179 struct complaint repeated_header_complaint =
 180   {"\"repeated\" header file not previously seen, at symtab pos %d", 0, 0};
 181
 182 struct complaint repeated_header_name_complaint =
 183   {"\"repeated\" header file not previously seen, named %s", 0, 0};
 184 \f
 185 /* During initial symbol readin, we need to have a structure to keep
 186    track of which psymtabs have which bincls in them.  This structure
 187    is used during readin to setup the list of dependencies within each
 188    partial symbol table. */
 189
 190 struct header_file_location
 191 {
 192   char *name;                   /* Name of header file */
 193   int instance;                 /* See above */
 194   struct partial_symtab *pst;   /* Partial symtab that has the
 195                                    BINCL/EINCL defs for this file */
 196 };
 197
 198 /* The actual list and controling variables */
 199 static struct header_file_location *bincl_list, *next_bincl;
 200 static int bincls_allocated;
 201
 202 /* Local function prototypes */
 203
 204 static void
 205 free_header_files PARAMS ((void));
 206
 207 static void
 208 init_header_files PARAMS ((void));
 209
 210 static struct pending *
 211 copy_pending PARAMS ((struct pending *, int, struct pending *));
 212
 213 static struct symtab *
 214 read_ofile_symtab PARAMS ((struct objfile *, int, int, CORE_ADDR, int,
 215                            struct section_offsets *));
 216
 217 static void
 218 dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
 219
 220 static void
 221 dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
 222
 223 static void
 224 read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
 225                          CORE_ADDR, int));
 226
 227 static void
 228 free_bincl_list PARAMS ((struct objfile *));
 229
 230 static struct partial_symtab *
 231 find_corresponding_bincl_psymtab PARAMS ((char *, int));
 232
 233 static void
 234 add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
 235
 236 static void
 237 init_bincl_list PARAMS ((int, struct objfile *));
 238
 239 static void
 240 init_psymbol_list PARAMS ((struct objfile *));
 241
 242 static char *
 243 dbx_next_symbol_text PARAMS ((void));
 244
 245 static void
 246 fill_symbuf PARAMS ((bfd *));
 247
 248 static void
 249 dbx_symfile_init PARAMS ((struct objfile *));
 250
 251 static void
 252 dbx_new_init PARAMS ((struct objfile *));
 253
 254 static void
 255 dbx_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
 256
 257 static void
 258 dbx_symfile_finish PARAMS ((struct objfile *));
 259
 260 static void
 261 record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
 262
 263 static void
 264 add_new_header_file PARAMS ((char *, int));
 265
 266 static void
 267 add_old_header_file PARAMS ((char *, int));
 268
 269 static void
 270 add_this_object_header_file PARAMS ((int));
 271
 272 /* Free up old header file tables */
 273
 274 static void
 275 free_header_files ()
 276 {
 277   register int i;
 278
 279   if (header_files != NULL)
 280     {
 281       for (i = 0; i < n_header_files; i++)
 282         {
 283           free (header_files[i].name);
 284         }
 285       free ((PTR)header_files);
 286       header_files = NULL;
 287       n_header_files = 0;
 288     }
 289   if (this_object_header_files)
 290     {
 291       free ((PTR)this_object_header_files);
 292       this_object_header_files = NULL;
 293     }
 294   n_allocated_header_files = 0;
 295   n_allocated_this_object_header_files = 0;
 296 }
 297
 298 /* Allocate new header file tables */
 299
 300 static void
 301 init_header_files ()
 302 {
 303   n_header_files = 0;
 304   n_allocated_header_files = 10;
 305   header_files = (struct header_file *)
 306     xmalloc (10 * sizeof (struct header_file));
 307
 308   n_allocated_this_object_header_files = 10;
 309   this_object_header_files = (int *) xmalloc (10 * sizeof (int));
 310 }
 311
 312 /* Add header file number I for this object file
 313    at the next successive FILENUM.  */
 314
 315 static void
 316 add_this_object_header_file (i)
 317      int i;
 318 {
 319   if (n_this_object_header_files == n_allocated_this_object_header_files)
 320     {
 321       n_allocated_this_object_header_files *= 2;
 322       this_object_header_files
 323         = (int *) xrealloc ((char *) this_object_header_files,
 324                             n_allocated_this_object_header_files * sizeof (int));
 325     }
 326
 327   this_object_header_files[n_this_object_header_files++] = i;
 328 }
 329
 330 /* Add to this file an "old" header file, one already seen in
 331    a previous object file.  NAME is the header file's name.
 332    INSTANCE is its instance code, to select among multiple
 333    symbol tables for the same header file.  */
 334
 335 static void
 336 add_old_header_file (name, instance)
 337      char *name;
 338      int instance;
 339 {
 340   register struct header_file *p = header_files;
 341   register int i;
 342
 343   for (i = 0; i < n_header_files; i++)
 344     if (!strcmp (p[i].name, name) && instance == p[i].instance)
 345       {
 346         add_this_object_header_file (i);
 347         return;
 348       }
 349   complain (&repeated_header_complaint, (char *)symnum);
 350   complain (&repeated_header_name_complaint, name);
 351 }
 352
 353 /* Add to this file a "new" header file: definitions for its types follow.
 354    NAME is the header file's name.
 355    Most often this happens only once for each distinct header file,
 356    but not necessarily.  If it happens more than once, INSTANCE has
 357    a different value each time, and references to the header file
 358    use INSTANCE values to select among them.
 359
 360    dbx output contains "begin" and "end" markers for each new header file,
 361    but at this level we just need to know which files there have been;
 362    so we record the file when its "begin" is seen and ignore the "end".  */
 363
 364 static void
 365 add_new_header_file (name, instance)
 366      char *name;
 367      int instance;
 368 {
 369   register int i;
 370
 371   /* Make sure there is room for one more header file.  */
 372
 373   if (n_header_files == n_allocated_header_files)
 374     {
 375       n_allocated_header_files *= 2;
 376       header_files = (struct header_file *)
 377         xrealloc ((char *) header_files,
 378                   (n_allocated_header_files * sizeof (struct header_file)));
 379     }
 380
 381   /* Create an entry for this header file.  */
 382
 383   i = n_header_files++;
 384   header_files[i].name = savestring (name, strlen(name));
 385   header_files[i].instance = instance;
 386   header_files[i].length = 10;
 387   header_files[i].vector
 388     = (struct type **) xmalloc (10 * sizeof (struct type *));
 389   memset (header_files[i].vector, 0, 10 * sizeof (struct type *));
 390
 391   add_this_object_header_file (i);
 392 }
 393
 394 #if 0
 395 static struct type **
 396 explicit_lookup_type (real_filenum, index)
 397      int real_filenum, index;
 398 {
 399   register struct header_file *f = &header_files[real_filenum];
 400
 401   if (index >= f->length)
 402     {
 403       f->length *= 2;
 404       f->vector = (struct type **)
 405         xrealloc (f->vector, f->length * sizeof (struct type *));
 406       bzero (&f->vector[f->length / 2],
 407              f->length * sizeof (struct type *) / 2);
 408     }
 409   return &f->vector[index];
 410 }
 411 #endif
 412 \f
 413 static void
 414 record_minimal_symbol (name, address, type, objfile)
 415      char *name;
 416      CORE_ADDR address;
 417      int type;
 418      struct objfile *objfile;
 419 {
 420   enum minimal_symbol_type ms_type;
 421
 422   switch (type &~ N_EXT) {
 423     case N_TEXT:  ms_type = mst_text; break;
 424     case N_DATA:  ms_type = mst_data; break;
 425     case N_BSS:   ms_type = mst_bss;  break;
 426     case N_ABS:   ms_type = mst_abs;  break;
 427 #ifdef N_SETV
 428     case N_SETV:  ms_type = mst_data; break;
 429 #endif
 430     default:      ms_type = mst_unknown; break;
 431   }
 432
 433   prim_record_minimal_symbol (obsavestring (name, strlen (name), &objfile -> symbol_obstack),
 434                              address, ms_type);
 435 }
 436 \f
 437 /* Scan and build partial symbols for a symbol file.
 438    We have been initialized by a call to dbx_symfile_init, which
 439    put all the relevant info into a "struct dbx_symfile_info",
 440    hung off the objfile structure.
 441
 442    SECTION_OFFSETS contains offsets relative to which the symbols in the
 443    various sections are (depending where the sections were actually loaded).
 444    MAINLINE is true if we are reading the main symbol
 445    table (as opposed to a shared lib or dynamically loaded file).  */
 446
 447 static void
 448 dbx_symfile_read (objfile, section_offsets, mainline)
 449      struct objfile *objfile;
 450      struct section_offsets *section_offsets;
 451      int mainline;      /* FIXME comments above */
 452 {
 453   bfd *sym_bfd;
 454   int val;
 455
 456   sym_bfd = objfile->obfd;
 457   val = bfd_seek (objfile->obfd, DBX_SYMTAB_OFFSET (objfile), L_SET);
 458   if (val < 0)
 459     perror_with_name (objfile->name);
 460
 461   /* If we are reinitializing, or if we have never loaded syms yet, init */
 462   if (mainline || objfile->global_psymbols.size == 0 || objfile->static_psymbols.size == 0)
 463     init_psymbol_list (objfile);
 464
 465 #ifdef hp9000s800
 466   symbol_size = obj_dbx_symbol_entry_size (sym_bfd);
 467 #else
 468   symbol_size = DBX_SYMBOL_SIZE (objfile);
 469 #endif
 470   symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
 471
 472   pending_blocks = 0;
 473   make_cleanup (really_free_pendings, 0);
 474
 475   init_minimal_symbol_collection ();
 476   make_cleanup (discard_minimal_symbols, 0);
 477
 478   /* Now that the symbol table data of the executable file are all in core,
 479      process them and define symbols accordingly.  */
 480
 481   read_dbx_symtab (section_offsets, objfile,
 482                    bfd_section_vma  (sym_bfd, DBX_TEXT_SECT (objfile)),
 483                    bfd_section_size (sym_bfd, DBX_TEXT_SECT (objfile)));
 484
 485   /* Install any minimal symbols that have been collected as the current
 486      minimal symbols for this objfile. */
 487
 488   install_minimal_symbols (objfile);
 489
 490   if (!have_partial_symbols ()) {
 491     wrap_here ("");
 492     printf_filtered ("(no debugging symbols found)...");
 493     wrap_here ("");
 494   }
 495 }
 496
 497 /* Initialize anything that needs initializing when a completely new
 498    symbol file is specified (not just adding some symbols from another
 499    file, e.g. a shared library).  */
 500
 501 static void
 502 dbx_new_init (ignore)
 503      struct objfile *ignore;
 504 {
 505   buildsym_new_init ();
 506   init_header_files ();
 507 }
 508
 509
 510 /* dbx_symfile_init ()
 511    is the dbx-specific initialization routine for reading symbols.
 512    It is passed a struct objfile which contains, among other things,
 513    the BFD for the file whose symbols are being read, and a slot for a pointer
 514    to "private data" which we fill with goodies.
 515
 516    We read the string table into malloc'd space and stash a pointer to it.
 517
 518    Since BFD doesn't know how to read debug symbols in a format-independent
 519    way (and may never do so...), we have to do it ourselves.  We will never
 520    be called unless this is an a.out (or very similar) file.
 521    FIXME, there should be a cleaner peephole into the BFD environment here.  */
 522
 523 static void
 524 dbx_symfile_init (objfile)
 525      struct objfile *objfile;
 526 {
 527   int val;
 528   bfd *sym_bfd = objfile->obfd;
 529   char *name = bfd_get_filename (sym_bfd);
 530   unsigned char size_temp[4];
 531
 532   /* Allocate struct to keep track of the symfile */
 533   objfile->sym_private = (PTR)
 534     xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
 535
 536   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
 537 #ifdef hp9000s800
 538 #define STRING_TABLE_OFFSET  (sym_bfd->origin + obj_dbx_str_filepos (sym_bfd))
 539 #define SYMBOL_TABLE_OFFSET  (sym_bfd->origin + obj_dbx_sym_filepos (sym_bfd))
 540 #define HP_STRING_TABLE_OFFSET  (sym_bfd->origin + obj_hp_str_filepos (sym_bfd))
 541 #define HP_SYMBOL_TABLE_OFFSET  (sym_bfd->origin + obj_hp_sym_filepos (sym_bfd))
 542 #else
 543 #define STRING_TABLE_OFFSET     (sym_bfd->origin + obj_str_filepos (sym_bfd))
 544 #define SYMBOL_TABLE_OFFSET     (sym_bfd->origin + obj_sym_filepos (sym_bfd))
 545 #endif
 546   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
 547
 548   DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
 549   if (!DBX_TEXT_SECT (objfile))
 550     error ("Can't find .text section in symbol file");
 551
 552 #ifdef hp9000s800
 553   HP_SYMCOUNT (objfile) = obj_hp_sym_count (sym_bfd);
 554   DBX_SYMCOUNT (objfile) = obj_dbx_sym_count (sym_bfd);
 555 #else
 556   DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
 557   DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
 558 #endif
 559   DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
 560
 561   /* Read the string table and stash it away in the psymbol_obstack.  It is
 562      only needed as long as we need to expand psymbols into full symbols,
 563      so when we blow away the psymbol the string table goes away as well.
 564      Note that gdb used to use the results of attempting to malloc the
 565      string table, based on the size it read, as a form of sanity check
 566      for botched byte swapping, on the theory that a byte swapped string
 567      table size would be so totally bogus that the malloc would fail.  Now
 568      that we put in on the psymbol_obstack, we can't do this since gdb gets
 569      a fatal error (out of virtual memory) if the size is bogus.  We can
 570      however at least check to see if the size is zero or some negative
 571      value. */
 572
 573 #ifdef hp9000s800
 574   DBX_STRINGTAB_SIZE (objfile) = obj_dbx_stringtab_size (sym_bfd);
 575   HP_STRINGTAB_SIZE (objfile) = obj_hp_stringtab_size (sym_bfd);
 576 #else
 577   val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
 578   if (val < 0)
 579     perror_with_name (name);
 580
 581   val = bfd_read ((PTR)size_temp, sizeof (long), 1, sym_bfd);
 582   if (val < 0)
 583     perror_with_name (name);
 584
 585   DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
 586 #endif
 587
 588   if (DBX_STRINGTAB_SIZE (objfile) <= 0)
 589     error ("ridiculous string table size (%d bytes).",
 590            DBX_STRINGTAB_SIZE (objfile));
 591
 592   DBX_STRINGTAB (objfile) =
 593     (char *) obstack_alloc (&objfile -> psymbol_obstack,
 594                             DBX_STRINGTAB_SIZE (objfile));
 595 #ifdef hp9000s800
 596   if (HP_STRINGTAB_SIZE (objfile) <= 0)
 597     error ("ridiculous string table size (%d bytes).",
 598            HP_STRINGTAB_SIZE (objfile));
 599
 600   HP_STRINGTAB (objfile) =
 601     (char *) obstack_alloc (&objfile -> psymbol_obstack,
 602                             HP_STRINGTAB_SIZE (objfile));
 603 #endif
 604
 605   /* Now read in the string table in one big gulp.  */
 606
 607   val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, L_SET);
 608   if (val < 0)
 609     perror_with_name (name);
 610   val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
 611                   sym_bfd);
 612   if (val != DBX_STRINGTAB_SIZE (objfile))
 613     perror_with_name (name);
 614 #ifdef hp9000s800
 615   val = bfd_seek (sym_bfd, HP_STRING_TABLE_OFFSET, L_SET);
 616   if (val < 0)
 617     perror_with_name (name);
 618   val = bfd_read (HP_STRINGTAB (objfile), HP_STRINGTAB_SIZE (objfile), 1,
 619                   sym_bfd);
 620   if (val != HP_STRINGTAB_SIZE (objfile))
 621     perror_with_name (name);
 622 #endif
 623 #ifdef hp9000s800
 624   HP_SYMTAB_OFFSET (objfile) = HP_SYMBOL_TABLE_OFFSET;
 625 #endif
 626 }
 627
 628 /* Perform any local cleanups required when we are done with a particular
 629    objfile.  I.E, we are in the process of discarding all symbol information
 630    for an objfile, freeing up all memory held for it, and unlinking the
 631    objfile struct from the global list of known objfiles. */
 632
 633 static void
 634 dbx_symfile_finish (objfile)
 635      struct objfile *objfile;
 636 {
 637   if (objfile->sym_private != NULL)
 638     {
 639       mfree (objfile -> md, objfile->sym_private);
 640     }
 641   free_header_files ();
 642 }
 643
 644 \f
 645 /* Buffer for reading the symbol table entries.  */
 646 static struct internal_nlist symbuf[4096];
 647 static int symbuf_idx;
 648 static int symbuf_end;
 649
 650 /* Name of last function encountered.  Used in Solaris to approximate
 651    object file boundaries.  */
 652 static char *last_function_name;
 653
 654 /* The address in memory of the string table of the object file we are
 655    reading (which might not be the "main" object file, but might be a
 656    shared library or some other dynamically loaded thing).  This is set
 657    by read_dbx_symtab when building psymtabs, and by read_ofile_symtab
 658    when building symtabs, and is used only by next_symbol_text.  */
 659 static char *stringtab_global;
 660
 661 /* Refill the symbol table input buffer
 662    and set the variables that control fetching entries from it.
 663    Reports an error if no data available.
 664    This function can read past the end of the symbol table
 665    (into the string table) but this does no harm.  */
 666
 667 static void
 668 fill_symbuf (sym_bfd)
 669      bfd *sym_bfd;
 670 {
 671   int nbytes = bfd_read ((PTR)symbuf, sizeof (symbuf), 1, sym_bfd);
 672   if (nbytes < 0)
 673     perror_with_name (bfd_get_filename (sym_bfd));
 674   else if (nbytes == 0)
 675     error ("Premature end of file reading symbol table");
 676   symbuf_end = nbytes / symbol_size;
 677   symbuf_idx = 0;
 678 }
 679 #ifdef hp9000s800
 680 /* same as above for the HP symbol table */
 681
 682 static struct symbol_dictionary_record hp_symbuf[4096];
 683 static int hp_symbuf_idx;
 684 static int hp_symbuf_end;
 685
 686 static int
 687 fill_hp_symbuf (sym_bfd)
 688      bfd *sym_bfd;
 689 {
 690   int nbytes = bfd_read ((PTR)hp_symbuf, sizeof (hp_symbuf), 1, sym_bfd);
 691   if (nbytes <= 0)
 692     error ("error or end of file reading symbol table");
 693   hp_symbuf_end = nbytes / sizeof (struct symbol_dictionary_record);
 694   hp_symbuf_idx = 0;
 695   return 1;
 696 }
 697 #endif
 698
 699 #define SWAP_SYMBOL(symp, abfd) \
 700   { \
 701     (symp)->n_strx = bfd_h_get_32(abfd,                 \
 702                                 (unsigned char *)&(symp)->n_strx);      \
 703     (symp)->n_desc = bfd_h_get_16 (abfd,                        \
 704                                 (unsigned char *)&(symp)->n_desc);      \
 705     (symp)->n_value = bfd_h_get_32 (abfd,                       \
 706                                 (unsigned char *)&(symp)->n_value);     \
 707   }
 708
 709 /* Invariant: The symbol pointed to by symbuf_idx is the first one
 710    that hasn't been swapped.  Swap the symbol at the same time
 711    that symbuf_idx is incremented.  */
 712
 713 /* dbx allows the text of a symbol name to be continued into the
 714    next symbol name!  When such a continuation is encountered
 715    (a \ at the end of the text of a name)
 716    call this function to get the continuation.  */
 717
 718 static char *
 719 dbx_next_symbol_text ()
 720 {
 721   if (symbuf_idx == symbuf_end)
 722     fill_symbuf (symfile_bfd);
 723   symnum++;
 724   SWAP_SYMBOL(&symbuf[symbuf_idx], symfile_bfd);
 725   return symbuf[symbuf_idx++].n_strx + stringtab_global
 726           + file_string_table_offset;
 727 }
 728 \f
 729 /* Initializes storage for all of the partial symbols that will be
 730    created by read_dbx_symtab and subsidiaries.  */
 731
 732 static void
 733 init_psymbol_list (objfile)
 734      struct objfile *objfile;
 735 {
 736   /* Free any previously allocated psymbol lists.  */
 737   if (objfile -> global_psymbols.list)
 738     mfree (objfile -> md, (PTR)objfile -> global_psymbols.list);
 739   if (objfile -> static_psymbols.list)
 740     mfree (objfile -> md, (PTR)objfile -> static_psymbols.list);
 741
 742   /* Current best guess is that there are approximately a twentieth
 743      of the total symbols (in a debugging file) are global or static
 744      oriented symbols */
 745 #ifdef hp9000s800
 746   objfile -> global_psymbols.size = (DBX_SYMCOUNT (objfile) +
 747                                      HP_SYMCOUNT (objfile)) / 10;
 748   objfile -> static_psymbols.size = (DBX_SYMCOUNT (objfile) +
 749                                      HP_SYMCOUNT (objfile)) / 10;
 750 #else
 751   objfile -> global_psymbols.size = DBX_SYMCOUNT (objfile) / 10;
 752   objfile -> static_psymbols.size = DBX_SYMCOUNT (objfile) / 10;
 753 #endif
 754   objfile -> global_psymbols.next = objfile -> global_psymbols.list = (struct partial_symbol *)
 755     xmmalloc (objfile -> md, objfile -> global_psymbols.size * sizeof (struct partial_symbol));
 756   objfile -> static_psymbols.next = objfile -> static_psymbols.list = (struct partial_symbol *)
 757     xmmalloc (objfile -> md, objfile -> static_psymbols.size * sizeof (struct partial_symbol));
 758 }
 759
 760 /* Initialize the list of bincls to contain none and have some
 761    allocated.  */
 762
 763 static void
 764 init_bincl_list (number, objfile)
 765      int number;
 766      struct objfile *objfile;
 767 {
 768   bincls_allocated = number;
 769   next_bincl = bincl_list = (struct header_file_location *)
 770     xmmalloc (objfile -> md, bincls_allocated * sizeof(struct header_file_location));
 771 }
 772
 773 /* Add a bincl to the list.  */
 774
 775 static void
 776 add_bincl_to_list (pst, name, instance)
 777      struct partial_symtab *pst;
 778      char *name;
 779      int instance;
 780 {
 781   if (next_bincl >= bincl_list + bincls_allocated)
 782     {
 783       int offset = next_bincl - bincl_list;
 784       bincls_allocated *= 2;
 785       bincl_list = (struct header_file_location *)
 786         xmrealloc (pst->objfile->md, (char *)bincl_list,
 787                   bincls_allocated * sizeof (struct header_file_location));
 788       next_bincl = bincl_list + offset;
 789     }
 790   next_bincl->pst = pst;
 791   next_bincl->instance = instance;
 792   next_bincl++->name = name;
 793 }
 794
 795 /* Given a name, value pair, find the corresponding
 796    bincl in the list.  Return the partial symtab associated
 797    with that header_file_location.  */
 798
 799 static struct partial_symtab *
 800 find_corresponding_bincl_psymtab (name, instance)
 801      char *name;
 802      int instance;
 803 {
 804   struct header_file_location *bincl;
 805
 806   for (bincl = bincl_list; bincl < next_bincl; bincl++)
 807     if (bincl->instance == instance
 808         && !strcmp (name, bincl->name))
 809       return bincl->pst;
 810
 811   return (struct partial_symtab *) 0;
 812 }
 813
 814 /* Free the storage allocated for the bincl list.  */
 815
 816 static void
 817 free_bincl_list (objfile)
 818      struct objfile *objfile;
 819 {
 820   mfree (objfile -> md, (PTR)bincl_list);
 821   bincls_allocated = 0;
 822 }
 823
 824 /* Given pointers to an a.out symbol table in core containing dbx
 825    style data, setup partial_symtab's describing each source file for
 826    which debugging information is available.
 827    SYMFILE_NAME is the name of the file we are reading from
 828    and SECTION_OFFSETS is the set of offsets for the various sections
 829    of the file (a set of zeros if the mainline program).  */
 830
 831 static void
 832 read_dbx_symtab (section_offsets, objfile, text_addr, text_size)
 833      struct section_offsets *section_offsets;
 834      struct objfile *objfile;
 835      CORE_ADDR text_addr;
 836      int text_size;
 837 {
 838   register struct internal_nlist *bufp = 0;     /* =0 avoids gcc -Wall glitch */
 839   register char *namestring;
 840   int nsl;
 841   int past_first_source_file = 0;
 842   CORE_ADDR last_o_file_start = 0;
 843   struct cleanup *old_chain;
 844   bfd *abfd;
 845 #ifdef hp9000s800
 846   /* HP stuff */
 847   struct symbol_dictionary_record *hp_bufp;
 848   int hp_symnum;
 849   /* A hack: the first text symbol in the debugging library */
 850   int dbsubc_addr = 0;
 851 #endif
 852
 853
 854   /* End of the text segment of the executable file.  */
 855   CORE_ADDR end_of_text_addr;
 856
 857   /* Current partial symtab */
 858   struct partial_symtab *pst;
 859
 860   /* List of current psymtab's include files */
 861   char **psymtab_include_list;
 862   int includes_allocated;
 863   int includes_used;
 864
 865   /* Index within current psymtab dependency list */
 866   struct partial_symtab **dependency_list;
 867   int dependencies_used, dependencies_allocated;
 868
 869   /* FIXME.  We probably want to change stringtab_global rather than add this
 870      while processing every symbol entry.  FIXME.  */
 871   file_string_table_offset = 0;
 872   next_file_string_table_offset = 0;
 873
 874 #ifdef hp9000s800
 875   stringtab_global = HP_STRINGTAB (objfile);
 876 #else
 877   stringtab_global = DBX_STRINGTAB (objfile);
 878 #endif
 879
 880   pst = (struct partial_symtab *) 0;
 881
 882   includes_allocated = 30;
 883   includes_used = 0;
 884   psymtab_include_list = (char **) alloca (includes_allocated *
 885                                            sizeof (char *));
 886
 887   dependencies_allocated = 30;
 888   dependencies_used = 0;
 889   dependency_list =
 890     (struct partial_symtab **) alloca (dependencies_allocated *
 891                                        sizeof (struct partial_symtab *));
 892
 893   old_chain = make_cleanup (free_objfile, objfile);
 894
 895   /* Init bincl list */
 896   init_bincl_list (20, objfile);
 897   make_cleanup (free_bincl_list, objfile);
 898
 899   last_source_file = 0;
 900
 901 #ifdef END_OF_TEXT_DEFAULT
 902   end_of_text_addr = END_OF_TEXT_DEFAULT;
 903 #else
 904   end_of_text_addr = text_addr + section_offsets->offsets[SECT_OFF_TEXT]
 905                                + text_size;     /* Relocate */
 906 #endif
 907
 908   symfile_bfd = objfile->obfd;  /* For next_text_symbol */
 909   abfd = objfile->obfd;
 910   symbuf_end = symbuf_idx = 0;
 911   next_symbol_text_func = dbx_next_symbol_text;
 912
 913 #ifdef hp9000s800
 914   /* On pa machines, the global symbols are all in the regular HP-UX
 915      symbol table. Read them in first. */
 916
 917   hp_symbuf_end = hp_symbuf_idx = 0;
 918   bfd_seek (abfd, HP_SYMTAB_OFFSET (objfile), 0);
 919
 920   for (hp_symnum = 0; hp_symnum < HP_SYMCOUNT (objfile); hp_symnum++)
 921     {
 922       int dbx_type;
 923
 924       QUIT;
 925       if (hp_symbuf_idx == hp_symbuf_end)
 926         fill_hp_symbuf (abfd);
 927       hp_bufp = &hp_symbuf[hp_symbuf_idx++];
 928       switch (hp_bufp->symbol_type)
 929         {
 930         case ST_SYM_EXT:
 931         case ST_ARG_EXT:
 932           continue;
 933         case ST_CODE:
 934         case ST_PRI_PROG:
 935         case ST_SEC_PROG:
 936         case ST_ENTRY:
 937         case ST_MILLICODE:
 938           dbx_type = N_TEXT;
 939           hp_bufp->symbol_value &= ~3; /* clear out permission bits */
 940           break;
 941         case ST_DATA:
 942           dbx_type = N_DATA;
 943           break;
 944 #ifdef KERNELDEBUG
 945         case ST_ABSOLUTE:
 946           {
 947             extern int kernel_debugging;
 948             if (!kernel_debugging)
 949               continue;
 950             dbx_type = N_ABS;
 951             break;
 952           }
 953 #endif
 954         default:
 955           continue;
 956         }
 957       /* Use the address of dbsubc to finish the last psymtab. */
 958       if (hp_bufp->symbol_type == ST_CODE &&
 959           HP_STRINGTAB (objfile)[hp_bufp->name.n_strx] == '_' &&
 960           !strcmp (HP_STRINGTAB (objfile) + hp_bufp->name.n_strx, "_dbsubc"))
 961         dbsubc_addr = hp_bufp->symbol_value;
 962       if (hp_bufp->symbol_scope == SS_UNIVERSAL)
 963         {
 964           if (hp_bufp->name.n_strx > HP_STRINGTAB_SIZE (objfile))
 965             error ("Invalid symbol data; bad HP string table offset: %d",
 966                    hp_bufp->name.n_strx);
 967           /* A hack, but gets the job done. */
 968           if (!strcmp (hp_bufp->name.n_strx + HP_STRINGTAB (objfile),
 969                        "$START$"))
 970             objfile -> ei.entry_file_lowpc = hp_bufp->symbol_value;
 971           if (!strcmp (hp_bufp->name.n_strx + HP_STRINGTAB (objfile),
 972                        "_sr4export"))
 973             objfile -> ei.entry_file_highpc = hp_bufp->symbol_value;
 974           record_minimal_symbol (hp_bufp->name.n_strx + HP_STRINGTAB (objfile),
 975                                  hp_bufp->symbol_value, dbx_type | N_EXT,
 976                                  objfile);
 977         }
 978     }
 979   bfd_seek (abfd, DBX_SYMTAB_OFFSET (objfile), 0);
 980 #endif
 981
 982   for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
 983     {
 984       /* Get the symbol for this run and pull out some info */
 985       QUIT;     /* allow this to be interruptable */
 986       if (symbuf_idx == symbuf_end)
 987         fill_symbuf (abfd);
 988       bufp = &symbuf[symbuf_idx++];
 989
 990       /*
 991        * Special case to speed up readin.
 992        */
 993       if (bufp->n_type == (unsigned char)N_SLINE) continue;
 994
 995       SWAP_SYMBOL (bufp, abfd);
 996
 997       /* Ok.  There is a lot of code duplicated in the rest of this
 998          switch statement (for efficiency reasons).  Since I don't
 999          like duplicating code, I will do my penance here, and
1000          describe the code which is duplicated:
1001
1002          *) The assignment to namestring.
1003          *) The call to strchr.
1004          *) The addition of a partial symbol the the two partial
1005             symbol lists.  This last is a large section of code, so
1006             I've imbedded it in the following macro.
1007          */
1008
1009 /* Set namestring based on bufp.  If the string table index is invalid,
1010    give a fake name, and print a single error message per symbol file read,
1011    rather than abort the symbol reading or flood the user with messages.  */
1012
1013 /*FIXME: Too many adds and indirections in here for the inner loop.  */
1014 #define SET_NAMESTRING()\
1015   if (((unsigned)bufp->n_strx + file_string_table_offset) >=            \
1016       DBX_STRINGTAB_SIZE (objfile)) {                                   \
1017     complain (&string_table_offset_complaint, (char *) symnum);         \
1018     namestring = "foo";                                                 \
1019   } else                                                                \
1020     namestring = bufp->n_strx + file_string_table_offset +              \
1021                  DBX_STRINGTAB (objfile)
1022
1023 #define CUR_SYMBOL_TYPE bufp->n_type
1024 #define CUR_SYMBOL_VALUE bufp->n_value
1025 #define DBXREAD_ONLY
1026 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1027   start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1028 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)\
1029   end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps)
1030
1031 #include "partial-stab.h"
1032     }
1033
1034   /* If there's stuff to be cleaned up, clean it up.  */
1035 #ifndef hp9000s800
1036   if (DBX_SYMCOUNT (objfile) > 0                        /* We have some syms */
1037 /*FIXME, does this have a bug at start address 0? */
1038       && last_o_file_start
1039       && objfile -> ei.entry_point < bufp->n_value
1040       && objfile -> ei.entry_point >= last_o_file_start)
1041     {
1042       objfile -> ei.entry_file_lowpc = last_o_file_start;
1043       objfile -> ei.entry_file_highpc = bufp->n_value;
1044     }
1045 #endif
1046
1047   if (pst)
1048     {
1049 #ifdef hp9000s800
1050       end_psymtab (pst, psymtab_include_list, includes_used,
1051                    symnum * symbol_size, dbsubc_addr,
1052                    dependency_list, dependencies_used);
1053 #else
1054       end_psymtab (pst, psymtab_include_list, includes_used,
1055                    symnum * symbol_size, end_of_text_addr,
1056                    dependency_list, dependencies_used);
1057 #endif
1058     }
1059
1060   free_bincl_list (objfile);
1061   discard_cleanups (old_chain);
1062 }
1063
1064 /* Allocate and partially fill a partial symtab.  It will be
1065    completely filled at the end of the symbol list.
1066
1067    SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1068    is the address relative to which its symbols are (incremental) or 0
1069    (normal). */
1070
1071
1072 struct partial_symtab *
1073 start_psymtab (objfile, section_offsets,
1074                filename, textlow, ldsymoff, global_syms, static_syms)
1075      struct objfile *objfile;
1076      struct section_offsets *section_offsets;
1077      char *filename;
1078      CORE_ADDR textlow;
1079      int ldsymoff;
1080      struct partial_symbol *global_syms;
1081      struct partial_symbol *static_syms;
1082 {
1083   struct partial_symtab *result =
1084       start_psymtab_common(objfile, section_offsets,
1085                            filename, textlow, global_syms, static_syms);
1086
1087   result->read_symtab_private = (char *)
1088     obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
1089   LDSYMOFF(result) = ldsymoff;
1090   result->read_symtab = dbx_psymtab_to_symtab;
1091   SYMBOL_SIZE(result) = symbol_size;
1092   SYMBOL_OFFSET(result) = symbol_table_offset;
1093   STRING_OFFSET(result) = string_table_offset;
1094   FILE_STRING_OFFSET(result) = file_string_table_offset;
1095
1096   /* If we're handling an ELF file, drag some section-relocation info
1097      for this source file out of the ELF symbol table, to compensate for
1098      Sun brain death.  This replaces the section_offsets in this psymtab,
1099      if successful.  */
1100   elfstab_offset_sections (objfile, result);
1101
1102   return result;
1103 }
1104
1105 /* Close off the current usage of a partial_symbol table entry.  This
1106    involves setting the correct number of includes (with a realloc),
1107    setting the high text mark, setting the symbol length in the
1108    executable, and setting the length of the global and static lists
1109    of psymbols.
1110
1111    The global symbols and static symbols are then seperately sorted.
1112
1113    Then the partial symtab is put on the global list.
1114    *** List variables and peculiarities of same. ***
1115    */
1116
1117 void
1118 end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
1119              capping_text, dependency_list, number_dependencies)
1120      struct partial_symtab *pst;
1121      char **include_list;
1122      int num_includes;
1123      int capping_symbol_offset;
1124      CORE_ADDR capping_text;
1125      struct partial_symtab **dependency_list;
1126      int number_dependencies;
1127 /*     struct partial_symbol *capping_global, *capping_static;*/
1128 {
1129   int i;
1130   struct partial_symtab *p1;
1131   struct objfile *objfile = pst -> objfile;
1132
1133   if (capping_symbol_offset != -1)
1134       LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
1135   pst->texthigh = capping_text;
1136
1137   /* Under Solaris, the N_SO symbols always have a value of 0,
1138      instead of the usual address of the .o file.  Therefore,
1139      we have to do some tricks to fill in texthigh and textlow.
1140      The first trick is in partial-stab.h: if we see a static
1141      or global function, and the textlow for the current pst
1142      is still 0, then we use that function's address for
1143      the textlow of the pst.
1144
1145      Now, to fill in texthigh, we remember the last function seen
1146      in the .o file (also in partial-stab.h).  Also, there's a hack in
1147      bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1148      to here via the misc_info field.  Therefore, we can fill in
1149      a reliable texthigh by taking the address plus size of the
1150      last function in the file.
1151
1152      Unfortunately, that does not cover the case where the last function
1153      in the file is static.  See the paragraph below for more comments
1154      on this situation.
1155
1156      Finally, if we have a valid textlow for the current file, we run
1157      down the partial_symtab_list filling in previous texthighs that
1158      are still unknown.  */
1159
1160   if (pst->texthigh == 0 && last_function_name) {
1161     char *p;
1162     int n;
1163     struct minimal_symbol *minsym;
1164
1165     p = strchr (last_function_name, ':');
1166     if (p == NULL)
1167       p = last_function_name;
1168     n = p - last_function_name;
1169     p = alloca (n + 1);
1170     strncpy (p, last_function_name, n);
1171     p[n] = 0;
1172
1173     minsym = lookup_minimal_symbol (p, objfile);
1174
1175     if (minsym) {
1176       pst->texthigh = minsym->address + (int)minsym->info;
1177     } else {
1178       /* This file ends with a static function, and it's
1179          difficult to imagine how hard it would be to track down
1180          the elf symbol.  Luckily, most of the time no one will notice,
1181          since the next file will likely be compiled with -g, so
1182          the code below will copy the first fuction's start address
1183          back to our texthigh variable.  (Also, if this file is the
1184          last one in a dynamically linked program, texthigh already
1185          has the right value.)  If the next file isn't compiled
1186          with -g, then the last function in this file winds up owning
1187          all of the text space up to the next -g file, or the end (minus
1188          shared libraries).  This only matters for single stepping,
1189          and even then it will still work, except that it will single
1190          step through all of the covered functions, instead of setting
1191          breakpoints around them as it usualy does.  This makes it
1192          pretty slow, but at least it doesn't fail.
1193
1194          We can fix this with a fairly big change to bfd, but we need
1195          to coordinate better with Cygnus if we want to do that.  FIXME.  */
1196     }
1197     last_function_name = NULL;
1198   }
1199
1200   /* this test will be true if the last .o file is only data */
1201   if (pst->textlow == 0)
1202     pst->textlow = pst->texthigh;
1203
1204   /* If we know our own starting text address, then walk through all other
1205      psymtabs for this objfile, and if any didn't know their ending text
1206      address, set it to our starting address.  Take care to not set our
1207      own ending address to our starting address, nor to set addresses on
1208      `dependency' files that have both textlow and texthigh zero.  */
1209   if (pst->textlow) {
1210     ALL_OBJFILE_PSYMTABS (objfile, p1) {
1211       if (p1->texthigh == 0  && p1->textlow != 0 && p1 != pst) {
1212         p1->texthigh = pst->textlow;
1213         /* if this file has only data, then make textlow match texthigh */
1214         if (p1->textlow == 0)
1215           p1->textlow = p1->texthigh;
1216       }
1217     }
1218   }
1219
1220   /* End of kludge for patching Solaris textlow and texthigh.  */
1221
1222
1223   pst->n_global_syms =
1224     objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1225   pst->n_static_syms =
1226     objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1227
1228   pst->number_of_dependencies = number_dependencies;
1229   if (number_dependencies)
1230     {
1231       pst->dependencies = (struct partial_symtab **)
1232         obstack_alloc (&objfile->psymbol_obstack,
1233                        number_dependencies * sizeof (struct partial_symtab *));
1234       memcpy (pst->dependencies, dependency_list,
1235              number_dependencies * sizeof (struct partial_symtab *));
1236     }
1237   else
1238     pst->dependencies = 0;
1239
1240   for (i = 0; i < num_includes; i++)
1241     {
1242       struct partial_symtab *subpst =
1243         allocate_psymtab (include_list[i], objfile);
1244
1245       subpst->section_offsets = pst->section_offsets;
1246       subpst->read_symtab_private =
1247           (char *) obstack_alloc (&objfile->psymbol_obstack,
1248                                   sizeof (struct symloc));
1249       LDSYMOFF(subpst) =
1250         LDSYMLEN(subpst) =
1251           subpst->textlow =
1252             subpst->texthigh = 0;
1253
1254       /* We could save slight bits of space by only making one of these,
1255          shared by the entire set of include files.  FIXME-someday.  */
1256       subpst->dependencies = (struct partial_symtab **)
1257         obstack_alloc (&objfile->psymbol_obstack,
1258                        sizeof (struct partial_symtab *));
1259       subpst->dependencies[0] = pst;
1260       subpst->number_of_dependencies = 1;
1261
1262       subpst->globals_offset =
1263         subpst->n_global_syms =
1264           subpst->statics_offset =
1265             subpst->n_static_syms = 0;
1266
1267       subpst->readin = 0;
1268       subpst->symtab = 0;
1269       subpst->read_symtab = dbx_psymtab_to_symtab;
1270     }
1271
1272   sort_pst_symbols (pst);
1273
1274   /* If there is already a psymtab or symtab for a file of this name, remove it.
1275      (If there is a symtab, more drastic things also happen.)
1276      This happens in VxWorks.  */
1277   free_named_symtabs (pst->filename);
1278
1279   if (num_includes == 0
1280    && number_dependencies == 0
1281    && pst->n_global_syms == 0
1282    && pst->n_static_syms == 0) {
1283     /* Throw away this psymtab, it's empty.  We can't deallocate it, since
1284        it is on the obstack, but we can forget to chain it on the list.  */
1285     struct partial_symtab *prev_pst;
1286
1287     /* First, snip it out of the psymtab chain */
1288
1289     if (pst->objfile->psymtabs == pst)
1290       pst->objfile->psymtabs = pst->next;
1291     else
1292       for (prev_pst = pst->objfile->psymtabs; prev_pst; prev_pst = pst->next)
1293         if (prev_pst->next == pst)
1294           prev_pst->next = pst->next;
1295
1296     /* Next, put it on a free list for recycling */
1297
1298     pst->next = pst->objfile->free_psymtabs;
1299     pst->objfile->free_psymtabs = pst;
1300   }
1301 }
1302 \f
1303 static void
1304 dbx_psymtab_to_symtab_1 (pst)
1305      struct partial_symtab *pst;
1306 {
1307   struct cleanup *old_chain;
1308   int i;
1309
1310   if (!pst)
1311     return;
1312
1313   if (pst->readin)
1314     {
1315       fprintf (stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
1316                pst->filename);
1317       return;
1318     }
1319
1320   /* Read in all partial symtabs on which this one is dependent */
1321   for (i = 0; i < pst->number_of_dependencies; i++)
1322     if (!pst->dependencies[i]->readin)
1323       {
1324         /* Inform about additional files that need to be read in.  */
1325         if (info_verbose)
1326           {
1327             fputs_filtered (" ", stdout);
1328             wrap_here ("");
1329             fputs_filtered ("and ", stdout);
1330             wrap_here ("");
1331             printf_filtered ("%s...", pst->dependencies[i]->filename);
1332             wrap_here ("");             /* Flush output */
1333             fflush (stdout);
1334           }
1335         dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1336       }
1337
1338   if (LDSYMLEN(pst))            /* Otherwise it's a dummy */
1339     {
1340       /* Init stuff necessary for reading in symbols */
1341       buildsym_init ();
1342       old_chain = make_cleanup (really_free_pendings, 0);
1343       file_string_table_offset = FILE_STRING_OFFSET (pst);
1344 #ifdef hp9000s800
1345       symbol_size = obj_dbx_symbol_entry_size (sym_bfd);
1346 #else
1347       symbol_size = SYMBOL_SIZE (pst);
1348 #endif
1349
1350       /* Read in this file's symbols */
1351       bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), L_SET);
1352       pst->symtab =
1353         read_ofile_symtab (pst->objfile, LDSYMOFF(pst), LDSYMLEN(pst),
1354                            pst->textlow, pst->texthigh - pst->textlow,
1355                            pst->section_offsets);
1356       sort_symtab_syms (pst->symtab);
1357
1358       do_cleanups (old_chain);
1359     }
1360
1361   pst->readin = 1;
1362 }
1363
1364 /* Read in all of the symbols for a given psymtab for real.
1365    Be verbose about it if the user wants that.  */
1366
1367 static void
1368 dbx_psymtab_to_symtab (pst)
1369      struct partial_symtab *pst;
1370 {
1371   bfd *sym_bfd;
1372
1373   if (!pst)
1374     return;
1375
1376   if (pst->readin)
1377     {
1378       fprintf (stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
1379                pst->filename);
1380       return;
1381     }
1382
1383   if (LDSYMLEN(pst) || pst->number_of_dependencies)
1384     {
1385       /* Print the message now, before reading the string table,
1386          to avoid disconcerting pauses.  */
1387       if (info_verbose)
1388         {
1389           printf_filtered ("Reading in symbols for %s...", pst->filename);
1390           fflush (stdout);
1391         }
1392
1393       sym_bfd = pst->objfile->obfd;
1394
1395       next_symbol_text_func = dbx_next_symbol_text;
1396
1397       dbx_psymtab_to_symtab_1 (pst);
1398
1399       /* Match with global symbols.  This only needs to be done once,
1400          after all of the symtabs and dependencies have been read in.   */
1401       scan_file_globals (pst->objfile);
1402
1403       /* Finish up the debug error message.  */
1404       if (info_verbose)
1405         printf_filtered ("done.\n");
1406     }
1407 }
1408
1409 /* Read in a defined section of a specific object file's symbols.
1410
1411    DESC is the file descriptor for the file, positioned at the
1412    beginning of the symtab
1413    SYM_OFFSET is the offset within the file of
1414    the beginning of the symbols we want to read
1415    SYM_SIZE is the size of the symbol info to read in.
1416    TEXT_OFFSET is the beginning of the text segment we are reading symbols for
1417    TEXT_SIZE is the size of the text segment read in.
1418    SECTION_OFFSETS are the relocation offsets which get added to each symbol. */
1419
1420 static struct symtab *
1421 read_ofile_symtab (objfile, sym_offset, sym_size, text_offset, text_size,
1422                    section_offsets)
1423      struct objfile *objfile;
1424      int sym_offset;
1425      int sym_size;
1426      CORE_ADDR text_offset;
1427      int text_size;
1428      struct section_offsets *section_offsets;
1429 {
1430   register char *namestring;
1431   register struct internal_nlist *bufp;
1432   unsigned char type;
1433   unsigned max_symnum;
1434   register bfd *abfd;
1435
1436   current_objfile = objfile;
1437   subfile_stack = 0;
1438
1439 #ifdef hp9000s800
1440   stringtab_global = HP_STRINGTAB (objfile);
1441 #else
1442   stringtab_global = DBX_STRINGTAB (objfile);
1443 #endif
1444   last_source_file = 0;
1445
1446   abfd = objfile->obfd;
1447   symfile_bfd = objfile->obfd;  /* Implicit param to next_text_symbol */
1448   symbuf_end = symbuf_idx = 0;
1449
1450   /* It is necessary to actually read one symbol *before* the start
1451      of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1452      occurs before the N_SO symbol.
1453
1454      Detecting this in read_dbx_symtab
1455      would slow down initial readin, so we look for it here instead.  */
1456   if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1457     {
1458       bfd_seek (symfile_bfd, sym_offset - symbol_size, L_INCR);
1459       fill_symbuf (abfd);
1460       bufp = &symbuf[symbuf_idx++];
1461       SWAP_SYMBOL (bufp, abfd);
1462
1463       SET_NAMESTRING ();
1464
1465       processing_gcc_compilation =
1466         (bufp->n_type == N_TEXT
1467          && (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0
1468              || strcmp(namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0));
1469     }
1470   else
1471     {
1472       /* The N_SO starting this symtab is the first symbol, so we
1473          better not check the symbol before it.  I'm not this can
1474          happen, but it doesn't hurt to check for it.  */
1475       bfd_seek (symfile_bfd, sym_offset, L_INCR);
1476       processing_gcc_compilation = 0;
1477     }
1478
1479   if (symbuf_idx == symbuf_end)
1480     fill_symbuf (abfd);
1481   bufp = &symbuf[symbuf_idx];
1482   if (bufp->n_type != (unsigned char)N_SO)
1483     error("First symbol in segment of executable not a source symbol");
1484
1485   max_symnum = sym_size / symbol_size;
1486
1487   for (symnum = 0;
1488        symnum < max_symnum;
1489        symnum++)
1490     {
1491       QUIT;                     /* Allow this to be interruptable */
1492       if (symbuf_idx == symbuf_end)
1493         fill_symbuf(abfd);
1494       bufp = &symbuf[symbuf_idx++];
1495       SWAP_SYMBOL (bufp, abfd);
1496
1497       type = bufp->n_type;
1498
1499       SET_NAMESTRING ();
1500
1501       if (type & N_STAB) {
1502           process_one_symbol (type, bufp->n_desc, bufp->n_value,
1503                               namestring, section_offsets, objfile);
1504       }
1505       /* We skip checking for a new .o or -l file; that should never
1506          happen in this routine. */
1507       else if (type == N_TEXT
1508                && (strcmp (namestring, GCC_COMPILED_FLAG_SYMBOL) == 0
1509                    || strcmp (namestring, GCC2_COMPILED_FLAG_SYMBOL) == 0))
1510         /* I don't think this code will ever be executed, because
1511            the GCC_COMPILED_FLAG_SYMBOL usually is right before
1512            the N_SO symbol which starts this source file.
1513            However, there is no reason not to accept
1514            the GCC_COMPILED_FLAG_SYMBOL anywhere.  */
1515         processing_gcc_compilation = 1;
1516       else if (type & N_EXT || type == (unsigned char)N_TEXT
1517                || type == (unsigned char)N_NBTEXT
1518                ) {
1519           /* Global symbol: see if we came across a dbx defintion for
1520              a corresponding symbol.  If so, store the value.  Remove
1521              syms from the chain when their values are stored, but
1522              search the whole chain, as there may be several syms from
1523              different files with the same name. */
1524           /* This is probably not true.  Since the files will be read
1525              in one at a time, each reference to a global symbol will
1526              be satisfied in each file as it appears. So we skip this
1527              section. */
1528           ;
1529         }
1530     }
1531
1532   current_objfile = NULL;
1533
1534   /* In a Solaris elf file, this variable, which comes from the
1535      value of the N_SO symbol, will still be 0.  Luckily, text_offset,
1536      which comes from pst->textlow is correct. */
1537   if (last_source_start_addr == 0)
1538     last_source_start_addr = text_offset;
1539
1540   return end_symtab (text_offset + text_size, 0, 0, objfile);
1541 }
1542 \f
1543 /* This handles a single symbol from the symbol-file, building symbols
1544    into a GDB symtab.  It takes these arguments and an implicit argument.
1545
1546    TYPE is the type field of the ".stab" symbol entry.
1547    DESC is the desc field of the ".stab" entry.
1548    VALU is the value field of the ".stab" entry.
1549    NAME is the symbol name, in our address space.
1550    SECTION_OFFSETS is a set of amounts by which the sections of this object
1551           file were relocated when it was loaded into memory.
1552           All symbols that refer
1553           to memory locations need to be offset by these amounts.
1554    OBJFILE is the object file from which we are reading symbols.
1555                It is used in end_symtab.  */
1556
1557 void
1558 process_one_symbol (type, desc, valu, name, section_offsets, objfile)
1559      int type, desc;
1560      CORE_ADDR valu;
1561      char *name;
1562      struct section_offsets *section_offsets;
1563      struct objfile *objfile;
1564 {
1565 #ifndef SUN_FIXED_LBRAC_BUG
1566   /* This records the last pc address we've seen.  We depend on there being
1567      an SLINE or FUN or SO before the first LBRAC, since the variable does
1568      not get reset in between reads of different symbol files.  */
1569   static CORE_ADDR last_pc_address;
1570 #endif
1571   register struct context_stack *new;
1572   /* This remembers the address of the start of a function.  It is used
1573      because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1574      relative to the current function's start address.  On systems
1575      other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1576      used to relocate these symbol types rather than SECTION_OFFSETS.  */
1577   static CORE_ADDR function_start_offset;
1578   char *colon_pos;
1579
1580   /* Something is wrong if we see real data before
1581      seeing a source file name.  */
1582
1583   if (last_source_file == 0 && type != (unsigned char)N_SO)
1584     {
1585       /* Currently this ignores N_ENTRY on Gould machines, N_NSYM on machines
1586          where that code is defined.  */
1587       if (IGNORE_SYMBOL (type))
1588         return;
1589
1590       /* FIXME, this should not be an error, since it precludes extending
1591          the symbol table information in this way...  */
1592       error ("Invalid symbol data: does not start by identifying a source file.");
1593     }
1594
1595   switch (type)
1596     {
1597     case N_FUN:
1598     case N_FNAME:
1599 #if 0
1600 /* It seems that the Sun ANSI C compiler (acc) replaces N_FUN with N_GSYM and
1601    N_STSYM with a type code of f or F.  Can't enable this until we get some
1602    stuff straightened out with psymtabs.  FIXME. */
1603
1604     case N_GSYM:
1605     case N_STSYM:
1606 #endif /* 0 */
1607
1608       /* Relocate for dynamic loading */
1609       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1610
1611       /* Either of these types of symbols indicates the start of
1612          a new function.  We must process its "name" normally for dbx,
1613          but also record the start of a new lexical context, and possibly
1614          also the end of the lexical context for the previous function.  */
1615       /* This is not always true.  This type of symbol may indicate a
1616          text segment variable.  */
1617
1618       colon_pos = strchr (name, ':');
1619       if (!colon_pos++
1620           || (*colon_pos != 'f' && *colon_pos != 'F'))
1621         {
1622           define_symbol (valu, name, desc, type, objfile);
1623           break;
1624         }
1625
1626 #ifndef SUN_FIXED_LBRAC_BUG
1627       last_pc_address = valu;   /* Save for SunOS bug circumcision */
1628 #endif
1629
1630 #ifdef  BLOCK_ADDRESS_FUNCTION_RELATIVE
1631       /* On Solaris 2.0 compilers, the block addresses and N_SLINE's
1632          are relative to the start of the function.  On normal systems,
1633          and when using gcc on Solaris 2.0, these addresses are just
1634          absolute, or relative to the N_SO, depending on
1635          BLOCK_ADDRESS_ABSOLUTE.  */
1636       function_start_offset = valu;
1637 #else
1638       /* Default on ordinary systems */
1639       function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
1640 #endif
1641
1642       within_function = 1;
1643       if (context_stack_depth > 0)
1644         {
1645           new = pop_context ();
1646           /* Make a block for the local symbols within.  */
1647           finish_block (new->name, &local_symbols, new->old_blocks,
1648                         new->start_addr, valu, objfile);
1649         }
1650       /* Stack must be empty now.  */
1651       if (context_stack_depth != 0)
1652         complain (&lbrac_unmatched_complaint, (char *) symnum);
1653
1654       new = push_context (0, valu);
1655       new->name = define_symbol (valu, name, desc, type, objfile);
1656       break;
1657
1658     case N_LBRAC:
1659       /* This "symbol" just indicates the start of an inner lexical
1660          context within a function.  */
1661
1662 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1663       /* Relocate for dynamic loading and Sun ELF acc fn-relative syms.  */
1664       valu += function_start_offset;
1665 #else
1666       /* On most machines, the block addresses are relative to the
1667          N_SO, the linker did not relocate them (sigh).  */
1668       valu += last_source_start_addr;
1669 #endif
1670
1671 #ifndef SUN_FIXED_LBRAC_BUG
1672       if (valu < last_pc_address) {
1673         /* Patch current LBRAC pc value to match last handy pc value */
1674         complain (&lbrac_complaint, 0);
1675         valu = last_pc_address;
1676       }
1677 #endif
1678       new = push_context (desc, valu);
1679       break;
1680
1681     case N_RBRAC:
1682       /* This "symbol" just indicates the end of an inner lexical
1683          context that was started with N_LBRAC.  */
1684
1685 #if defined(BLOCK_ADDRESS_ABSOLUTE) || defined(BLOCK_ADDRESS_FUNCTION_RELATIVE)
1686       /* Relocate for dynamic loading and Sun ELF acc fn-relative syms.  */
1687       valu += function_start_offset;
1688 #else
1689       /* On most machines, the block addresses are relative to the
1690          N_SO, the linker did not relocate them (sigh).  */
1691       valu += last_source_start_addr;
1692 #endif
1693
1694       new = pop_context();
1695       if (desc != new->depth)
1696         complain (&lbrac_mismatch_complaint, (char *) symnum);
1697
1698       /* Some compilers put the variable decls inside of an
1699          LBRAC/RBRAC block.  This macro should be nonzero if this
1700          is true.  DESC is N_DESC from the N_RBRAC symbol.
1701          GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1702          or the GCC2_COMPILED_SYMBOL.  */
1703 #if !defined (VARIABLES_INSIDE_BLOCK)
1704 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
1705 #endif
1706
1707       /* Can only use new->locals as local symbols here if we're in
1708          gcc or on a machine that puts them before the lbrack.  */
1709       if (!VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1710         local_symbols = new->locals;
1711
1712       /* If this is not the outermost LBRAC...RBRAC pair in the
1713          function, its local symbols preceded it, and are the ones
1714          just recovered from the context stack.  Defined the block for them.
1715
1716          If this is the outermost LBRAC...RBRAC pair, there is no
1717          need to do anything; leave the symbols that preceded it
1718          to be attached to the function's own block.  However, if
1719          it is so, we need to indicate that we just moved outside
1720          of the function.  */
1721       if (local_symbols
1722           && (context_stack_depth
1723               > !VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation)))
1724         {
1725           /* FIXME Muzzle a compiler bug that makes end < start.  */
1726           if (new->start_addr > valu)
1727             {
1728               complain(&lbrac_rbrac_complaint, 0);
1729               new->start_addr = valu;
1730             }
1731           /* Make a block for the local symbols within.  */
1732           finish_block (0, &local_symbols, new->old_blocks,
1733                         new->start_addr, valu, objfile);
1734         }
1735       else
1736         {
1737           within_function = 0;
1738         }
1739       if (VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
1740         /* Now pop locals of block just finished.  */
1741         local_symbols = new->locals;
1742       break;
1743
1744     case N_FN:
1745     case N_FN_SEQ:
1746       /* This kind of symbol indicates the start of an object file.  */
1747       /* Relocate for dynamic loading */
1748       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1749       break;
1750
1751     case N_SO:
1752       /* This type of symbol indicates the start of data
1753          for one source file.
1754          Finish the symbol table of the previous source file
1755          (if any) and start accumulating a new symbol table.  */
1756       /* Relocate for dynamic loading */
1757       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1758
1759 #ifndef SUN_FIXED_LBRAC_BUG
1760       last_pc_address = valu;   /* Save for SunOS bug circumcision */
1761 #endif
1762
1763 #ifdef PCC_SOL_BROKEN
1764       /* pcc bug, occasionally puts out SO for SOL.  */
1765       if (context_stack_depth > 0)
1766         {
1767           start_subfile (name, NULL);
1768           break;
1769         }
1770 #endif
1771       if (last_source_file)
1772         {
1773           /* Check if previous symbol was also an N_SO (with some
1774              sanity checks).  If so, that one was actually the directory
1775              name, and the current one is the real file name.
1776              Patch things up. */
1777           if (previous_stab_code == N_SO)
1778             {
1779               if (current_subfile && current_subfile->dirname == NULL
1780                   && current_subfile->name != NULL
1781                   && current_subfile->name[strlen(current_subfile->name)-1] == '/')
1782                 {
1783                   current_subfile->dirname = current_subfile->name;
1784                   current_subfile->name =
1785                     obsavestring (name, strlen (name),
1786                                   &objfile -> symbol_obstack);
1787                 }
1788               break;            /* Ignore repeated SOs */
1789             }
1790           end_symtab (valu, 0, 0, objfile);
1791         }
1792       start_symtab (name, NULL, valu);
1793       break;
1794
1795
1796     case N_SOL:
1797       /* This type of symbol indicates the start of data for
1798          a sub-source-file, one whose contents were copied or
1799          included in the compilation of the main source file
1800          (whose name was given in the N_SO symbol.)  */
1801       /* Relocate for dynamic loading */
1802       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1803       start_subfile (name, NULL);
1804       break;
1805
1806     case N_BINCL:
1807       push_subfile ();
1808       add_new_header_file (name, valu);
1809       start_subfile (name, NULL);
1810       break;
1811
1812     case N_EINCL:
1813       start_subfile (pop_subfile (), NULL);
1814       break;
1815
1816     case N_EXCL:
1817       add_old_header_file (name, valu);
1818       break;
1819
1820     case N_SLINE:
1821       /* This type of "symbol" really just records
1822          one line-number -- core-address correspondence.
1823          Enter it in the line list for this symbol table.  */
1824       /* Relocate for dynamic loading and for ELF acc fn-relative syms.  */
1825       valu += function_start_offset;
1826 #ifndef SUN_FIXED_LBRAC_BUG
1827       last_pc_address = valu;   /* Save for SunOS bug circumcision */
1828 #endif
1829       record_line (current_subfile, desc, valu);
1830       break;
1831
1832     case N_BCOMM:
1833       if (common_block)
1834         error ("Invalid symbol data: common within common at symtab pos %d",
1835                symnum);
1836       common_block = local_symbols;
1837       common_block_i = local_symbols ? local_symbols->nsyms : 0;
1838       break;
1839
1840     case N_ECOMM:
1841       /* Symbols declared since the BCOMM are to have the common block
1842          start address added in when we know it.  common_block points to
1843          the first symbol after the BCOMM in the local_symbols list;
1844          copy the list and hang it off the symbol for the common block name
1845          for later fixup.  */
1846       {
1847         int i;
1848         struct symbol *sym =
1849           (struct symbol *) xmmalloc (objfile -> md, sizeof (struct symbol));
1850         memset (sym, 0, sizeof *sym);
1851         SYMBOL_NAME (sym) = savestring (name, strlen (name));
1852         SYMBOL_CLASS (sym) = LOC_BLOCK;
1853         SYMBOL_NAMESPACE (sym) = (enum namespace)((long)
1854           copy_pending (local_symbols, common_block_i, common_block));
1855         i = hashname (SYMBOL_NAME (sym));
1856         SYMBOL_VALUE_CHAIN (sym) = global_sym_chain[i];
1857         global_sym_chain[i] = sym;
1858         common_block = 0;
1859         break;
1860       }
1861
1862     /* The following symbol types need to have the appropriate offset added
1863        to their value; then we process symbol definitions in the name.  */
1864
1865     case N_STSYM:               /* Static symbol in data seg */
1866     case N_LCSYM:               /* Static symbol in BSS seg */
1867     case N_ROSYM:               /* Static symbol in Read-only data seg */
1868      /* HORRID HACK DEPT.  However, it's Sun's furgin' fault.  FIXME.
1869         Solaris2's stabs-in-coff makes *most* symbols relative
1870         but leaves a few absolute.  N_STSYM and friends sit on the fence.
1871         .stab "foo:S...",N_STSYM        is absolute (ld relocates it)
1872         .stab "foo:V...",N_STSYM        is relative (section base subtracted).
1873         This leaves us no choice but to search for the 'S' or 'V'...
1874         (or pass the whole section_offsets stuff down ONE MORE function
1875         call level, which we really don't want to do).  */
1876       {
1877         char *p;
1878         p = strchr (name, ':');
1879         if (p != 0 && p[1] == 'S')
1880           {
1881             /* FIXME!  We relocate it by the TEXT offset, in case the
1882                whole module moved in memory.  But this is wrong, since
1883                the sections can side around independently.  */
1884             valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1885             goto define_a_symbol;
1886           }
1887         /* Since it's not the kludge case, re-dispatch to the right handler. */
1888         switch (type) {
1889         case N_STSYM:   goto case_N_STSYM;
1890         case N_LCSYM:   goto case_N_LCSYM;
1891         case N_ROSYM:   goto case_N_ROSYM;
1892         default:        abort();
1893         }
1894       }
1895
1896     case_N_STSYM:               /* Static symbol in data seg */
1897     case N_DSLINE:              /* Source line number, data seg */
1898       valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
1899       goto define_a_symbol;
1900
1901     case_N_LCSYM:               /* Static symbol in BSS seg */
1902     case N_BSLINE:              /* Source line number, bss seg */
1903     /*   N_BROWS:       overlaps with N_BSLINE */
1904       valu += ANOFFSET (section_offsets, SECT_OFF_BSS);
1905       goto define_a_symbol;
1906
1907     case_N_ROSYM:               /* Static symbol in Read-only data seg */
1908       valu += ANOFFSET (section_offsets, SECT_OFF_RODATA);
1909       goto define_a_symbol;
1910
1911     case N_ENTRY:               /* Alternate entry point */
1912       /* Relocate for dynamic loading */
1913       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1914       goto define_a_symbol;
1915
1916     /* The following symbol types don't need the address field relocated,
1917        since it is either unused, or is absolute.  */
1918     define_a_symbol:
1919     case N_GSYM:                /* Global variable */
1920     case N_NSYMS:               /* Number of symbols (ultrix) */
1921     case N_NOMAP:               /* No map?  (ultrix) */
1922     case N_RSYM:                /* Register variable */
1923     case N_DEFD:                /* Modula-2 GNU module dependency */
1924     case N_SSYM:                /* Struct or union element */
1925     case N_LSYM:                /* Local symbol in stack */
1926     case N_PSYM:                /* Parameter variable */
1927     case N_LENG:                /* Length of preceding symbol type */
1928       if (name)
1929         define_symbol (valu, name, desc, type, objfile);
1930       break;
1931
1932     /* The following symbol types can be ignored.  */
1933     case N_OBJ:                 /* Solaris 2:  Object file dir and name */
1934     case N_OPT:                 /* Solaris 2:  Optimization level? */
1935     /*   N_UNDF:                   Solaris 2:  file separator mark */
1936     /*   N_UNDF: -- we will never encounter it, since we only process one
1937                     file's symbols at once.  */
1938     case N_ENDM:                /* Solaris 2:  End of module */
1939     case N_MAIN:                /* Name of main routine.  */
1940       break;
1941
1942     /* The following symbol types we don't know how to process.  Handle
1943        them in a "default" way, but complain to people who care.  */
1944     default:
1945     case N_CATCH:               /* Exception handler catcher */
1946     case N_EHDECL:              /* Exception handler name */
1947     case N_PC:                  /* Global symbol in Pascal */
1948     case N_M2C:                 /* Modula-2 compilation unit */
1949     /*   N_MOD2:        overlaps with N_EHDECL */
1950     case N_SCOPE:               /* Modula-2 scope information */
1951     case N_ECOML:               /* End common (local name) */
1952     case N_NBTEXT:              /* Gould Non-Base-Register symbols??? */
1953     case N_NBDATA:
1954     case N_NBBSS:
1955     case N_NBSTS:
1956     case N_NBLCS:
1957       complain (&unknown_symtype_complaint, local_hex_string(type));
1958       if (name)
1959         define_symbol (valu, name, desc, type, objfile);
1960     }
1961
1962   previous_stab_code = type;
1963 }
1964 \f
1965 /* Copy a pending list, used to record the contents of a common
1966    block for later fixup.  */
1967 static struct pending *
1968 copy_pending (beg, begi, end)
1969     struct pending *beg;
1970     int begi;
1971     struct pending *end;
1972 {
1973   struct pending *new = 0;
1974   struct pending *next;
1975
1976   for (next = beg; next != 0 && (next != end || begi < end->nsyms);
1977        next = next->next, begi = 0)
1978     {
1979       register int j;
1980       for (j = begi; j < next->nsyms; j++)
1981         add_symbol_to_list (next->symbol[j], &new);
1982     }
1983   return new;
1984 }
1985 \f
1986 /* Scan and build partial symbols for an ELF symbol file.
1987    This ELF file has already been processed to get its minimal symbols,
1988    and any DWARF symbols that were in it.
1989
1990    This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
1991    rolled into one.
1992
1993    OBJFILE is the object file we are reading symbols from.
1994    ADDR is the address relative to which the symbols are (e.g.
1995    the base address of the text segment).
1996    MAINLINE is true if we are reading the main symbol
1997    table (as opposed to a shared lib or dynamically loaded file).
1998    STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
1999    section exists.
2000    STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2001    .stabstr section exists.
2002
2003    This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2004    adjusted for elf details. */
2005
2006 void
2007 DEFUN(elfstab_build_psymtabs, (objfile, section_offsets, mainline,
2008                                staboffset, stabsize,
2009                                stabstroffset, stabstrsize),
2010       struct objfile *objfile AND
2011       struct section_offsets *section_offsets AND
2012       int mainline AND
2013       unsigned int staboffset AND
2014       unsigned int stabsize AND
2015       unsigned int stabstroffset AND
2016       unsigned int stabstrsize)
2017 {
2018   int val;
2019   bfd *sym_bfd = objfile->obfd;
2020   char *name = bfd_get_filename (sym_bfd);
2021   struct dbx_symfile_info *info;
2022
2023   /* There is already a dbx_symfile_info allocated by our caller.
2024      It might even contain some info from the ELF symtab to help us.  */
2025   info = (struct dbx_symfile_info *) objfile->sym_private;
2026
2027   DBX_TEXT_SECT (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
2028   if (!DBX_TEXT_SECT (objfile))
2029     error ("Can't find .text section in symbol file");
2030
2031 #define ELF_STABS_SYMBOL_SIZE   12      /* XXX FIXME XXX */
2032   DBX_SYMBOL_SIZE    (objfile) = ELF_STABS_SYMBOL_SIZE;
2033   DBX_SYMCOUNT       (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2034   DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2035   DBX_SYMTAB_OFFSET  (objfile) = staboffset;
2036
2037   if (stabstrsize < 0)  /* FIXME:  stabstrsize is unsigned; never true! */
2038     error ("ridiculous string table size: %d bytes", stabstrsize);
2039   DBX_STRINGTAB (objfile) = (char *)
2040     obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2041
2042   /* Now read in the string table in one big gulp.  */
2043
2044   val = bfd_seek (sym_bfd, stabstroffset, L_SET);
2045   if (val < 0)
2046     perror_with_name (name);
2047   val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2048   if (val != stabstrsize)
2049     perror_with_name (name);
2050
2051   buildsym_new_init ();
2052   free_header_files ();
2053   init_header_files ();
2054   install_minimal_symbols (objfile);
2055
2056   processing_acc_compilation = 1;
2057
2058   /* In an elf file, we've already installed the minimal symbols that came
2059      from the elf (non-stab) symbol table, so always act like an
2060      incremental load here. */
2061   dbx_symfile_read (objfile, section_offsets, 0);
2062 }
2063 \f
2064 /* Parse the user's idea of an offset for dynamic linking, into our idea
2065    of how to represent it for fast symbol reading.  */
2066
2067 struct section_offsets *
2068 dbx_symfile_offsets (objfile, addr)
2069      struct objfile *objfile;
2070      CORE_ADDR addr;
2071 {
2072   struct section_offsets *section_offsets;
2073   int i;
2074
2075   section_offsets = (struct section_offsets *)
2076     obstack_alloc (&objfile -> psymbol_obstack,
2077                    sizeof (struct section_offsets) +
2078                           sizeof (section_offsets->offsets) * (SECT_OFF_MAX-1));
2079
2080   for (i = 0; i < SECT_OFF_MAX; i++)
2081     ANOFFSET (section_offsets, i) = addr;
2082
2083   return section_offsets;
2084 }
2085 \f
2086 /* Register our willingness to decode symbols for SunOS and a.out and
2087    b.out files handled by BFD... */
2088 static struct sym_fns sunos_sym_fns =
2089 {
2090   "sunOs",              /* sym_name: name or name prefix of BFD target type */
2091   6,                    /* sym_namelen: number of significant sym_name chars */
2092   dbx_new_init,         /* sym_new_init: init anything gbl to entire symtab */
2093   dbx_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
2094   dbx_symfile_read,     /* sym_read: read a symbol file into symtab */
2095   dbx_symfile_finish,   /* sym_finish: finished with file, cleanup */
2096   dbx_symfile_offsets,  /* sym_offsets: parse user's offsets to internal form */
2097   NULL                  /* next: pointer to next struct sym_fns */
2098 };
2099
2100 static struct sym_fns aout_sym_fns =
2101 {
2102   "a.out",              /* sym_name: name or name prefix of BFD target type */
2103   5,                    /* sym_namelen: number of significant sym_name chars */
2104   dbx_new_init,         /* sym_new_init: init anything gbl to entire symtab */
2105   dbx_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
2106   dbx_symfile_read,     /* sym_read: read a symbol file into symtab */
2107   dbx_symfile_finish,   /* sym_finish: finished with file, cleanup */
2108   dbx_symfile_offsets,  /* sym_offsets: parse user's offsets to internal form */
2109   NULL                  /* next: pointer to next struct sym_fns */
2110 };
2111
2112 static struct sym_fns bout_sym_fns =
2113 {
2114   "b.out",              /* sym_name: name or name prefix of BFD target type */
2115   5,                    /* sym_namelen: number of significant sym_name chars */
2116   dbx_new_init,         /* sym_new_init: init anything gbl to entire symtab */
2117   dbx_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
2118   dbx_symfile_read,     /* sym_read: read a symbol file into symtab */
2119   dbx_symfile_finish,   /* sym_finish: finished with file, cleanup */
2120   dbx_symfile_offsets,  /* sym_offsets: parse user's offsets to internal form */
2121   NULL                  /* next: pointer to next struct sym_fns */
2122 };
2123
2124 /* This is probably a mistake.  FIXME.  Why can't the HP's use an ordinary
2125    file format name with an -hppa suffix?  */
2126 static struct sym_fns hppa_sym_fns =
2127 {
2128   "hppa",               /* sym_name: name or name prefix of BFD target type */
2129   4,                    /* sym_namelen: number of significant sym_name chars */
2130   dbx_new_init,         /* sym_new_init: init anything gbl to entire symtab */
2131   dbx_symfile_init,     /* sym_init: read initial info, setup for sym_read() */
2132   dbx_symfile_read,     /* sym_read: read a symbol file into symtab */
2133   dbx_symfile_finish,   /* sym_finish: finished with file, cleanup */
2134   dbx_symfile_offsets,  /* sym_offsets: parse user's offsets to internal form */
2135   NULL                  /* next: pointer to next struct sym_fns */
2136 };
2137
2138 void
2139 _initialize_dbxread ()
2140 {
2141   add_symtab_fns(&sunos_sym_fns);
2142   add_symtab_fns(&aout_sym_fns);
2143   add_symtab_fns(&bout_sym_fns);
2144   add_symtab_fns(&hppa_sym_fns);
2145 }