* dbxread.c (process_one_symbol) [SUN_FIXED_LBRAC_BUG]: Remove
[external/binutils.git] / gdb / dbxread.c
1 /* Read dbx symbol tables and convert to internal format, for GDB.
2    Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004.
4    Free Software Foundation, Inc.
5
6    This file is part of GDB.
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place - Suite 330,
21    Boston, MA 02111-1307, USA.  */
22
23 /* This module provides three functions: dbx_symfile_init,
24    which initializes to read a symbol file; dbx_new_init, which 
25    discards existing cached information when all symbols are being
26    discarded; and dbx_symfile_read, which reads a symbol table
27    from a file.
28
29    dbx_symfile_read only does the minimum work necessary for letting the
30    user "name" things symbolically; it does not read the entire symtab.
31    Instead, it reads the external and static symbols and puts them in partial
32    symbol tables.  When more extensive information is requested of a
33    file, the corresponding partial symbol table is mutated into a full
34    fledged symbol table by going back and reading the symbols
35    for real.  dbx_psymtab_to_symtab() is the function that does this */
36
37 #include "defs.h"
38 #include "gdb_string.h"
39
40 #if defined(USG) || defined(__CYGNUSCLIB__)
41 #include <sys/types.h>
42 #include <fcntl.h>
43 #endif
44
45 #include "gdb_obstack.h"
46 #include "gdb_stat.h"
47 #include "symtab.h"
48 #include "breakpoint.h"
49 #include "target.h"
50 #include "gdbcore.h"            /* for bfd stuff */
51 #include "libaout.h"            /* FIXME Secret internal BFD stuff for a.out */
52 #include "objfiles.h"
53 #include "buildsym.h"
54 #include "stabsread.h"
55 #include "gdb-stabs.h"
56 #include "demangle.h"
57 #include "language.h"           /* Needed for local_hex_string */
58 #include "complaints.h"
59 #include "cp-abi.h"
60 #include "gdb_assert.h"
61
62 #include "aout/aout64.h"
63 #include "aout/stab_gnu.h"      /* We always use GNU stabs, not native, now */
64 \f
65
66 /* We put a pointer to this structure in the read_symtab_private field
67    of the psymtab.  */
68
69 struct symloc
70   {
71     /* Offset within the file symbol table of first local symbol for this
72        file.  */
73
74     int ldsymoff;
75
76     /* Length (in bytes) of the section of the symbol table devoted to
77        this file's symbols (actually, the section bracketed may contain
78        more than just this file's symbols).  If ldsymlen is 0, the only
79        reason for this thing's existence is the dependency list.  Nothing
80        else will happen when it is read in.  */
81
82     int ldsymlen;
83
84     /* The size of each symbol in the symbol file (in external form).  */
85
86     int symbol_size;
87
88     /* Further information needed to locate the symbols if they are in
89        an ELF file.  */
90
91     int symbol_offset;
92     int string_offset;
93     int file_string_offset;
94   };
95
96 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
97 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
98 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
99 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
100 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
101 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
102 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
103 \f
104
105 /* Remember what we deduced to be the source language of this psymtab. */
106
107 static enum language psymtab_language = language_unknown;
108
109 /* The BFD for this file -- implicit parameter to next_symbol_text.  */
110
111 static bfd *symfile_bfd;
112
113 /* The size of each symbol in the symbol file (in external form).
114    This is set by dbx_symfile_read when building psymtabs, and by
115    dbx_psymtab_to_symtab when building symtabs.  */
116
117 static unsigned symbol_size;
118
119 /* This is the offset of the symbol table in the executable file. */
120
121 static unsigned symbol_table_offset;
122
123 /* This is the offset of the string table in the executable file. */
124
125 static unsigned string_table_offset;
126
127 /* For elf+stab executables, the n_strx field is not a simple index
128    into the string table.  Instead, each .o file has a base offset in
129    the string table, and the associated symbols contain offsets from
130    this base.  The following two variables contain the base offset for
131    the current and next .o files. */
132
133 static unsigned int file_string_table_offset;
134 static unsigned int next_file_string_table_offset;
135
136 /* .o and NLM files contain unrelocated addresses which are based at
137    0.  When non-zero, this flag disables some of the special cases for
138    Solaris elf+stab text addresses at location 0. */
139
140 static int symfile_relocatable = 0;
141
142 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
143    relative to the function start address.  */
144
145 static int block_address_function_relative = 0;
146 \f
147 /* The lowest text address we have yet encountered.  This is needed
148    because in an a.out file, there is no header field which tells us
149    what address the program is actually going to be loaded at, so we
150    need to make guesses based on the symbols (which *are* relocated to
151    reflect the address it will be loaded at).  */
152
153 static CORE_ADDR lowest_text_address;
154
155 /* Non-zero if there is any line number info in the objfile.  Prevents
156    end_psymtab from discarding an otherwise empty psymtab.  */
157
158 static int has_line_numbers;
159
160 /* Complaints about the symbols we have encountered.  */
161
162 static void
163 unknown_symtype_complaint (const char *arg1)
164 {
165   complaint (&symfile_complaints, "unknown symbol type %s", arg1);
166 }
167
168 static void
169 lbrac_mismatch_complaint (int arg1)
170 {
171   complaint (&symfile_complaints,
172              "N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", arg1);
173 }
174
175 static void
176 repeated_header_complaint (const char *arg1, int arg2)
177 {
178   complaint (&symfile_complaints,
179              "\"repeated\" header file %s not previously seen, at symtab pos %d",
180              arg1, arg2);
181 }
182
183 /* find_text_range --- find start and end of loadable code sections
184
185    The find_text_range function finds the shortest address range that
186    encloses all sections containing executable code, and stores it in
187    objfile's text_addr and text_size members.
188
189    dbx_symfile_read will use this to finish off the partial symbol
190    table, in some cases.  */
191
192 static void
193 find_text_range (bfd * sym_bfd, struct objfile *objfile)
194 {
195   asection *sec;
196   int found_any = 0;
197   CORE_ADDR start = 0;
198   CORE_ADDR end = 0;
199
200   for (sec = sym_bfd->sections; sec; sec = sec->next)
201     if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE)
202       {
203         CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec);
204         CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec);
205
206         if (found_any)
207           {
208             if (sec_start < start)
209               start = sec_start;
210             if (sec_end > end)
211               end = sec_end;
212           }
213         else
214           {
215             start = sec_start;
216             end = sec_end;
217           }
218
219         found_any = 1;
220       }
221
222   if (!found_any)
223     error ("Can't find any code sections in symbol file");
224
225   DBX_TEXT_ADDR (objfile) = start;
226   DBX_TEXT_SIZE (objfile) = end - start;
227 }
228 \f
229
230
231 /* During initial symbol readin, we need to have a structure to keep
232    track of which psymtabs have which bincls in them.  This structure
233    is used during readin to setup the list of dependencies within each
234    partial symbol table. */
235
236 struct header_file_location
237 {
238   char *name;                   /* Name of header file */
239   int instance;                 /* See above */
240   struct partial_symtab *pst;   /* Partial symtab that has the
241                                    BINCL/EINCL defs for this file */
242 };
243
244 /* The actual list and controling variables */
245 static struct header_file_location *bincl_list, *next_bincl;
246 static int bincls_allocated;
247
248 /* Local function prototypes */
249
250 extern void _initialize_dbxread (void);
251
252 static void read_ofile_symtab (struct partial_symtab *);
253
254 static void dbx_psymtab_to_symtab (struct partial_symtab *);
255
256 static void dbx_psymtab_to_symtab_1 (struct partial_symtab *);
257
258 static void read_dbx_dynamic_symtab (struct objfile *objfile);
259
260 static void read_dbx_symtab (struct objfile *);
261
262 static void free_bincl_list (struct objfile *);
263
264 static struct partial_symtab *find_corresponding_bincl_psymtab (char *, int);
265
266 static void add_bincl_to_list (struct partial_symtab *, char *, int);
267
268 static void init_bincl_list (int, struct objfile *);
269
270 static char *dbx_next_symbol_text (struct objfile *);
271
272 static void fill_symbuf (bfd *);
273
274 static void dbx_symfile_init (struct objfile *);
275
276 static void dbx_new_init (struct objfile *);
277
278 static void dbx_symfile_read (struct objfile *, int);
279
280 static void dbx_symfile_finish (struct objfile *);
281
282 static void record_minimal_symbol (char *, CORE_ADDR, int, struct objfile *);
283
284 static void add_new_header_file (char *, int);
285
286 static void add_old_header_file (char *, int);
287
288 static void add_this_object_header_file (int);
289
290 static struct partial_symtab *start_psymtab (struct objfile *, char *,
291                                              CORE_ADDR, int,
292                                              struct partial_symbol **,
293                                              struct partial_symbol **);
294
295 /* Free up old header file tables */
296
297 void
298 free_header_files (void)
299 {
300   if (this_object_header_files)
301     {
302       xfree (this_object_header_files);
303       this_object_header_files = NULL;
304     }
305   n_allocated_this_object_header_files = 0;
306 }
307
308 /* Allocate new header file tables */
309
310 void
311 init_header_files (void)
312 {
313   n_allocated_this_object_header_files = 10;
314   this_object_header_files = (int *) xmalloc (10 * sizeof (int));
315 }
316
317 /* Add header file number I for this object file
318    at the next successive FILENUM.  */
319
320 static void
321 add_this_object_header_file (int i)
322 {
323   if (n_this_object_header_files == n_allocated_this_object_header_files)
324     {
325       n_allocated_this_object_header_files *= 2;
326       this_object_header_files
327         = (int *) xrealloc ((char *) this_object_header_files,
328                        n_allocated_this_object_header_files * sizeof (int));
329     }
330
331   this_object_header_files[n_this_object_header_files++] = i;
332 }
333
334 /* Add to this file an "old" header file, one already seen in
335    a previous object file.  NAME is the header file's name.
336    INSTANCE is its instance code, to select among multiple
337    symbol tables for the same header file.  */
338
339 static void
340 add_old_header_file (char *name, int instance)
341 {
342   struct header_file *p = HEADER_FILES (current_objfile);
343   int i;
344
345   for (i = 0; i < N_HEADER_FILES (current_objfile); i++)
346     if (strcmp (p[i].name, name) == 0 && instance == p[i].instance)
347       {
348         add_this_object_header_file (i);
349         return;
350       }
351   repeated_header_complaint (name, symnum);
352 }
353
354 /* Add to this file a "new" header file: definitions for its types follow.
355    NAME is the header file's name.
356    Most often this happens only once for each distinct header file,
357    but not necessarily.  If it happens more than once, INSTANCE has
358    a different value each time, and references to the header file
359    use INSTANCE values to select among them.
360
361    dbx output contains "begin" and "end" markers for each new header file,
362    but at this level we just need to know which files there have been;
363    so we record the file when its "begin" is seen and ignore the "end".  */
364
365 static void
366 add_new_header_file (char *name, int instance)
367 {
368   int i;
369   struct header_file *hfile;
370
371   /* Make sure there is room for one more header file.  */
372
373   i = N_ALLOCATED_HEADER_FILES (current_objfile);
374
375   if (N_HEADER_FILES (current_objfile) == i)
376     {
377       if (i == 0)
378         {
379           N_ALLOCATED_HEADER_FILES (current_objfile) = 10;
380           HEADER_FILES (current_objfile) = (struct header_file *)
381             xmalloc (10 * sizeof (struct header_file));
382         }
383       else
384         {
385           i *= 2;
386           N_ALLOCATED_HEADER_FILES (current_objfile) = i;
387           HEADER_FILES (current_objfile) = (struct header_file *)
388             xrealloc ((char *) HEADER_FILES (current_objfile),
389                       (i * sizeof (struct header_file)));
390         }
391     }
392
393   /* Create an entry for this header file.  */
394
395   i = N_HEADER_FILES (current_objfile)++;
396   hfile = HEADER_FILES (current_objfile) + i;
397   hfile->name = savestring (name, strlen (name));
398   hfile->instance = instance;
399   hfile->length = 10;
400   hfile->vector
401     = (struct type **) xmalloc (10 * sizeof (struct type *));
402   memset (hfile->vector, 0, 10 * sizeof (struct type *));
403
404   add_this_object_header_file (i);
405 }
406
407 #if 0
408 static struct type **
409 explicit_lookup_type (int real_filenum, int index)
410 {
411   struct header_file *f = &HEADER_FILES (current_objfile)[real_filenum];
412
413   if (index >= f->length)
414     {
415       f->length *= 2;
416       f->vector = (struct type **)
417         xrealloc (f->vector, f->length * sizeof (struct type *));
418       memset (&f->vector[f->length / 2],
419               '\0', f->length * sizeof (struct type *) / 2);
420     }
421   return &f->vector[index];
422 }
423 #endif
424 \f
425 static void
426 record_minimal_symbol (char *name, CORE_ADDR address, int type,
427                        struct objfile *objfile)
428 {
429   enum minimal_symbol_type ms_type;
430   int section;
431   asection *bfd_section;
432
433   switch (type)
434     {
435     case N_TEXT | N_EXT:
436       ms_type = mst_text;
437       section = SECT_OFF_TEXT (objfile);
438       bfd_section = DBX_TEXT_SECTION (objfile);
439       break;
440     case N_DATA | N_EXT:
441       ms_type = mst_data;
442       section = SECT_OFF_DATA (objfile);
443       bfd_section = DBX_DATA_SECTION (objfile);
444       break;
445     case N_BSS | N_EXT:
446       ms_type = mst_bss;
447       section = SECT_OFF_BSS (objfile);
448       bfd_section = DBX_BSS_SECTION (objfile);
449       break;
450     case N_ABS | N_EXT:
451       ms_type = mst_abs;
452       section = -1;
453       bfd_section = NULL;
454       break;
455 #ifdef N_SETV
456     case N_SETV | N_EXT:
457       ms_type = mst_data;
458       section = SECT_OFF_DATA (objfile);
459       bfd_section = DBX_DATA_SECTION (objfile);
460       break;
461     case N_SETV:
462       /* I don't think this type actually exists; since a N_SETV is the result
463          of going over many .o files, it doesn't make sense to have one
464          file local.  */
465       ms_type = mst_file_data;
466       section = SECT_OFF_DATA (objfile);
467       bfd_section = DBX_DATA_SECTION (objfile);
468       break;
469 #endif
470     case N_TEXT:
471     case N_NBTEXT:
472     case N_FN:
473     case N_FN_SEQ:
474       ms_type = mst_file_text;
475       section = SECT_OFF_TEXT (objfile);
476       bfd_section = DBX_TEXT_SECTION (objfile);
477       break;
478     case N_DATA:
479       ms_type = mst_file_data;
480
481       /* Check for __DYNAMIC, which is used by Sun shared libraries. 
482          Record it as global even if it's local, not global, so
483          lookup_minimal_symbol can find it.  We don't check symbol_leading_char
484          because for SunOS4 it always is '_'.  */
485       if (name[8] == 'C' && DEPRECATED_STREQ ("__DYNAMIC", name))
486         ms_type = mst_data;
487
488       /* Same with virtual function tables, both global and static.  */
489       {
490         char *tempstring = name;
491         if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
492           ++tempstring;
493         if (is_vtable_name (tempstring))
494           ms_type = mst_data;
495       }
496       section = SECT_OFF_DATA (objfile);
497       bfd_section = DBX_DATA_SECTION (objfile);
498       break;
499     case N_BSS:
500       ms_type = mst_file_bss;
501       section = SECT_OFF_BSS (objfile);
502       bfd_section = DBX_BSS_SECTION (objfile);
503       break;
504     default:
505       ms_type = mst_unknown;
506       section = -1;
507       bfd_section = NULL;
508       break;
509     }
510
511   if ((ms_type == mst_file_text || ms_type == mst_text)
512       && address < lowest_text_address)
513     lowest_text_address = address;
514
515   prim_record_minimal_symbol_and_info
516     (name, address, ms_type, NULL, section, bfd_section, objfile);
517 }
518 \f
519 /* Scan and build partial symbols for a symbol file.
520    We have been initialized by a call to dbx_symfile_init, which 
521    put all the relevant info into a "struct dbx_symfile_info",
522    hung off the objfile structure.
523
524    MAINLINE is true if we are reading the main symbol
525    table (as opposed to a shared lib or dynamically loaded file).  */
526
527 static void
528 dbx_symfile_read (struct objfile *objfile, int mainline)
529 {
530   bfd *sym_bfd;
531   int val;
532   struct cleanup *back_to;
533
534   sym_bfd = objfile->obfd;
535
536   /* .o and .nlm files are relocatables with text, data and bss segs based at
537      0.  This flag disables special (Solaris stabs-in-elf only) fixups for
538      symbols with a value of 0.  */
539
540   symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC;
541
542   /* This is true for Solaris (and all other systems which put stabs
543      in sections, hopefully, since it would be silly to do things
544      differently from Solaris), and false for SunOS4 and other a.out
545      file formats.  */
546   block_address_function_relative =
547     ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3))
548      || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3))
549      || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4))
550      || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2))
551      || (0 == strncmp (bfd_get_target (sym_bfd), "epoc-pe", 7))
552      || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3)));
553
554   val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
555   if (val < 0)
556     perror_with_name (objfile->name);
557
558   /* If we are reinitializing, or if we have never loaded syms yet, init */
559   if (mainline
560       || (objfile->global_psymbols.size == 0
561           &&  objfile->static_psymbols.size == 0))
562     init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
563
564   symbol_size = DBX_SYMBOL_SIZE (objfile);
565   symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
566
567   free_pending_blocks ();
568   back_to = make_cleanup (really_free_pendings, 0);
569
570   init_minimal_symbol_collection ();
571   make_cleanup_discard_minimal_symbols ();
572
573   /* Read stabs data from executable file and define symbols. */
574
575   read_dbx_symtab (objfile);
576
577   /* Add the dynamic symbols.  */
578
579   read_dbx_dynamic_symtab (objfile);
580
581   /* Install any minimal symbols that have been collected as the current
582      minimal symbols for this objfile. */
583
584   install_minimal_symbols (objfile);
585
586   do_cleanups (back_to);
587 }
588
589 /* Initialize anything that needs initializing when a completely new
590    symbol file is specified (not just adding some symbols from another
591    file, e.g. a shared library).  */
592
593 static void
594 dbx_new_init (struct objfile *ignore)
595 {
596   stabsread_new_init ();
597   buildsym_new_init ();
598   init_header_files ();
599 }
600
601
602 /* dbx_symfile_init ()
603    is the dbx-specific initialization routine for reading symbols.
604    It is passed a struct objfile which contains, among other things,
605    the BFD for the file whose symbols are being read, and a slot for a pointer
606    to "private data" which we fill with goodies.
607
608    We read the string table into malloc'd space and stash a pointer to it.
609
610    Since BFD doesn't know how to read debug symbols in a format-independent
611    way (and may never do so...), we have to do it ourselves.  We will never
612    be called unless this is an a.out (or very similar) file. 
613    FIXME, there should be a cleaner peephole into the BFD environment here.  */
614
615 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long)    /* FIXME */
616
617 static void
618 dbx_symfile_init (struct objfile *objfile)
619 {
620   int val;
621   bfd *sym_bfd = objfile->obfd;
622   char *name = bfd_get_filename (sym_bfd);
623   asection *text_sect;
624   unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
625
626   /* Allocate struct to keep track of the symfile */
627   objfile->sym_stab_info = (struct dbx_symfile_info *)
628     xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
629   memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
630
631   DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
632   DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
633   DBX_BSS_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".bss");
634
635   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
636 #define STRING_TABLE_OFFSET     (sym_bfd->origin + obj_str_filepos (sym_bfd))
637 #define SYMBOL_TABLE_OFFSET     (sym_bfd->origin + obj_sym_filepos (sym_bfd))
638
639   /* FIXME POKING INSIDE BFD DATA STRUCTURES */
640
641   DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
642
643   text_sect = bfd_get_section_by_name (sym_bfd, ".text");
644   if (!text_sect)
645     error ("Can't find .text section in symbol file");
646   DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
647   DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
648
649   DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
650   DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
651   DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
652
653   /* Read the string table and stash it away in the objfile_obstack.
654      When we blow away the objfile the string table goes away as well.
655      Note that gdb used to use the results of attempting to malloc the
656      string table, based on the size it read, as a form of sanity check
657      for botched byte swapping, on the theory that a byte swapped string
658      table size would be so totally bogus that the malloc would fail.  Now
659      that we put in on the objfile_obstack, we can't do this since gdb gets
660      a fatal error (out of virtual memory) if the size is bogus.  We can
661      however at least check to see if the size is less than the size of
662      the size field itself, or larger than the size of the entire file.
663      Note that all valid string tables have a size greater than zero, since
664      the bytes used to hold the size are included in the count. */
665
666   if (STRING_TABLE_OFFSET == 0)
667     {
668       /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
669          will never be zero, even when there is no string table.  This
670          would appear to be a bug in bfd. */
671       DBX_STRINGTAB_SIZE (objfile) = 0;
672       DBX_STRINGTAB (objfile) = NULL;
673     }
674   else
675     {
676       val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
677       if (val < 0)
678         perror_with_name (name);
679
680       memset (size_temp, 0, sizeof (size_temp));
681       val = bfd_bread (size_temp, sizeof (size_temp), sym_bfd);
682       if (val < 0)
683         {
684           perror_with_name (name);
685         }
686       else if (val == 0)
687         {
688           /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
689              EOF if there is no string table, and attempting to read the size
690              from EOF will read zero bytes. */
691           DBX_STRINGTAB_SIZE (objfile) = 0;
692           DBX_STRINGTAB (objfile) = NULL;
693         }
694       else
695         {
696           /* Read some data that would appear to be the string table size.
697              If there really is a string table, then it is probably the right
698              size.  Byteswap if necessary and validate the size.  Note that
699              the minimum is DBX_STRINGTAB_SIZE_SIZE.  If we just read some
700              random data that happened to be at STRING_TABLE_OFFSET, because
701              bfd can't tell us there is no string table, the sanity checks may
702              or may not catch this. */
703           DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
704
705           if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
706               || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
707             error ("ridiculous string table size (%d bytes).",
708                    DBX_STRINGTAB_SIZE (objfile));
709
710           DBX_STRINGTAB (objfile) =
711             (char *) obstack_alloc (&objfile->objfile_obstack,
712                                     DBX_STRINGTAB_SIZE (objfile));
713           OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile));
714
715           /* Now read in the string table in one big gulp.  */
716
717           val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
718           if (val < 0)
719             perror_with_name (name);
720           val = bfd_bread (DBX_STRINGTAB (objfile),
721                            DBX_STRINGTAB_SIZE (objfile),
722                            sym_bfd);
723           if (val != DBX_STRINGTAB_SIZE (objfile))
724             perror_with_name (name);
725         }
726     }
727 }
728
729 /* Perform any local cleanups required when we are done with a particular
730    objfile.  I.E, we are in the process of discarding all symbol information
731    for an objfile, freeing up all memory held for it, and unlinking the
732    objfile struct from the global list of known objfiles. */
733
734 static void
735 dbx_symfile_finish (struct objfile *objfile)
736 {
737   if (objfile->sym_stab_info != NULL)
738     {
739       if (HEADER_FILES (objfile) != NULL)
740         {
741           int i = N_HEADER_FILES (objfile);
742           struct header_file *hfiles = HEADER_FILES (objfile);
743
744           while (--i >= 0)
745             {
746               xfree (hfiles[i].name);
747               xfree (hfiles[i].vector);
748             }
749           xfree (hfiles);
750         }
751       xmfree (objfile->md, objfile->sym_stab_info);
752     }
753   free_header_files ();
754 }
755 \f
756
757 /* Buffer for reading the symbol table entries.  */
758 static struct external_nlist symbuf[4096];
759 static int symbuf_idx;
760 static int symbuf_end;
761
762 /* Name of last function encountered.  Used in Solaris to approximate
763    object file boundaries.  */
764 static char *last_function_name;
765
766 /* The address in memory of the string table of the object file we are
767    reading (which might not be the "main" object file, but might be a
768    shared library or some other dynamically loaded thing).  This is
769    set by read_dbx_symtab when building psymtabs, and by
770    read_ofile_symtab when building symtabs, and is used only by
771    next_symbol_text.  FIXME: If that is true, we don't need it when
772    building psymtabs, right?  */
773 static char *stringtab_global;
774
775 /* These variables are used to control fill_symbuf when the stabs
776    symbols are not contiguous (as may be the case when a COFF file is
777    linked using --split-by-reloc).  */
778 static struct stab_section_list *symbuf_sections;
779 static unsigned int symbuf_left;
780 static unsigned int symbuf_read;
781
782 /* This variable stores a global stabs buffer, if we read stabs into
783    memory in one chunk in order to process relocations.  */
784 static bfd_byte *stabs_data;
785
786 /* Refill the symbol table input buffer
787    and set the variables that control fetching entries from it.
788    Reports an error if no data available.
789    This function can read past the end of the symbol table
790    (into the string table) but this does no harm.  */
791
792 static void
793 fill_symbuf (bfd *sym_bfd)
794 {
795   unsigned int count;
796   int nbytes;
797
798   if (stabs_data)
799     {
800       nbytes = sizeof (symbuf);
801       if (nbytes > symbuf_left)
802         nbytes = symbuf_left;
803       memcpy (symbuf, stabs_data + symbuf_read, nbytes);
804     }
805   else if (symbuf_sections == NULL)
806     {
807       count = sizeof (symbuf);
808       nbytes = bfd_bread (symbuf, count, sym_bfd);
809     }
810   else
811     {
812       if (symbuf_left <= 0)
813         {
814           file_ptr filepos = symbuf_sections->section->filepos;
815           if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
816             perror_with_name (bfd_get_filename (sym_bfd));
817           symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
818           symbol_table_offset = filepos - symbuf_read;
819           symbuf_sections = symbuf_sections->next;
820         }
821
822       count = symbuf_left;
823       if (count > sizeof (symbuf))
824         count = sizeof (symbuf);
825       nbytes = bfd_bread (symbuf, count, sym_bfd);
826     }
827
828   if (nbytes < 0)
829     perror_with_name (bfd_get_filename (sym_bfd));
830   else if (nbytes == 0)
831     error ("Premature end of file reading symbol table");
832   symbuf_end = nbytes / symbol_size;
833   symbuf_idx = 0;
834   symbuf_left -= nbytes;
835   symbuf_read += nbytes;
836 }
837
838 static void
839 stabs_seek (int sym_offset)
840 {
841   if (stabs_data)
842     {
843       symbuf_read += sym_offset;
844       symbuf_left -= sym_offset;
845     }
846   else
847     bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
848 }
849
850 #define INTERNALIZE_SYMBOL(intern, extern, abfd)                        \
851   {                                                                     \
852     (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type);             \
853     (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx);            \
854     (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc);            \
855     if (bfd_get_sign_extend_vma (abfd))                                 \
856       (intern).n_value = bfd_h_get_signed_32 (abfd, (extern)->e_value); \
857     else                                                                \
858       (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value);        \
859   }
860
861 /* Invariant: The symbol pointed to by symbuf_idx is the first one
862    that hasn't been swapped.  Swap the symbol at the same time
863    that symbuf_idx is incremented.  */
864
865 /* dbx allows the text of a symbol name to be continued into the
866    next symbol name!  When such a continuation is encountered
867    (a \ at the end of the text of a name)
868    call this function to get the continuation.  */
869
870 static char *
871 dbx_next_symbol_text (struct objfile *objfile)
872 {
873   struct internal_nlist nlist;
874
875   if (symbuf_idx == symbuf_end)
876     fill_symbuf (symfile_bfd);
877
878   symnum++;
879   INTERNALIZE_SYMBOL (nlist, &symbuf[symbuf_idx], symfile_bfd);
880   OBJSTAT (objfile, n_stabs++);
881
882   symbuf_idx++;
883
884   return nlist.n_strx + stringtab_global + file_string_table_offset;
885 }
886 \f
887 /* Initialize the list of bincls to contain none and have some
888    allocated.  */
889
890 static void
891 init_bincl_list (int number, struct objfile *objfile)
892 {
893   bincls_allocated = number;
894   next_bincl = bincl_list = (struct header_file_location *)
895     xmmalloc (objfile->md, bincls_allocated * sizeof (struct header_file_location));
896 }
897
898 /* Add a bincl to the list.  */
899
900 static void
901 add_bincl_to_list (struct partial_symtab *pst, char *name, int instance)
902 {
903   if (next_bincl >= bincl_list + bincls_allocated)
904     {
905       int offset = next_bincl - bincl_list;
906       bincls_allocated *= 2;
907       bincl_list = (struct header_file_location *)
908         xmrealloc (pst->objfile->md, (char *) bincl_list,
909                    bincls_allocated * sizeof (struct header_file_location));
910       next_bincl = bincl_list + offset;
911     }
912   next_bincl->pst = pst;
913   next_bincl->instance = instance;
914   next_bincl++->name = name;
915 }
916
917 /* Given a name, value pair, find the corresponding
918    bincl in the list.  Return the partial symtab associated
919    with that header_file_location.  */
920
921 static struct partial_symtab *
922 find_corresponding_bincl_psymtab (char *name, int instance)
923 {
924   struct header_file_location *bincl;
925
926   for (bincl = bincl_list; bincl < next_bincl; bincl++)
927     if (bincl->instance == instance
928         && strcmp (name, bincl->name) == 0)
929       return bincl->pst;
930
931   repeated_header_complaint (name, symnum);
932   return (struct partial_symtab *) 0;
933 }
934
935 /* Free the storage allocated for the bincl list.  */
936
937 static void
938 free_bincl_list (struct objfile *objfile)
939 {
940   xmfree (objfile->md, bincl_list);
941   bincls_allocated = 0;
942 }
943
944 static void
945 do_free_bincl_list_cleanup (void *objfile)
946 {
947   free_bincl_list (objfile);
948 }
949
950 static struct cleanup *
951 make_cleanup_free_bincl_list (struct objfile *objfile)
952 {
953   return make_cleanup (do_free_bincl_list_cleanup, objfile);
954 }
955
956 /* Set namestring based on nlist.  If the string table index is invalid, 
957    give a fake name, and print a single error message per symbol file read,
958    rather than abort the symbol reading or flood the user with messages.  */
959
960 static char *
961 set_namestring (struct objfile *objfile, struct internal_nlist nlist)
962 {
963   char *namestring;
964
965   if (((unsigned) nlist.n_strx + file_string_table_offset) >=
966       DBX_STRINGTAB_SIZE (objfile))
967     {
968       complaint (&symfile_complaints, "bad string table offset in symbol %d",
969                  symnum);
970       namestring = "<bad string table offset>";
971     } 
972   else
973     namestring = nlist.n_strx + file_string_table_offset +
974       DBX_STRINGTAB (objfile);
975   return namestring;
976 }
977
978 /* Scan a SunOs dynamic symbol table for symbols of interest and
979    add them to the minimal symbol table.  */
980
981 static void
982 read_dbx_dynamic_symtab (struct objfile *objfile)
983 {
984   bfd *abfd = objfile->obfd;
985   struct cleanup *back_to;
986   int counter;
987   long dynsym_size;
988   long dynsym_count;
989   asymbol **dynsyms;
990   asymbol **symptr;
991   arelent **relptr;
992   long dynrel_size;
993   long dynrel_count;
994   arelent **dynrels;
995   CORE_ADDR sym_value;
996   char *name;
997
998   /* Check that the symbol file has dynamic symbols that we know about.
999      bfd_arch_unknown can happen if we are reading a sun3 symbol file
1000      on a sun4 host (and vice versa) and bfd is not configured
1001      --with-target=all.  This would trigger an assertion in bfd/sunos.c,
1002      so we ignore the dynamic symbols in this case.  */
1003   if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
1004       || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
1005       || bfd_get_arch (abfd) == bfd_arch_unknown)
1006     return;
1007
1008   dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
1009   if (dynsym_size < 0)
1010     return;
1011
1012   dynsyms = (asymbol **) xmalloc (dynsym_size);
1013   back_to = make_cleanup (xfree, dynsyms);
1014
1015   dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
1016   if (dynsym_count < 0)
1017     {
1018       do_cleanups (back_to);
1019       return;
1020     }
1021
1022   /* Enter dynamic symbols into the minimal symbol table
1023      if this is a stripped executable.  */
1024   if (bfd_get_symcount (abfd) <= 0)
1025     {
1026       symptr = dynsyms;
1027       for (counter = 0; counter < dynsym_count; counter++, symptr++)
1028         {
1029           asymbol *sym = *symptr;
1030           asection *sec;
1031           int type;
1032
1033           sec = bfd_get_section (sym);
1034
1035           /* BFD symbols are section relative.  */
1036           sym_value = sym->value + sec->vma;
1037
1038           if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
1039             {
1040               sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1041               type = N_TEXT;
1042             }
1043           else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
1044             {
1045               sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
1046               type = N_DATA;
1047             }
1048           else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
1049             {
1050               sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
1051               type = N_BSS;
1052             }
1053           else
1054             continue;
1055
1056           if (sym->flags & BSF_GLOBAL)
1057             type |= N_EXT;
1058
1059           record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value,
1060                                  type, objfile);
1061         }
1062     }
1063
1064   /* Symbols from shared libraries have a dynamic relocation entry
1065      that points to the associated slot in the procedure linkage table.
1066      We make a mininal symbol table entry with type mst_solib_trampoline
1067      at the address in the procedure linkage table.  */
1068   dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
1069   if (dynrel_size < 0)
1070     {
1071       do_cleanups (back_to);
1072       return;
1073     }
1074
1075   dynrels = (arelent **) xmalloc (dynrel_size);
1076   make_cleanup (xfree, dynrels);
1077
1078   dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
1079   if (dynrel_count < 0)
1080     {
1081       do_cleanups (back_to);
1082       return;
1083     }
1084
1085   for (counter = 0, relptr = dynrels;
1086        counter < dynrel_count;
1087        counter++, relptr++)
1088     {
1089       arelent *rel = *relptr;
1090       CORE_ADDR address =
1091       rel->address + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
1092
1093       switch (bfd_get_arch (abfd))
1094         {
1095         case bfd_arch_sparc:
1096           if (rel->howto->type != RELOC_JMP_SLOT)
1097             continue;
1098           break;
1099         case bfd_arch_m68k:
1100           /* `16' is the type BFD produces for a jump table relocation.  */
1101           if (rel->howto->type != 16)
1102             continue;
1103
1104           /* Adjust address in the jump table to point to
1105              the start of the bsr instruction.  */
1106           address -= 2;
1107           break;
1108         default:
1109           continue;
1110         }
1111
1112       name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr);
1113       prim_record_minimal_symbol (name, address, mst_solib_trampoline,
1114                                   objfile);
1115     }
1116
1117   do_cleanups (back_to);
1118 }
1119
1120 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1121 static CORE_ADDR
1122 find_stab_function_addr (char *namestring, char *filename,
1123                          struct objfile *objfile)
1124 {
1125   struct minimal_symbol *msym;
1126   char *p;
1127   int n;
1128
1129   p = strchr (namestring, ':');
1130   if (p == NULL)
1131     p = namestring;
1132   n = p - namestring;
1133   p = alloca (n + 2);
1134   strncpy (p, namestring, n);
1135   p[n] = 0;
1136
1137   msym = lookup_minimal_symbol (p, filename, objfile);
1138   if (msym == NULL)
1139     {
1140       /* Sun Fortran appends an underscore to the minimal symbol name,
1141          try again with an appended underscore if the minimal symbol
1142          was not found.  */
1143       p[n] = '_';
1144       p[n + 1] = 0;
1145       msym = lookup_minimal_symbol (p, filename, objfile);
1146     }
1147
1148   if (msym == NULL && filename != NULL)
1149     {
1150       /* Try again without the filename. */
1151       p[n] = 0;
1152       msym = lookup_minimal_symbol (p, NULL, objfile);
1153     }
1154   if (msym == NULL && filename != NULL)
1155     {
1156       /* And try again for Sun Fortran, but without the filename. */
1157       p[n] = '_';
1158       p[n + 1] = 0;
1159       msym = lookup_minimal_symbol (p, NULL, objfile);
1160     }
1161
1162   return msym == NULL ? 0 : SYMBOL_VALUE_ADDRESS (msym);
1163 }
1164 #endif /* SOFUN_ADDRESS_MAYBE_MISSING */
1165
1166 static void
1167 function_outside_compilation_unit_complaint (const char *arg1)
1168 {
1169   complaint (&symfile_complaints,
1170              "function `%s' appears to be defined outside of all compilation units",
1171              arg1);
1172 }
1173
1174 /* Setup partial_symtab's describing each source file for which
1175    debugging information is available. */
1176
1177 static void
1178 read_dbx_symtab (struct objfile *objfile)
1179 {
1180   struct external_nlist *bufp = 0;      /* =0 avoids gcc -Wall glitch */
1181   struct internal_nlist nlist;
1182   CORE_ADDR text_addr;
1183   int text_size;
1184
1185   char *namestring;
1186   int nsl;
1187   int past_first_source_file = 0;
1188   CORE_ADDR last_o_file_start = 0;
1189   CORE_ADDR last_function_start = 0;
1190   struct cleanup *back_to;
1191   bfd *abfd;
1192   int textlow_not_set;
1193   int data_sect_index;
1194
1195   /* Current partial symtab */
1196   struct partial_symtab *pst;
1197
1198   /* List of current psymtab's include files */
1199   char **psymtab_include_list;
1200   int includes_allocated;
1201   int includes_used;
1202
1203   /* Index within current psymtab dependency list */
1204   struct partial_symtab **dependency_list;
1205   int dependencies_used, dependencies_allocated;
1206
1207   text_addr = DBX_TEXT_ADDR (objfile);
1208   text_size = DBX_TEXT_SIZE (objfile);
1209
1210   /* FIXME.  We probably want to change stringtab_global rather than add this
1211      while processing every symbol entry.  FIXME.  */
1212   file_string_table_offset = 0;
1213   next_file_string_table_offset = 0;
1214
1215   stringtab_global = DBX_STRINGTAB (objfile);
1216
1217   pst = (struct partial_symtab *) 0;
1218
1219   includes_allocated = 30;
1220   includes_used = 0;
1221   psymtab_include_list = (char **) alloca (includes_allocated *
1222                                            sizeof (char *));
1223
1224   dependencies_allocated = 30;
1225   dependencies_used = 0;
1226   dependency_list =
1227     (struct partial_symtab **) alloca (dependencies_allocated *
1228                                        sizeof (struct partial_symtab *));
1229
1230   /* Init bincl list */
1231   init_bincl_list (20, objfile);
1232   back_to = make_cleanup_free_bincl_list (objfile);
1233
1234   last_source_file = NULL;
1235
1236   lowest_text_address = (CORE_ADDR) -1;
1237
1238   symfile_bfd = objfile->obfd;  /* For next_text_symbol */
1239   abfd = objfile->obfd;
1240   symbuf_end = symbuf_idx = 0;
1241   next_symbol_text_func = dbx_next_symbol_text;
1242   textlow_not_set = 1;
1243   has_line_numbers = 0;
1244
1245   /* FIXME: jimb/2003-09-12: We don't apply the right section's offset
1246      to global and static variables.  The stab for a global or static
1247      variable doesn't give us any indication of which section it's in,
1248      so we can't tell immediately which offset in
1249      objfile->section_offsets we should apply to the variable's
1250      address.
1251
1252      We could certainly find out which section contains the variable
1253      by looking up the variable's unrelocated address with
1254      find_pc_section, but that would be expensive; this is the
1255      function that constructs the partial symbol tables by examining
1256      every symbol in the entire executable, and it's
1257      performance-critical.  So that expense would not be welcome.  I'm
1258      not sure what to do about this at the moment.
1259
1260      What we have done for years is to simply assume that the .data
1261      section's offset is appropriate for all global and static
1262      variables.  Recently, this was expanded to fall back to the .bss
1263      section's offset if there is no .data section, and then to the
1264      .rodata section's offset.  */
1265   data_sect_index = objfile->sect_index_data;
1266   if (data_sect_index == -1)
1267     data_sect_index = SECT_OFF_BSS (objfile);
1268   if (data_sect_index == -1)
1269     data_sect_index = SECT_OFF_RODATA (objfile);
1270
1271   /* If data_sect_index is still -1, that's okay.  It's perfectly fine
1272      for the file to have no .data, no .bss, and no .text at all, if
1273      it also has no global or static variables.  If it does, we will
1274      get an internal error from an ANOFFSET macro below when we try to
1275      use data_sect_index.  */
1276
1277   for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1278     {
1279       /* Get the symbol for this run and pull out some info */
1280       QUIT;                     /* allow this to be interruptable */
1281       if (symbuf_idx == symbuf_end)
1282         fill_symbuf (abfd);
1283       bufp = &symbuf[symbuf_idx++];
1284
1285       /*
1286        * Special case to speed up readin.
1287        */
1288       if (bfd_h_get_8 (abfd, bufp->e_type) == N_SLINE)
1289         {
1290           has_line_numbers = 1;
1291           continue;
1292         }
1293
1294       INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1295       OBJSTAT (objfile, n_stabs++);
1296
1297       /* Ok.  There is a lot of code duplicated in the rest of this
1298          switch statement (for efficiency reasons).  Since I don't
1299          like duplicating code, I will do my penance here, and
1300          describe the code which is duplicated:
1301
1302          *) The assignment to namestring.
1303          *) The call to strchr.
1304          *) The addition of a partial symbol the the two partial
1305          symbol lists.  This last is a large section of code, so
1306          I've imbedded it in the following macro.
1307       */
1308
1309       switch (nlist.n_type)
1310         {
1311           char *p;
1312           /*
1313            * Standard, external, non-debugger, symbols
1314            */
1315
1316           case N_TEXT | N_EXT:
1317           case N_NBTEXT | N_EXT:
1318           nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1319           goto record_it;
1320
1321           case N_DATA | N_EXT:
1322           case N_NBDATA | N_EXT:
1323           nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
1324           goto record_it;
1325
1326           case N_BSS:
1327           case N_BSS | N_EXT:
1328           case N_NBBSS | N_EXT:
1329           case N_SETV | N_EXT:          /* FIXME, is this in BSS? */
1330           nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
1331           goto record_it;
1332
1333           case N_ABS | N_EXT:
1334           record_it:
1335           namestring = set_namestring (objfile, nlist);
1336
1337           bss_ext_symbol:
1338           record_minimal_symbol (namestring, nlist.n_value,
1339                                  nlist.n_type, objfile);        /* Always */
1340           continue;
1341
1342           /* Standard, local, non-debugger, symbols */
1343
1344           case N_NBTEXT:
1345
1346           /* We need to be able to deal with both N_FN or N_TEXT,
1347              because we have no way of knowing whether the sys-supplied ld
1348              or GNU ld was used to make the executable.  Sequents throw
1349              in another wrinkle -- they renumbered N_FN.  */
1350
1351           case N_FN:
1352           case N_FN_SEQ:
1353           case N_TEXT:
1354           nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1355           namestring = set_namestring (objfile, nlist);
1356
1357           if ((namestring[0] == '-' && namestring[1] == 'l')
1358               || (namestring[(nsl = strlen (namestring)) - 1] == 'o'
1359                   && namestring[nsl - 2] == '.'))
1360           {
1361             if (past_first_source_file && pst
1362                 /* The gould NP1 uses low values for .o and -l symbols
1363                    which are not the address.  */
1364                 && nlist.n_value >= pst->textlow)
1365               {
1366                 end_psymtab (pst, psymtab_include_list, includes_used,
1367                              symnum * symbol_size,
1368                              nlist.n_value > pst->texthigh
1369                              ? nlist.n_value : pst->texthigh,
1370                              dependency_list, dependencies_used, textlow_not_set);
1371                 pst = (struct partial_symtab *) 0;
1372                 includes_used = 0;
1373                 dependencies_used = 0;
1374               }
1375             else
1376               past_first_source_file = 1;
1377             last_o_file_start = nlist.n_value;
1378           }
1379           else
1380           goto record_it;
1381           continue;
1382
1383           case N_DATA:
1384           nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
1385           goto record_it;
1386
1387           case N_UNDF | N_EXT:
1388           if (nlist.n_value != 0)
1389           {
1390             /* This is a "Fortran COMMON" symbol.  See if the target
1391                environment knows where it has been relocated to.  */
1392
1393             CORE_ADDR reladdr;
1394
1395             namestring = set_namestring (objfile, nlist);
1396             if (target_lookup_symbol (namestring, &reladdr))
1397               {
1398                 continue;               /* Error in lookup; ignore symbol for now.  */
1399               }
1400             nlist.n_type ^= (N_BSS ^ N_UNDF);   /* Define it as a bss-symbol */
1401             nlist.n_value = reladdr;
1402             goto bss_ext_symbol;
1403           }
1404           continue;                     /* Just undefined, not COMMON */
1405
1406           case N_UNDF:
1407           if (processing_acc_compilation && nlist.n_strx == 1)
1408           {
1409             /* Deal with relative offsets in the string table
1410                used in ELF+STAB under Solaris.  If we want to use the
1411                n_strx field, which contains the name of the file,
1412                we must adjust file_string_table_offset *before* calling
1413                set_namestring().  */
1414             past_first_source_file = 1;
1415             file_string_table_offset = next_file_string_table_offset;
1416             next_file_string_table_offset =
1417               file_string_table_offset + nlist.n_value;
1418             if (next_file_string_table_offset < file_string_table_offset)
1419               error ("string table offset backs up at %d", symnum);
1420             /* FIXME -- replace error() with complaint.  */
1421             continue;
1422           }
1423           continue;
1424
1425           /* Lots of symbol types we can just ignore.  */
1426
1427           case N_ABS:
1428           case N_NBDATA:
1429           case N_NBBSS:
1430           continue;
1431
1432           /* Keep going . . . */
1433
1434           /*
1435            * Special symbol types for GNU
1436            */
1437           case N_INDR:
1438           case N_INDR | N_EXT:
1439           case N_SETA:
1440           case N_SETA | N_EXT:
1441           case N_SETT:
1442           case N_SETT | N_EXT:
1443           case N_SETD:
1444           case N_SETD | N_EXT:
1445           case N_SETB:
1446           case N_SETB | N_EXT:
1447           case N_SETV:
1448           continue;
1449
1450           /*
1451            * Debugger symbols
1452            */
1453
1454           case N_SO:
1455           {
1456             CORE_ADDR valu;
1457             static int prev_so_symnum = -10;
1458             static int first_so_symnum;
1459             char *p;
1460             static char *dirname_nso;
1461             int prev_textlow_not_set;
1462
1463             valu = nlist.n_value + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1464
1465             prev_textlow_not_set = textlow_not_set;
1466
1467 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1468             /* A zero value is probably an indication for the SunPRO 3.0
1469                compiler. end_psymtab explicitly tests for zero, so
1470                don't relocate it.  */
1471
1472             if (nlist.n_value == 0)
1473               {
1474                 textlow_not_set = 1;
1475                 valu = 0;
1476               }
1477             else
1478               textlow_not_set = 0;
1479 #else
1480             textlow_not_set = 0;
1481 #endif
1482             past_first_source_file = 1;
1483
1484             if (prev_so_symnum != symnum - 1)
1485               {                 /* Here if prev stab wasn't N_SO */
1486                 first_so_symnum = symnum;
1487
1488                 if (pst)
1489                   {
1490                     end_psymtab (pst, psymtab_include_list, includes_used,
1491                                  symnum * symbol_size,
1492                                  valu > pst->texthigh ? valu : pst->texthigh,
1493                                  dependency_list, dependencies_used,
1494                                  prev_textlow_not_set);
1495                     pst = (struct partial_symtab *) 0;
1496                     includes_used = 0;
1497                     dependencies_used = 0;
1498                   }
1499               }
1500
1501             prev_so_symnum = symnum;
1502
1503             /* End the current partial symtab and start a new one */
1504
1505             namestring = set_namestring (objfile, nlist);
1506
1507             /* Null name means end of .o file.  Don't start a new one. */
1508             if (*namestring == '\000')
1509               continue;
1510
1511             /* Some compilers (including gcc) emit a pair of initial N_SOs.
1512                The first one is a directory name; the second the file name.
1513                If pst exists, is empty, and has a filename ending in '/',
1514                we assume the previous N_SO was a directory name. */
1515
1516             p = strrchr (namestring, '/');
1517             if (p && *(p + 1) == '\000')
1518               {
1519                 /* Save the directory name SOs locally, then save it into
1520                    the psymtab when it's created below. */
1521                 dirname_nso = namestring;
1522                 continue;               
1523               }
1524
1525             /* Some other compilers (C++ ones in particular) emit useless
1526                SOs for non-existant .c files.  We ignore all subsequent SOs that
1527                immediately follow the first.  */
1528
1529             if (!pst)
1530               {
1531               pst = start_psymtab (objfile,
1532                                    namestring, valu,
1533                                    first_so_symnum * symbol_size,
1534                                    objfile->global_psymbols.next,
1535                                    objfile->static_psymbols.next);
1536                 pst->dirname = dirname_nso;
1537                 dirname_nso = NULL;
1538               }
1539             continue;
1540           }
1541
1542           case N_BINCL:
1543           {
1544             enum language tmp_language;
1545             /* Add this bincl to the bincl_list for future EXCLs.  No
1546                need to save the string; it'll be around until
1547                read_dbx_symtab function returns */
1548
1549             namestring = set_namestring (objfile, nlist);
1550             tmp_language = deduce_language_from_filename (namestring);
1551
1552             /* Only change the psymtab's language if we've learned
1553                something useful (eg. tmp_language is not language_unknown).
1554                In addition, to match what start_subfile does, never change
1555                from C++ to C.  */
1556             if (tmp_language != language_unknown
1557                 && (tmp_language != language_c
1558                     || psymtab_language != language_cplus))
1559             psymtab_language = tmp_language;
1560
1561             if (pst == NULL)
1562             {
1563               /* FIXME: we should not get here without a PST to work on.
1564                  Attempt to recover.  */
1565               complaint (&symfile_complaints,
1566                          "N_BINCL %s not in entries for any file, at symtab pos %d",
1567                          namestring, symnum);
1568               continue;
1569             }
1570             add_bincl_to_list (pst, namestring, nlist.n_value);
1571
1572             /* Mark down an include file in the current psymtab */
1573
1574             goto record_include_file;
1575           }
1576
1577           case N_SOL:
1578           {
1579             enum language tmp_language;
1580             /* Mark down an include file in the current psymtab */
1581
1582             namestring = set_namestring (objfile, nlist);
1583             tmp_language = deduce_language_from_filename (namestring);
1584
1585             /* Only change the psymtab's language if we've learned
1586                something useful (eg. tmp_language is not language_unknown).
1587                In addition, to match what start_subfile does, never change
1588                from C++ to C.  */
1589             if (tmp_language != language_unknown
1590                 && (tmp_language != language_c
1591                     || psymtab_language != language_cplus))
1592             psymtab_language = tmp_language;
1593
1594             /* In C++, one may expect the same filename to come round many
1595                times, when code is coming alternately from the main file
1596                and from inline functions in other files. So I check to see
1597                if this is a file we've seen before -- either the main
1598                source file, or a previously included file.
1599
1600                This seems to be a lot of time to be spending on N_SOL, but
1601                things like "break c-exp.y:435" need to work (I
1602                suppose the psymtab_include_list could be hashed or put
1603                in a binary tree, if profiling shows this is a major hog).  */
1604             if (pst && strcmp (namestring, pst->filename) == 0)
1605             continue;
1606             {
1607               int i;
1608               for (i = 0; i < includes_used; i++)
1609                 if (strcmp (namestring, psymtab_include_list[i]) == 0)
1610                   {
1611                     i = -1;
1612                     break;
1613                   }
1614               if (i == -1)
1615                 continue;
1616             }
1617
1618             record_include_file:
1619
1620             psymtab_include_list[includes_used++] = namestring;
1621             if (includes_used >= includes_allocated)
1622             {
1623               char **orig = psymtab_include_list;
1624
1625               psymtab_include_list = (char **)
1626                 alloca ((includes_allocated *= 2) *
1627                         sizeof (char *));
1628               memcpy (psymtab_include_list, orig,
1629                       includes_used * sizeof (char *));
1630             }
1631             continue;
1632           }
1633           case N_LSYM:                  /* Typedef or automatic variable. */
1634           case N_STSYM:         /* Data seg var -- static  */
1635           case N_LCSYM:         /* BSS      "  */
1636           case N_ROSYM:         /* Read-only data seg var -- static.  */
1637           case N_NBSTS:         /* Gould nobase.  */
1638           case N_NBLCS:         /* symbols.  */
1639           case N_FUN:
1640           case N_GSYM:                  /* Global (extern) variable; can be
1641                                            data or bss (sigh FIXME).  */
1642
1643           /* Following may probably be ignored; I'll leave them here
1644              for now (until I do Pascal and Modula 2 extensions).  */
1645
1646           case N_PC:                    /* I may or may not need this; I
1647                                            suspect not.  */
1648           case N_M2C:                   /* I suspect that I can ignore this here. */
1649           case N_SCOPE:         /* Same.   */
1650
1651           namestring = set_namestring (objfile, nlist);
1652
1653           /* See if this is an end of function stab.  */
1654           if (pst && nlist.n_type == N_FUN && *namestring == '\000')
1655           {
1656             CORE_ADDR valu;
1657
1658             /* It's value is the size (in bytes) of the function for
1659                function relative stabs, or the address of the function's
1660                end for old style stabs.  */
1661             valu = nlist.n_value + last_function_start;
1662             if (pst->texthigh == 0 || valu > pst->texthigh)
1663               pst->texthigh = valu;
1664             break;
1665           }
1666
1667           p = (char *) strchr (namestring, ':');
1668           if (!p)
1669           continue;                     /* Not a debugging symbol.   */
1670
1671
1672
1673           /* Main processing section for debugging symbols which
1674              the initial read through the symbol tables needs to worry
1675              about.  If we reach this point, the symbol which we are
1676              considering is definitely one we are interested in.
1677              p must also contain the (valid) index into the namestring
1678              which indicates the debugging type symbol.  */
1679
1680           switch (p[1])
1681           {
1682           case 'S':
1683             nlist.n_value += ANOFFSET (objfile->section_offsets, data_sect_index);
1684 #ifdef STATIC_TRANSFORM_NAME
1685             namestring = STATIC_TRANSFORM_NAME (namestring);
1686 #endif
1687             add_psymbol_to_list (namestring, p - namestring,
1688                                  VAR_DOMAIN, LOC_STATIC,
1689                                  &objfile->static_psymbols,
1690                                  0, nlist.n_value,
1691                                  psymtab_language, objfile);
1692             continue;
1693           case 'G':
1694             nlist.n_value += ANOFFSET (objfile->section_offsets, data_sect_index);
1695             /* The addresses in these entries are reported to be
1696                wrong.  See the code that reads 'G's for symtabs. */
1697             add_psymbol_to_list (namestring, p - namestring,
1698                                  VAR_DOMAIN, LOC_STATIC,
1699                                  &objfile->global_psymbols,
1700                                  0, nlist.n_value,
1701                                  psymtab_language, objfile);
1702             continue;
1703
1704           case 'T':
1705             /* When a 'T' entry is defining an anonymous enum, it
1706                may have a name which is the empty string, or a
1707                single space.  Since they're not really defining a
1708                symbol, those shouldn't go in the partial symbol
1709                table.  We do pick up the elements of such enums at
1710                'check_enum:', below.  */
1711             if (p >= namestring + 2
1712                 || (p == namestring + 1
1713                     && namestring[0] != ' '))
1714               {
1715                 add_psymbol_to_list (namestring, p - namestring,
1716                                      STRUCT_DOMAIN, LOC_TYPEDEF,
1717                                      &objfile->static_psymbols,
1718                                      nlist.n_value, 0,
1719                                      psymtab_language, objfile);
1720                 if (p[2] == 't')
1721                   {
1722                     /* Also a typedef with the same name.  */
1723                     add_psymbol_to_list (namestring, p - namestring,
1724                                          VAR_DOMAIN, LOC_TYPEDEF,
1725                                          &objfile->static_psymbols,
1726                                          nlist.n_value, 0,
1727                                          psymtab_language, objfile);
1728                     p += 1;
1729                   }
1730               }
1731             goto check_enum;
1732           case 't':
1733             if (p != namestring)        /* a name is there, not just :T... */
1734               {
1735                 add_psymbol_to_list (namestring, p - namestring,
1736                                      VAR_DOMAIN, LOC_TYPEDEF,
1737                                      &objfile->static_psymbols,
1738                                      nlist.n_value, 0,
1739                                      psymtab_language, objfile);
1740               }
1741           check_enum:
1742             /* If this is an enumerated type, we need to
1743                add all the enum constants to the partial symbol
1744                table.  This does not cover enums without names, e.g.
1745                "enum {a, b} c;" in C, but fortunately those are
1746                rare.  There is no way for GDB to find those from the
1747                enum type without spending too much time on it.  Thus
1748                to solve this problem, the compiler needs to put out the
1749                enum in a nameless type.  GCC2 does this.  */
1750
1751             /* We are looking for something of the form
1752                <name> ":" ("t" | "T") [<number> "="] "e"
1753                {<constant> ":" <value> ","} ";".  */
1754
1755             /* Skip over the colon and the 't' or 'T'.  */
1756             p += 2;
1757             /* This type may be given a number.  Also, numbers can come
1758                in pairs like (0,26).  Skip over it.  */
1759             while ((*p >= '0' && *p <= '9')
1760                    || *p == '(' || *p == ',' || *p == ')'
1761                    || *p == '=')
1762               p++;
1763
1764             if (*p++ == 'e')
1765               {
1766                 /* The aix4 compiler emits extra crud before the members.  */
1767                 if (*p == '-')
1768                   {
1769                     /* Skip over the type (?).  */
1770                     while (*p != ':')
1771                       p++;
1772
1773                     /* Skip over the colon.  */
1774                     p++;
1775                   }
1776
1777                 /* We have found an enumerated type.  */
1778                 /* According to comments in read_enum_type
1779                    a comma could end it instead of a semicolon.
1780                    I don't know where that happens.
1781                    Accept either.  */
1782                 while (*p && *p != ';' && *p != ',')
1783                   {
1784                     char *q;
1785
1786                     /* Check for and handle cretinous dbx symbol name
1787                        continuation!  */
1788                     if (*p == '\\' || (*p == '?' && p[1] == '\0'))
1789                       p = next_symbol_text (objfile);
1790
1791                     /* Point to the character after the name
1792                        of the enum constant.  */
1793                     for (q = p; *q && *q != ':'; q++)
1794                       ;
1795                     /* Note that the value doesn't matter for
1796                        enum constants in psymtabs, just in symtabs.  */
1797                     add_psymbol_to_list (p, q - p,
1798                                          VAR_DOMAIN, LOC_CONST,
1799                                          &objfile->static_psymbols, 0,
1800                                          0, psymtab_language, objfile);
1801                     /* Point past the name.  */
1802                     p = q;
1803                     /* Skip over the value.  */
1804                     while (*p && *p != ',')
1805                       p++;
1806                     /* Advance past the comma.  */
1807                     if (*p)
1808                       p++;
1809                   }
1810               }
1811             continue;
1812           case 'c':
1813             /* Constant, e.g. from "const" in Pascal.  */
1814             add_psymbol_to_list (namestring, p - namestring,
1815                                  VAR_DOMAIN, LOC_CONST,
1816                                  &objfile->static_psymbols, nlist.n_value,
1817                                  0, psymtab_language, objfile);
1818             continue;
1819
1820           case 'f':
1821             if (! pst)
1822               {
1823                 int name_len = p - namestring;
1824                 char *name = xmalloc (name_len + 1);
1825                 memcpy (name, namestring, name_len);
1826                 name[name_len] = '\0';
1827                 function_outside_compilation_unit_complaint (name);
1828                 xfree (name);
1829               }
1830             nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1831             /* Kludges for ELF/STABS with Sun ACC */
1832             last_function_name = namestring;
1833 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1834             /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
1835                value for the bottom of the text seg in those cases. */
1836             if (nlist.n_value == ANOFFSET (objfile->section_offsets, 
1837                                            SECT_OFF_TEXT (objfile)))
1838               {
1839                 CORE_ADDR minsym_valu = 
1840                   find_stab_function_addr (namestring, pst->filename, objfile);
1841                 /* find_stab_function_addr will return 0 if the minimal
1842                    symbol wasn't found.  (Unfortunately, this might also
1843                    be a valid address.)  Anyway, if it *does* return 0,
1844                    it is likely that the value was set correctly to begin
1845                    with... */
1846                 if (minsym_valu != 0)
1847                   nlist.n_value = minsym_valu;
1848               }
1849             if (pst && textlow_not_set)
1850               {
1851                 pst->textlow = nlist.n_value;
1852                 textlow_not_set = 0;
1853               }
1854 #endif
1855             /* End kludge.  */
1856
1857             /* Keep track of the start of the last function so we
1858                can handle end of function symbols.  */
1859             last_function_start = nlist.n_value;
1860
1861             /* In reordered executables this function may lie outside
1862                the bounds created by N_SO symbols.  If that's the case
1863                use the address of this function as the low bound for
1864                the partial symbol table.  */
1865             if (pst
1866                 && (textlow_not_set
1867                     || (nlist.n_value < pst->textlow
1868                         && (nlist.n_value
1869                             != ANOFFSET (objfile->section_offsets,
1870                                          SECT_OFF_TEXT (objfile))))))
1871               {
1872                 pst->textlow = nlist.n_value;
1873                 textlow_not_set = 0;
1874               }
1875             add_psymbol_to_list (namestring, p - namestring,
1876                                  VAR_DOMAIN, LOC_BLOCK,
1877                                  &objfile->static_psymbols,
1878                                  0, nlist.n_value,
1879                                  psymtab_language, objfile);
1880             continue;
1881
1882             /* Global functions were ignored here, but now they
1883                are put into the global psymtab like one would expect.
1884                They're also in the minimal symbol table.  */
1885           case 'F':
1886             if (! pst)
1887               {
1888                 int name_len = p - namestring;
1889                 char *name = xmalloc (name_len + 1);
1890                 memcpy (name, namestring, name_len);
1891                 name[name_len] = '\0';
1892                 function_outside_compilation_unit_complaint (name);
1893                 xfree (name);
1894               }
1895             nlist.n_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1896             /* Kludges for ELF/STABS with Sun ACC */
1897             last_function_name = namestring;
1898 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1899             /* Do not fix textlow==0 for .o or NLM files, as 0 is a legit
1900                value for the bottom of the text seg in those cases. */
1901             if (nlist.n_value == ANOFFSET (objfile->section_offsets, 
1902                                            SECT_OFF_TEXT (objfile)))
1903               {
1904                 CORE_ADDR minsym_valu = 
1905                   find_stab_function_addr (namestring, pst->filename, objfile);
1906                 /* find_stab_function_addr will return 0 if the minimal
1907                    symbol wasn't found.  (Unfortunately, this might also
1908                    be a valid address.)  Anyway, if it *does* return 0,
1909                    it is likely that the value was set correctly to begin
1910                    with... */
1911                 if (minsym_valu != 0)
1912                   nlist.n_value = minsym_valu;
1913               }
1914             if (pst && textlow_not_set)
1915               {
1916                 pst->textlow = nlist.n_value;
1917                 textlow_not_set = 0;
1918               }
1919 #endif
1920             /* End kludge.  */
1921
1922             /* Keep track of the start of the last function so we
1923                can handle end of function symbols.  */
1924             last_function_start = nlist.n_value;
1925
1926             /* In reordered executables this function may lie outside
1927                the bounds created by N_SO symbols.  If that's the case
1928                use the address of this function as the low bound for
1929                the partial symbol table.  */
1930             if (pst
1931                 && (textlow_not_set
1932                     || (nlist.n_value < pst->textlow
1933                         && (nlist.n_value
1934                             != ANOFFSET (objfile->section_offsets,
1935                                          SECT_OFF_TEXT (objfile))))))
1936               {
1937                 pst->textlow = nlist.n_value;
1938                 textlow_not_set = 0;
1939               }
1940             add_psymbol_to_list (namestring, p - namestring,
1941                                  VAR_DOMAIN, LOC_BLOCK,
1942                                  &objfile->global_psymbols,
1943                                  0, nlist.n_value,
1944                                  psymtab_language, objfile);
1945             continue;
1946
1947             /* Two things show up here (hopefully); static symbols of
1948                local scope (static used inside braces) or extensions
1949                of structure symbols.  We can ignore both.  */
1950           case 'V':
1951           case '(':
1952           case '0':
1953           case '1':
1954           case '2':
1955           case '3':
1956           case '4':
1957           case '5':
1958           case '6':
1959           case '7':
1960           case '8':
1961           case '9':
1962           case '-':
1963           case '#':             /* for symbol identification (used in live ranges) */
1964             continue;
1965
1966           case ':':
1967             /* It is a C++ nested symbol.  We don't need to record it
1968                (I don't think); if we try to look up foo::bar::baz,
1969                then symbols for the symtab containing foo should get
1970                read in, I think.  */
1971             /* Someone says sun cc puts out symbols like
1972                /foo/baz/maclib::/usr/local/bin/maclib,
1973                which would get here with a symbol type of ':'.  */
1974             continue;
1975
1976           default:
1977             /* Unexpected symbol descriptor.  The second and subsequent stabs
1978                of a continued stab can show up here.  The question is
1979                whether they ever can mimic a normal stab--it would be
1980                nice if not, since we certainly don't want to spend the
1981                time searching to the end of every string looking for
1982                a backslash.  */
1983
1984             complaint (&symfile_complaints, "unknown symbol descriptor `%c'",
1985                        p[1]);
1986
1987             /* Ignore it; perhaps it is an extension that we don't
1988                know about.  */
1989             continue;
1990           }
1991
1992           case N_EXCL:
1993
1994           namestring = set_namestring (objfile, nlist);
1995
1996           /* Find the corresponding bincl and mark that psymtab on the
1997              psymtab dependency list */
1998           {
1999             struct partial_symtab *needed_pst =
2000               find_corresponding_bincl_psymtab (namestring, nlist.n_value);
2001
2002             /* If this include file was defined earlier in this file,
2003                leave it alone.  */
2004             if (needed_pst == pst)
2005               continue;
2006
2007             if (needed_pst)
2008               {
2009                 int i;
2010                 int found = 0;
2011
2012                 for (i = 0; i < dependencies_used; i++)
2013                   if (dependency_list[i] == needed_pst)
2014                     {
2015                       found = 1;
2016                       break;
2017                     }
2018
2019                 /* If it's already in the list, skip the rest.  */
2020                 if (found)
2021                   continue;
2022
2023                 dependency_list[dependencies_used++] = needed_pst;
2024                 if (dependencies_used >= dependencies_allocated)
2025                   {
2026                     struct partial_symtab **orig = dependency_list;
2027                     dependency_list =
2028                       (struct partial_symtab **)
2029                       alloca ((dependencies_allocated *= 2)
2030                               * sizeof (struct partial_symtab *));
2031                     memcpy (dependency_list, orig,
2032                             (dependencies_used
2033                              * sizeof (struct partial_symtab *)));
2034 #ifdef DEBUG_INFO
2035                     fprintf_unfiltered (gdb_stderr, "Had to reallocate dependency list.\n");
2036                     fprintf_unfiltered (gdb_stderr, "New dependencies allocated: %d\n",
2037                                         dependencies_allocated);
2038 #endif
2039                   }
2040               }
2041           }
2042           continue;
2043
2044           case N_ENDM:
2045 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2046           /* Solaris 2 end of module, finish current partial symbol table.
2047              end_psymtab will set pst->texthigh to the proper value, which
2048              is necessary if a module compiled without debugging info
2049              follows this module.  */
2050           if (pst)
2051           {
2052             end_psymtab (pst, psymtab_include_list, includes_used,
2053                          symnum * symbol_size,
2054                          (CORE_ADDR) 0,
2055                          dependency_list, dependencies_used, textlow_not_set);
2056             pst = (struct partial_symtab *) 0;
2057             includes_used = 0;
2058             dependencies_used = 0;
2059           }
2060 #endif
2061           continue;
2062
2063           case N_RBRAC:
2064 #ifdef HANDLE_RBRAC
2065           HANDLE_RBRAC (nlist.n_value);
2066           continue;
2067 #endif
2068           case N_EINCL:
2069           case N_DSLINE:
2070           case N_BSLINE:
2071           case N_SSYM:                  /* Claim: Structure or union element.
2072                                            Hopefully, I can ignore this.  */
2073           case N_ENTRY:         /* Alternate entry point; can ignore. */
2074           case N_MAIN:                  /* Can definitely ignore this.   */
2075           case N_CATCH:         /* These are GNU C++ extensions */
2076           case N_EHDECL:                /* that can safely be ignored here. */
2077           case N_LENG:
2078           case N_BCOMM:
2079           case N_ECOMM:
2080           case N_ECOML:
2081           case N_FNAME:
2082           case N_SLINE:
2083           case N_RSYM:
2084           case N_PSYM:
2085           case N_LBRAC:
2086           case N_NSYMS:         /* Ultrix 4.0: symbol count */
2087           case N_DEFD:                  /* GNU Modula-2 */
2088           case N_ALIAS:         /* SunPro F77: alias name, ignore for now.  */
2089
2090           case N_OBJ:                   /* useless types from Solaris */
2091           case N_OPT:
2092           case N_PATCH:
2093           /* These symbols aren't interesting; don't worry about them */
2094
2095           continue;
2096
2097           default:
2098           /* If we haven't found it yet, ignore it.  It's probably some
2099              new type we don't know about yet.  */
2100           unknown_symtype_complaint (local_hex_string (nlist.n_type));
2101           continue;
2102         }
2103     }
2104
2105   /* If there's stuff to be cleaned up, clean it up.  */
2106   if (pst)
2107     {
2108       /* Don't set pst->texthigh lower than it already is.  */
2109       CORE_ADDR text_end =
2110         (lowest_text_address == (CORE_ADDR) -1
2111          ? (text_addr + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)))
2112          : lowest_text_address)
2113         + text_size;
2114
2115       end_psymtab (pst, psymtab_include_list, includes_used,
2116                    symnum * symbol_size,
2117                    text_end > pst->texthigh ? text_end : pst->texthigh,
2118                    dependency_list, dependencies_used, textlow_not_set);
2119     }
2120
2121   do_cleanups (back_to);
2122 }
2123
2124 /* Allocate and partially fill a partial symtab.  It will be
2125    completely filled at the end of the symbol list.
2126
2127    SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2128    is the address relative to which its symbols are (incremental) or 0
2129    (normal). */
2130
2131
2132 static struct partial_symtab *
2133 start_psymtab (struct objfile *objfile, char *filename, CORE_ADDR textlow,
2134                int ldsymoff, struct partial_symbol **global_syms,
2135                struct partial_symbol **static_syms)
2136 {
2137   struct partial_symtab *result =
2138   start_psymtab_common (objfile, objfile->section_offsets,
2139                         filename, textlow, global_syms, static_syms);
2140
2141   result->read_symtab_private = (char *)
2142     obstack_alloc (&objfile->objfile_obstack, sizeof (struct symloc));
2143   LDSYMOFF (result) = ldsymoff;
2144   result->read_symtab = dbx_psymtab_to_symtab;
2145   SYMBOL_SIZE (result) = symbol_size;
2146   SYMBOL_OFFSET (result) = symbol_table_offset;
2147   STRING_OFFSET (result) = string_table_offset;
2148   FILE_STRING_OFFSET (result) = file_string_table_offset;
2149
2150   /* If we're handling an ELF file, drag some section-relocation info
2151      for this source file out of the ELF symbol table, to compensate for
2152      Sun brain death.  This replaces the section_offsets in this psymtab,
2153      if successful.  */
2154   elfstab_offset_sections (objfile, result);
2155
2156   /* Deduce the source language from the filename for this psymtab. */
2157   psymtab_language = deduce_language_from_filename (filename);
2158
2159   return result;
2160 }
2161
2162 /* Close off the current usage of PST.  
2163    Returns PST or NULL if the partial symtab was empty and thrown away.
2164
2165    FIXME:  List variables and peculiarities of same.  */
2166
2167 struct partial_symtab *
2168 end_psymtab (struct partial_symtab *pst, char **include_list, int num_includes,
2169              int capping_symbol_offset, CORE_ADDR capping_text,
2170              struct partial_symtab **dependency_list, int number_dependencies,
2171              int textlow_not_set)
2172 {
2173   int i;
2174   struct objfile *objfile = pst->objfile;
2175
2176   if (capping_symbol_offset != -1)
2177     LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
2178   pst->texthigh = capping_text;
2179
2180 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2181   /* Under Solaris, the N_SO symbols always have a value of 0,
2182      instead of the usual address of the .o file.  Therefore,
2183      we have to do some tricks to fill in texthigh and textlow.
2184      The first trick is: if we see a static
2185      or global function, and the textlow for the current pst
2186      is not set (ie: textlow_not_set), then we use that function's
2187      address for the textlow of the pst.  */
2188
2189   /* Now, to fill in texthigh, we remember the last function seen
2190      in the .o file.  Also, there's a hack in
2191      bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
2192      to here via the misc_info field.  Therefore, we can fill in
2193      a reliable texthigh by taking the address plus size of the
2194      last function in the file.  */
2195
2196   if (pst->texthigh == 0 && last_function_name)
2197     {
2198       char *p;
2199       int n;
2200       struct minimal_symbol *minsym;
2201
2202       p = strchr (last_function_name, ':');
2203       if (p == NULL)
2204         p = last_function_name;
2205       n = p - last_function_name;
2206       p = alloca (n + 2);
2207       strncpy (p, last_function_name, n);
2208       p[n] = 0;
2209
2210       minsym = lookup_minimal_symbol (p, pst->filename, objfile);
2211       if (minsym == NULL)
2212         {
2213           /* Sun Fortran appends an underscore to the minimal symbol name,
2214              try again with an appended underscore if the minimal symbol
2215              was not found.  */
2216           p[n] = '_';
2217           p[n + 1] = 0;
2218           minsym = lookup_minimal_symbol (p, pst->filename, objfile);
2219         }
2220
2221       if (minsym)
2222         pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
2223
2224       last_function_name = NULL;
2225     }
2226
2227   /* this test will be true if the last .o file is only data */
2228   if (textlow_not_set)
2229     pst->textlow = pst->texthigh;
2230   else
2231     {
2232       struct partial_symtab *p1;
2233
2234       /* If we know our own starting text address, then walk through all other
2235          psymtabs for this objfile, and if any didn't know their ending text
2236          address, set it to our starting address.  Take care to not set our
2237          own ending address to our starting address, nor to set addresses on
2238          `dependency' files that have both textlow and texthigh zero.  */
2239
2240       ALL_OBJFILE_PSYMTABS (objfile, p1)
2241       {
2242         if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst)
2243           {
2244             p1->texthigh = pst->textlow;
2245             /* if this file has only data, then make textlow match texthigh */
2246             if (p1->textlow == 0)
2247               p1->textlow = p1->texthigh;
2248           }
2249       }
2250     }
2251
2252   /* End of kludge for patching Solaris textlow and texthigh.  */
2253 #endif /* SOFUN_ADDRESS_MAYBE_MISSING.  */
2254
2255   pst->n_global_syms =
2256     objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
2257   pst->n_static_syms =
2258     objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
2259
2260   pst->number_of_dependencies = number_dependencies;
2261   if (number_dependencies)
2262     {
2263       pst->dependencies = (struct partial_symtab **)
2264         obstack_alloc (&objfile->objfile_obstack,
2265                     number_dependencies * sizeof (struct partial_symtab *));
2266       memcpy (pst->dependencies, dependency_list,
2267               number_dependencies * sizeof (struct partial_symtab *));
2268     }
2269   else
2270     pst->dependencies = 0;
2271
2272   for (i = 0; i < num_includes; i++)
2273     {
2274       struct partial_symtab *subpst =
2275       allocate_psymtab (include_list[i], objfile);
2276
2277       /* Copy the sesction_offsets array from the main psymtab. */
2278       subpst->section_offsets = pst->section_offsets;
2279       subpst->read_symtab_private =
2280         (char *) obstack_alloc (&objfile->objfile_obstack,
2281                                 sizeof (struct symloc));
2282       LDSYMOFF (subpst) =
2283         LDSYMLEN (subpst) =
2284         subpst->textlow =
2285         subpst->texthigh = 0;
2286
2287       /* We could save slight bits of space by only making one of these,
2288          shared by the entire set of include files.  FIXME-someday.  */
2289       subpst->dependencies = (struct partial_symtab **)
2290         obstack_alloc (&objfile->objfile_obstack,
2291                        sizeof (struct partial_symtab *));
2292       subpst->dependencies[0] = pst;
2293       subpst->number_of_dependencies = 1;
2294
2295       subpst->globals_offset =
2296         subpst->n_global_syms =
2297         subpst->statics_offset =
2298         subpst->n_static_syms = 0;
2299
2300       subpst->readin = 0;
2301       subpst->symtab = 0;
2302       subpst->read_symtab = pst->read_symtab;
2303     }
2304
2305   sort_pst_symbols (pst);
2306
2307   /* If there is already a psymtab or symtab for a file of this name, remove it.
2308      (If there is a symtab, more drastic things also happen.)
2309      This happens in VxWorks.  */
2310   free_named_symtabs (pst->filename);
2311
2312   if (num_includes == 0
2313       && number_dependencies == 0
2314       && pst->n_global_syms == 0
2315       && pst->n_static_syms == 0
2316       && has_line_numbers == 0)
2317     {
2318       /* Throw away this psymtab, it's empty.  We can't deallocate it, since
2319          it is on the obstack, but we can forget to chain it on the list.  */
2320       /* Empty psymtabs happen as a result of header files which don't have
2321          any symbols in them.  There can be a lot of them.  But this check
2322          is wrong, in that a psymtab with N_SLINE entries but nothing else
2323          is not empty, but we don't realize that.  Fixing that without slowing
2324          things down might be tricky.  */
2325
2326       discard_psymtab (pst);
2327
2328       /* Indicate that psymtab was thrown away.  */
2329       pst = (struct partial_symtab *) NULL;
2330     }
2331   return pst;
2332 }
2333 \f
2334 static void
2335 dbx_psymtab_to_symtab_1 (struct partial_symtab *pst)
2336 {
2337   struct cleanup *old_chain;
2338   int i;
2339
2340   if (!pst)
2341     return;
2342
2343   if (pst->readin)
2344     {
2345       fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
2346                           pst->filename);
2347       return;
2348     }
2349
2350   /* Read in all partial symtabs on which this one is dependent */
2351   for (i = 0; i < pst->number_of_dependencies; i++)
2352     if (!pst->dependencies[i]->readin)
2353       {
2354         /* Inform about additional files that need to be read in.  */
2355         if (info_verbose)
2356           {
2357             fputs_filtered (" ", gdb_stdout);
2358             wrap_here ("");
2359             fputs_filtered ("and ", gdb_stdout);
2360             wrap_here ("");
2361             printf_filtered ("%s...", pst->dependencies[i]->filename);
2362             wrap_here ("");     /* Flush output */
2363             gdb_flush (gdb_stdout);
2364           }
2365         dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
2366       }
2367
2368   if (LDSYMLEN (pst))           /* Otherwise it's a dummy */
2369     {
2370       /* Init stuff necessary for reading in symbols */
2371       stabsread_init ();
2372       buildsym_init ();
2373       old_chain = make_cleanup (really_free_pendings, 0);
2374       file_string_table_offset = FILE_STRING_OFFSET (pst);
2375       symbol_size = SYMBOL_SIZE (pst);
2376
2377       /* Read in this file's symbols */
2378       bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
2379       read_ofile_symtab (pst);
2380
2381       do_cleanups (old_chain);
2382     }
2383
2384   pst->readin = 1;
2385 }
2386
2387 /* Read in all of the symbols for a given psymtab for real.
2388    Be verbose about it if the user wants that.  */
2389
2390 static void
2391 dbx_psymtab_to_symtab (struct partial_symtab *pst)
2392 {
2393   bfd *sym_bfd;
2394   struct cleanup *back_to = NULL;
2395
2396   if (!pst)
2397     return;
2398
2399   if (pst->readin)
2400     {
2401       fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in.  Shouldn't happen.\n",
2402                           pst->filename);
2403       return;
2404     }
2405
2406   if (LDSYMLEN (pst) || pst->number_of_dependencies)
2407     {
2408       /* Print the message now, before reading the string table,
2409          to avoid disconcerting pauses.  */
2410       if (info_verbose)
2411         {
2412           printf_filtered ("Reading in symbols for %s...", pst->filename);
2413           gdb_flush (gdb_stdout);
2414         }
2415
2416       sym_bfd = pst->objfile->obfd;
2417
2418       next_symbol_text_func = dbx_next_symbol_text;
2419
2420       if (DBX_STAB_SECTION (pst->objfile))
2421         {
2422           stabs_data
2423             = symfile_relocate_debug_section (pst->objfile->obfd,
2424                                               DBX_STAB_SECTION (pst->objfile),
2425                                               NULL);
2426           if (stabs_data)
2427             back_to = make_cleanup (free_current_contents, (void *) &stabs_data);
2428         }
2429
2430       dbx_psymtab_to_symtab_1 (pst);
2431
2432       if (back_to)
2433         do_cleanups (back_to);
2434
2435       /* Match with global symbols.  This only needs to be done once,
2436          after all of the symtabs and dependencies have been read in.   */
2437       scan_file_globals (pst->objfile);
2438
2439       /* Finish up the debug error message.  */
2440       if (info_verbose)
2441         printf_filtered ("done.\n");
2442     }
2443 }
2444
2445 /* Read in a defined section of a specific object file's symbols. */
2446
2447 static void
2448 read_ofile_symtab (struct partial_symtab *pst)
2449 {
2450   char *namestring;
2451   struct external_nlist *bufp;
2452   struct internal_nlist nlist;
2453   unsigned char type;
2454   unsigned max_symnum;
2455   bfd *abfd;
2456   struct objfile *objfile;
2457   int sym_offset;               /* Offset to start of symbols to read */
2458   int sym_size;                 /* Size of symbols to read */
2459   CORE_ADDR text_offset;        /* Start of text segment for symbols */
2460   int text_size;                /* Size of text segment for symbols */
2461   struct section_offsets *section_offsets;
2462
2463   objfile = pst->objfile;
2464   sym_offset = LDSYMOFF (pst);
2465   sym_size = LDSYMLEN (pst);
2466   text_offset = pst->textlow;
2467   text_size = pst->texthigh - pst->textlow;
2468   /* This cannot be simply objfile->section_offsets because of
2469      elfstab_offset_sections() which initializes the psymtab section
2470      offsets information in a special way, and that is different from
2471      objfile->section_offsets. */ 
2472   section_offsets = pst->section_offsets;
2473
2474   current_objfile = objfile;
2475   subfile_stack = NULL;
2476
2477   stringtab_global = DBX_STRINGTAB (objfile);
2478   last_source_file = NULL;
2479
2480   abfd = objfile->obfd;
2481   symfile_bfd = objfile->obfd;  /* Implicit param to next_text_symbol */
2482   symbuf_end = symbuf_idx = 0;
2483   symbuf_read = 0;
2484   symbuf_left = sym_offset + sym_size;
2485
2486   /* It is necessary to actually read one symbol *before* the start
2487      of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
2488      occurs before the N_SO symbol.
2489
2490      Detecting this in read_dbx_symtab
2491      would slow down initial readin, so we look for it here instead.  */
2492   if (!processing_acc_compilation && sym_offset >= (int) symbol_size)
2493     {
2494       stabs_seek (sym_offset - symbol_size);
2495       fill_symbuf (abfd);
2496       bufp = &symbuf[symbuf_idx++];
2497       INTERNALIZE_SYMBOL (nlist, bufp, abfd);
2498       OBJSTAT (objfile, n_stabs++);
2499
2500       namestring = set_namestring (objfile, nlist);
2501
2502       processing_gcc_compilation = 0;
2503       if (nlist.n_type == N_TEXT)
2504         {
2505           const char *tempstring = namestring;
2506
2507           if (DEPRECATED_STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
2508             processing_gcc_compilation = 1;
2509           else if (DEPRECATED_STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
2510             processing_gcc_compilation = 2;
2511           if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
2512             ++tempstring;
2513           if (DEPRECATED_STREQN (tempstring, "__gnu_compiled", 14))
2514             processing_gcc_compilation = 2;
2515         }
2516
2517       /* Try to select a C++ demangling based on the compilation unit
2518          producer. */
2519
2520 #if 0
2521       /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
2522          know whether it will use the old style or v3 mangling.  */
2523       if (processing_gcc_compilation)
2524         {
2525           if (AUTO_DEMANGLING)
2526             {
2527               set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
2528             }
2529         }
2530 #endif
2531     }
2532   else
2533     {
2534       /* The N_SO starting this symtab is the first symbol, so we
2535          better not check the symbol before it.  I'm not this can
2536          happen, but it doesn't hurt to check for it.  */
2537       stabs_seek (sym_offset);
2538       processing_gcc_compilation = 0;
2539     }
2540
2541   if (symbuf_idx == symbuf_end)
2542     fill_symbuf (abfd);
2543   bufp = &symbuf[symbuf_idx];
2544   if (bfd_h_get_8 (abfd, bufp->e_type) != N_SO)
2545     error ("First symbol in segment of executable not a source symbol");
2546
2547   max_symnum = sym_size / symbol_size;
2548
2549   for (symnum = 0;
2550        symnum < max_symnum;
2551        symnum++)
2552     {
2553       QUIT;                     /* Allow this to be interruptable */
2554       if (symbuf_idx == symbuf_end)
2555         fill_symbuf (abfd);
2556       bufp = &symbuf[symbuf_idx++];
2557       INTERNALIZE_SYMBOL (nlist, bufp, abfd);
2558       OBJSTAT (objfile, n_stabs++);
2559
2560       type = bfd_h_get_8 (abfd, bufp->e_type);
2561
2562       namestring = set_namestring (objfile, nlist);
2563
2564       if (type & N_STAB)
2565         {
2566           process_one_symbol (type, nlist.n_desc, nlist.n_value,
2567                               namestring, section_offsets, objfile);
2568         }
2569       /* We skip checking for a new .o or -l file; that should never
2570          happen in this routine. */
2571       else if (type == N_TEXT)
2572         {
2573           /* I don't think this code will ever be executed, because
2574              the GCC_COMPILED_FLAG_SYMBOL usually is right before
2575              the N_SO symbol which starts this source file.
2576              However, there is no reason not to accept
2577              the GCC_COMPILED_FLAG_SYMBOL anywhere.  */
2578
2579           if (DEPRECATED_STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
2580             processing_gcc_compilation = 1;
2581           else if (DEPRECATED_STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
2582             processing_gcc_compilation = 2;
2583
2584 #if 0
2585           /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
2586              know whether it will use the old style or v3 mangling.  */
2587           if (AUTO_DEMANGLING)
2588             {
2589               set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
2590             }
2591 #endif
2592         }
2593       else if (type & N_EXT || type == (unsigned char) N_TEXT
2594                || type == (unsigned char) N_NBTEXT
2595         )
2596         {
2597           /* Global symbol: see if we came across a dbx defintion for
2598              a corresponding symbol.  If so, store the value.  Remove
2599              syms from the chain when their values are stored, but
2600              search the whole chain, as there may be several syms from
2601              different files with the same name. */
2602           /* This is probably not true.  Since the files will be read
2603              in one at a time, each reference to a global symbol will
2604              be satisfied in each file as it appears. So we skip this
2605              section. */
2606           ;
2607         }
2608     }
2609
2610   current_objfile = NULL;
2611
2612   /* In a Solaris elf file, this variable, which comes from the
2613      value of the N_SO symbol, will still be 0.  Luckily, text_offset,
2614      which comes from pst->textlow is correct. */
2615   if (last_source_start_addr == 0)
2616     last_source_start_addr = text_offset;
2617
2618   /* In reordered executables last_source_start_addr may not be the
2619      lower bound for this symtab, instead use text_offset which comes
2620      from pst->textlow which is correct.  */
2621   if (last_source_start_addr > text_offset)
2622     last_source_start_addr = text_offset;
2623
2624   pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
2625
2626   end_stabs ();
2627 }
2628 \f
2629
2630 /* This handles a single symbol from the symbol-file, building symbols
2631    into a GDB symtab.  It takes these arguments and an implicit argument.
2632
2633    TYPE is the type field of the ".stab" symbol entry.
2634    DESC is the desc field of the ".stab" entry.
2635    VALU is the value field of the ".stab" entry.
2636    NAME is the symbol name, in our address space.
2637    SECTION_OFFSETS is a set of amounts by which the sections of this object
2638    file were relocated when it was loaded into memory.
2639    Note that these section_offsets are not the 
2640    objfile->section_offsets but the pst->section_offsets.
2641    All symbols that refer
2642    to memory locations need to be offset by these amounts.
2643    OBJFILE is the object file from which we are reading symbols.
2644    It is used in end_symtab.  */
2645
2646 void
2647 process_one_symbol (int type, int desc, CORE_ADDR valu, char *name,
2648                     struct section_offsets *section_offsets,
2649                     struct objfile *objfile)
2650 {
2651   struct context_stack *new;
2652   /* This remembers the address of the start of a function.  It is used
2653      because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
2654      relative to the current function's start address.  On systems
2655      other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
2656      used to relocate these symbol types rather than SECTION_OFFSETS.  */
2657   static CORE_ADDR function_start_offset;
2658
2659   /* This holds the address of the start of a function, without the system
2660      peculiarities of function_start_offset.  */
2661   static CORE_ADDR last_function_start;
2662
2663   /* If this is nonzero, we've seen an N_SLINE since the start of the
2664      current function.  We use this to tell us to move the first sline
2665      to the beginning of the function regardless of what its given
2666      value is. */
2667   static int sline_found_in_function = 1;
2668
2669   /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
2670      file.  Used to detect the SunPRO solaris compiler.  */
2671   static int n_opt_found;
2672
2673   /* The stab type used for the definition of the last function.
2674      N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers.  */
2675   static int function_stab_type = 0;
2676
2677   if (!block_address_function_relative)
2678     /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
2679        function start address, so just use the text offset.  */
2680     function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2681
2682   /* Something is wrong if we see real data before
2683      seeing a source file name.  */
2684
2685   if (last_source_file == NULL && type != (unsigned char) N_SO)
2686     {
2687       /* Ignore any symbols which appear before an N_SO symbol.
2688          Currently no one puts symbols there, but we should deal
2689          gracefully with the case.  A complain()t might be in order,
2690          but this should not be an error ().  */
2691       return;
2692     }
2693
2694   switch (type)
2695     {
2696     case N_FUN:
2697     case N_FNAME:
2698
2699       if (*name == '\000')
2700         {
2701           /* This N_FUN marks the end of a function.  This closes off the
2702              current block.  */
2703
2704           if (context_stack_depth <= 0)
2705             {
2706               lbrac_mismatch_complaint (symnum);
2707               break;
2708             }
2709
2710           /* The following check is added before recording line 0 at
2711              end of function so as to handle hand-generated stabs
2712              which may have an N_FUN stabs at the end of the function, but
2713              no N_SLINE stabs.  */
2714           if (sline_found_in_function)
2715             record_line (current_subfile, 0, last_function_start + valu);
2716
2717           within_function = 0;
2718           new = pop_context ();
2719
2720           /* Make a block for the local symbols within.  */
2721           finish_block (new->name, &local_symbols, new->old_blocks,
2722                         new->start_addr, new->start_addr + valu,
2723                         objfile);
2724
2725           /* May be switching to an assembler file which may not be using
2726              block relative stabs, so reset the offset.  */
2727           if (block_address_function_relative)
2728             function_start_offset = 0;
2729
2730           break;
2731         }
2732
2733       sline_found_in_function = 0;
2734
2735       /* Relocate for dynamic loading */
2736       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2737       valu = SMASH_TEXT_ADDRESS (valu);
2738       last_function_start = valu;
2739
2740       goto define_a_symbol;
2741
2742     case N_LBRAC:
2743       /* This "symbol" just indicates the start of an inner lexical
2744          context within a function.  */
2745
2746       /* Ignore extra outermost context from SunPRO cc and acc.  */
2747       if (n_opt_found && desc == 1)
2748         break;
2749
2750       if (block_address_function_relative)
2751         /* Relocate for Sun ELF acc fn-relative syms.  */
2752         valu += function_start_offset;
2753       else
2754         /* On most machines, the block addresses are relative to the
2755            N_SO, the linker did not relocate them (sigh).  */
2756         valu += last_source_start_addr;
2757
2758       new = push_context (desc, valu);
2759       break;
2760
2761     case N_RBRAC:
2762       /* This "symbol" just indicates the end of an inner lexical
2763          context that was started with N_LBRAC.  */
2764
2765       /* Ignore extra outermost context from SunPRO cc and acc.  */
2766       if (n_opt_found && desc == 1)
2767         break;
2768
2769       if (block_address_function_relative)
2770         /* Relocate for Sun ELF acc fn-relative syms.  */
2771         valu += function_start_offset;
2772       else
2773         /* On most machines, the block addresses are relative to the
2774            N_SO, the linker did not relocate them (sigh).  */
2775         valu += last_source_start_addr;
2776
2777       if (context_stack_depth <= 0)
2778         {
2779           lbrac_mismatch_complaint (symnum);
2780           break;
2781         }
2782
2783       new = pop_context ();
2784       if (desc != new->depth)
2785         lbrac_mismatch_complaint (symnum);
2786
2787       /* Some compilers put the variable decls inside of an
2788          LBRAC/RBRAC block.  This macro should be nonzero if this
2789          is true.  DESC is N_DESC from the N_RBRAC symbol.
2790          GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2791          or the GCC2_COMPILED_SYMBOL.  */
2792 #if !defined (VARIABLES_INSIDE_BLOCK)
2793 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2794 #endif
2795
2796       /* Can only use new->locals as local symbols here if we're in
2797          gcc or on a machine that puts them before the lbrack.  */
2798       if (!VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation))
2799         {
2800           if (local_symbols != NULL)
2801             {
2802               /* GCC development snapshots from March to December of
2803                  2000 would output N_LSYM entries after N_LBRAC
2804                  entries.  As a consequence, these symbols are simply
2805                  discarded.  Complain if this is the case.  Note that
2806                  there are some compilers which legitimately put local
2807                  symbols within an LBRAC/RBRAC block; this complaint
2808                  might also help sort out problems in which
2809                  VARIABLES_INSIDE_BLOCK is incorrectly defined.  */
2810               complaint (&symfile_complaints,
2811                          "misplaced N_LBRAC entry; discarding local symbols which have no enclosing block");
2812             }
2813           local_symbols = new->locals;
2814         }
2815
2816       if (context_stack_depth
2817           > !VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation))
2818         {
2819           /* This is not the outermost LBRAC...RBRAC pair in the function,
2820              its local symbols preceded it, and are the ones just recovered
2821              from the context stack.  Define the block for them (but don't
2822              bother if the block contains no symbols.  Should we complain
2823              on blocks without symbols?  I can't think of any useful purpose
2824              for them).  */
2825           if (local_symbols != NULL)
2826             {
2827               /* Muzzle a compiler bug that makes end < start.  (which
2828                  compilers?  Is this ever harmful?).  */
2829               if (new->start_addr > valu)
2830                 {
2831                   complaint (&symfile_complaints,
2832                              "block start larger than block end");
2833                   new->start_addr = valu;
2834                 }
2835               /* Make a block for the local symbols within.  */
2836               finish_block (0, &local_symbols, new->old_blocks,
2837                             new->start_addr, valu, objfile);
2838             }
2839         }
2840       else
2841         {
2842           /* This is the outermost LBRAC...RBRAC pair.  There is no
2843              need to do anything; leave the symbols that preceded it
2844              to be attached to the function's own block.  We need to
2845              indicate that we just moved outside of the function.  */
2846           within_function = 0;
2847         }
2848
2849       if (VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation))
2850         /* Now pop locals of block just finished.  */
2851         local_symbols = new->locals;
2852       break;
2853
2854     case N_FN:
2855     case N_FN_SEQ:
2856       /* This kind of symbol indicates the start of an object file.  */
2857       /* Relocate for dynamic loading */
2858       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2859       break;
2860
2861     case N_SO:
2862       /* This type of symbol indicates the start of data
2863          for one source file.
2864          Finish the symbol table of the previous source file
2865          (if any) and start accumulating a new symbol table.  */
2866       /* Relocate for dynamic loading */
2867       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2868
2869       n_opt_found = 0;
2870
2871 #ifdef PCC_SOL_BROKEN
2872       /* pcc bug, occasionally puts out SO for SOL.  */
2873       if (context_stack_depth > 0)
2874         {
2875           start_subfile (name, NULL);
2876           break;
2877         }
2878 #endif
2879       if (last_source_file)
2880         {
2881           /* Check if previous symbol was also an N_SO (with some
2882              sanity checks).  If so, that one was actually the directory
2883              name, and the current one is the real file name.
2884              Patch things up. */
2885           if (previous_stab_code == (unsigned char) N_SO)
2886             {
2887               patch_subfile_names (current_subfile, name);
2888               break;            /* Ignore repeated SOs */
2889             }
2890           end_symtab (valu, objfile, SECT_OFF_TEXT (objfile));
2891           end_stabs ();
2892         }
2893
2894       /* Null name means this just marks the end of text for this .o file.
2895          Don't start a new symtab in this case.  */
2896       if (*name == '\000')
2897         break;
2898
2899       if (block_address_function_relative)
2900         function_start_offset = 0;
2901
2902       start_stabs ();
2903       start_symtab (name, NULL, valu);
2904       record_debugformat ("stabs");
2905       break;
2906
2907     case N_SOL:
2908       /* This type of symbol indicates the start of data for
2909          a sub-source-file, one whose contents were copied or
2910          included in the compilation of the main source file
2911          (whose name was given in the N_SO symbol.)  */
2912       /* Relocate for dynamic loading */
2913       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2914       start_subfile (name, current_subfile->dirname);
2915       break;
2916
2917     case N_BINCL:
2918       push_subfile ();
2919       add_new_header_file (name, valu);
2920       start_subfile (name, current_subfile->dirname);
2921       break;
2922
2923     case N_EINCL:
2924       start_subfile (pop_subfile (), current_subfile->dirname);
2925       break;
2926
2927     case N_EXCL:
2928       add_old_header_file (name, valu);
2929       break;
2930
2931     case N_SLINE:
2932       /* This type of "symbol" really just records
2933          one line-number -- core-address correspondence.
2934          Enter it in the line list for this symbol table.  */
2935
2936       /* Relocate for dynamic loading and for ELF acc fn-relative syms.  */
2937       valu += function_start_offset;
2938
2939       /* If this is the first SLINE note in the function, record it at
2940          the start of the function instead of at the listed location.  */
2941       if (within_function && sline_found_in_function == 0)
2942         {
2943           record_line (current_subfile, desc, last_function_start);
2944           sline_found_in_function = 1;
2945         }
2946       else
2947         record_line (current_subfile, desc, valu);
2948       break;
2949
2950     case N_BCOMM:
2951       common_block_start (name, objfile);
2952       break;
2953
2954     case N_ECOMM:
2955       common_block_end (objfile);
2956       break;
2957
2958       /* The following symbol types need to have the appropriate offset added
2959          to their value; then we process symbol definitions in the name.  */
2960
2961     case N_STSYM:               /* Static symbol in data seg */
2962     case N_LCSYM:               /* Static symbol in BSS seg */
2963     case N_ROSYM:               /* Static symbol in Read-only data seg */
2964       /* HORRID HACK DEPT.  However, it's Sun's furgin' fault.
2965          Solaris2's stabs-in-elf makes *most* symbols relative
2966          but leaves a few absolute (at least for Solaris 2.1 and version
2967          2.0.1 of the SunPRO compiler).  N_STSYM and friends sit on the fence.
2968          .stab "foo:S...",N_STSYM        is absolute (ld relocates it)
2969          .stab "foo:V...",N_STSYM        is relative (section base subtracted).
2970          This leaves us no choice but to search for the 'S' or 'V'...
2971          (or pass the whole section_offsets stuff down ONE MORE function
2972          call level, which we really don't want to do).  */
2973       {
2974         char *p;
2975
2976         /* .o files and NLMs have non-zero text seg offsets, but don't need
2977            their static syms offset in this fashion.  XXX - This is really a
2978            crock that should be fixed in the solib handling code so that I
2979            don't have to work around it here. */
2980
2981         if (!symfile_relocatable)
2982           {
2983             p = strchr (name, ':');
2984             if (p != 0 && p[1] == 'S')
2985               {
2986                 /* The linker relocated it.  We don't want to add an
2987                    elfstab_offset_sections-type offset, but we *do* want
2988                    to add whatever solib.c passed to symbol_file_add as
2989                    addr (this is known to affect SunOS4, and I suspect ELF
2990                    too).  Since elfstab_offset_sections currently does not
2991                    muck with the text offset (there is no Ttext.text
2992                    symbol), we can get addr from the text offset.  If
2993                    elfstab_offset_sections ever starts dealing with the
2994                    text offset, and we still need to do this, we need to
2995                    invent a SECT_OFF_ADDR_KLUDGE or something.  */
2996                 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2997                 goto define_a_symbol;
2998               }
2999           }
3000         /* Since it's not the kludge case, re-dispatch to the right handler. */
3001         switch (type)
3002           {
3003           case N_STSYM:
3004             goto case_N_STSYM;
3005           case N_LCSYM:
3006             goto case_N_LCSYM;
3007           case N_ROSYM:
3008             goto case_N_ROSYM;
3009           default:
3010             internal_error (__FILE__, __LINE__, "failed internal consistency check");
3011           }
3012       }
3013
3014     case_N_STSYM:               /* Static symbol in data seg */
3015     case N_DSLINE:              /* Source line number, data seg */
3016       valu += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
3017       goto define_a_symbol;
3018
3019     case_N_LCSYM:               /* Static symbol in BSS seg */
3020     case N_BSLINE:              /* Source line number, bss seg */
3021       /*   N_BROWS:       overlaps with N_BSLINE */
3022       valu += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
3023       goto define_a_symbol;
3024
3025     case_N_ROSYM:               /* Static symbol in Read-only data seg */
3026       valu += ANOFFSET (section_offsets, SECT_OFF_RODATA (objfile));
3027       goto define_a_symbol;
3028
3029     case N_ENTRY:               /* Alternate entry point */
3030       /* Relocate for dynamic loading */
3031       valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
3032       goto define_a_symbol;
3033
3034       /* The following symbol types we don't know how to process.  Handle
3035          them in a "default" way, but complain to people who care.  */
3036     default:
3037     case N_CATCH:               /* Exception handler catcher */
3038     case N_EHDECL:              /* Exception handler name */
3039     case N_PC:                  /* Global symbol in Pascal */
3040     case N_M2C:         /* Modula-2 compilation unit */
3041       /*   N_MOD2:        overlaps with N_EHDECL */
3042     case N_SCOPE:               /* Modula-2 scope information */
3043     case N_ECOML:               /* End common (local name) */
3044     case N_NBTEXT:              /* Gould Non-Base-Register symbols??? */
3045     case N_NBDATA:
3046     case N_NBBSS:
3047     case N_NBSTS:
3048     case N_NBLCS:
3049       unknown_symtype_complaint (local_hex_string (type));
3050       /* FALLTHROUGH */
3051
3052       /* The following symbol types don't need the address field relocated,
3053          since it is either unused, or is absolute.  */
3054     define_a_symbol:
3055     case N_GSYM:                /* Global variable */
3056     case N_NSYMS:               /* Number of symbols (ultrix) */
3057     case N_NOMAP:               /* No map?  (ultrix) */
3058     case N_RSYM:                /* Register variable */
3059     case N_DEFD:                /* Modula-2 GNU module dependency */
3060     case N_SSYM:                /* Struct or union element */
3061     case N_LSYM:                /* Local symbol in stack */
3062     case N_PSYM:                /* Parameter variable */
3063     case N_LENG:                /* Length of preceding symbol type */
3064       if (name)
3065         {
3066           int deftype;
3067           char *colon_pos = strchr (name, ':');
3068           if (colon_pos == NULL)
3069             deftype = '\0';
3070           else
3071             deftype = colon_pos[1];
3072
3073           switch (deftype)
3074             {
3075             case 'f':
3076             case 'F':
3077               function_stab_type = type;
3078
3079 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
3080               /* Deal with the SunPRO 3.0 compiler which omits the address
3081                  from N_FUN symbols.  */
3082               if (type == N_FUN
3083                   && valu == ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)))
3084                 {
3085                   CORE_ADDR minsym_valu = 
3086                     find_stab_function_addr (name, last_source_file, objfile);
3087
3088                   /* find_stab_function_addr will return 0 if the minimal
3089                      symbol wasn't found.  (Unfortunately, this might also
3090                      be a valid address.)  Anyway, if it *does* return 0,
3091                      it is likely that the value was set correctly to begin
3092                      with... */
3093                   if (minsym_valu != 0)
3094                     valu = minsym_valu;
3095                 }
3096 #endif
3097
3098               if (block_address_function_relative)
3099                 /* For Solaris 2.0 compilers, the block addresses and
3100                    N_SLINE's are relative to the start of the
3101                    function.  On normal systems, and when using gcc on
3102                    Solaris 2.0, these addresses are just absolute, or
3103                    relative to the N_SO, depending on
3104                    BLOCK_ADDRESS_ABSOLUTE.  */
3105                 function_start_offset = valu;
3106
3107               within_function = 1;
3108
3109               if (context_stack_depth > 1)
3110                 {
3111                   complaint (&symfile_complaints,
3112                              "unmatched N_LBRAC before symtab pos %d", symnum);
3113                   break;
3114                 }
3115
3116               if (context_stack_depth > 0)
3117                 {
3118                   new = pop_context ();
3119                   /* Make a block for the local symbols within.  */
3120                   finish_block (new->name, &local_symbols, new->old_blocks,
3121                                 new->start_addr, valu, objfile);
3122                 }
3123
3124               new = push_context (0, valu);
3125               new->name = define_symbol (valu, name, desc, type, objfile);
3126               break;
3127
3128             default:
3129               define_symbol (valu, name, desc, type, objfile);
3130               break;
3131             }
3132         }
3133       break;
3134
3135       /* We use N_OPT to carry the gcc2_compiled flag.  Sun uses it
3136          for a bunch of other flags, too.  Someday we may parse their
3137          flags; for now we ignore theirs and hope they'll ignore ours.  */
3138     case N_OPT:         /* Solaris 2:  Compiler options */
3139       if (name)
3140         {
3141           if (strcmp (name, GCC2_COMPILED_FLAG_SYMBOL) == 0)
3142             {
3143               processing_gcc_compilation = 2;
3144 #if 0                           /* Works, but is experimental.  -fnf */
3145               /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
3146                  know whether it will use the old style or v3 mangling.  */
3147               if (AUTO_DEMANGLING)
3148                 {
3149                   set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
3150                 }
3151 #endif
3152             }
3153           else
3154             n_opt_found = 1;
3155         }
3156       break;
3157
3158     case N_MAIN:                /* Name of main routine.  */
3159       /* FIXME: If one has a symbol file with N_MAIN and then replaces
3160          it with a symbol file with "main" and without N_MAIN.  I'm
3161          not sure exactly what rule to follow but probably something
3162          like: N_MAIN takes precedence over "main" no matter what
3163          objfile it is in; If there is more than one N_MAIN, choose
3164          the one in the symfile_objfile; If there is more than one
3165          N_MAIN within a given objfile, complain() and choose
3166          arbitrarily. (kingdon) */
3167       if (name != NULL)
3168         set_main_name (name);
3169       break;
3170
3171       /* The following symbol types can be ignored.  */
3172     case N_OBJ:         /* Solaris 2:  Object file dir and name */
3173     case N_PATCH:       /* Solaris2: Patch Run Time Checker.  */
3174       /*   N_UNDF:                   Solaris 2:  file separator mark */
3175       /*   N_UNDF: -- we will never encounter it, since we only process one
3176          file's symbols at once.  */
3177     case N_ENDM:                /* Solaris 2:  End of module */
3178     case N_ALIAS:               /* SunPro F77: alias name, ignore for now.  */
3179       break;
3180     }
3181
3182   /* '#' is a GNU C extension to allow one symbol to refer to another
3183      related symbol.
3184
3185      Generally this is used so that an alias can refer to its main
3186      symbol.  */
3187   if (name[0] == '#')
3188     {
3189       /* Initialize symbol reference names and determine if this is 
3190          a definition.  If symbol reference is being defined, go 
3191          ahead and add it.  Otherwise, just return sym. */
3192
3193       char *s = name;
3194       int refnum;
3195
3196       /* If this stab defines a new reference ID that is not on the
3197          reference list, then put it on the reference list.
3198
3199          We go ahead and advance NAME past the reference, even though
3200          it is not strictly necessary at this time.  */
3201       refnum = symbol_reference_defined (&s);
3202       if (refnum >= 0)
3203         if (!ref_search (refnum))
3204           ref_add (refnum, 0, name, valu);
3205       name = s;
3206     }
3207
3208
3209   previous_stab_code = type;
3210 }
3211 \f
3212 /* FIXME: The only difference between this and elfstab_build_psymtabs
3213    is the call to install_minimal_symbols for elf, and the support for
3214    split sections.  If the differences are really that small, the code
3215    should be shared.  */
3216
3217 /* Scan and build partial symbols for an coff symbol file.
3218    The coff file has already been processed to get its minimal symbols.
3219
3220    This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3221    rolled into one.
3222
3223    OBJFILE is the object file we are reading symbols from.
3224    ADDR is the address relative to which the symbols are (e.g.
3225    the base address of the text segment).
3226    MAINLINE is true if we are reading the main symbol
3227    table (as opposed to a shared lib or dynamically loaded file).
3228    TEXTADDR is the address of the text section.
3229    TEXTSIZE is the size of the text section.
3230    STABSECTS is the list of .stab sections in OBJFILE.
3231    STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
3232    .stabstr section exists.
3233
3234    This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
3235    adjusted for coff details. */
3236
3237 void
3238 coffstab_build_psymtabs (struct objfile *objfile, int mainline,
3239                          CORE_ADDR textaddr, unsigned int textsize,
3240                          struct stab_section_list *stabsects,
3241                          file_ptr stabstroffset, unsigned int stabstrsize)
3242 {
3243   int val;
3244   bfd *sym_bfd = objfile->obfd;
3245   char *name = bfd_get_filename (sym_bfd);
3246   struct dbx_symfile_info *info;
3247   unsigned int stabsize;
3248
3249   /* There is already a dbx_symfile_info allocated by our caller.
3250      It might even contain some info from the coff symtab to help us.  */
3251   info = objfile->sym_stab_info;
3252
3253   DBX_TEXT_ADDR (objfile) = textaddr;
3254   DBX_TEXT_SIZE (objfile) = textsize;
3255
3256 #define COFF_STABS_SYMBOL_SIZE  12      /* XXX FIXME XXX */
3257   DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE;
3258   DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
3259
3260   if (stabstrsize > bfd_get_size (sym_bfd))
3261     error ("ridiculous string table size: %d bytes", stabstrsize);
3262   DBX_STRINGTAB (objfile) = (char *)
3263     obstack_alloc (&objfile->objfile_obstack, stabstrsize + 1);
3264   OBJSTAT (objfile, sz_strtab += stabstrsize + 1);
3265
3266   /* Now read in the string table in one big gulp.  */
3267
3268   val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
3269   if (val < 0)
3270     perror_with_name (name);
3271   val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
3272   if (val != stabstrsize)
3273     perror_with_name (name);
3274
3275   stabsread_new_init ();
3276   buildsym_new_init ();
3277   free_header_files ();
3278   init_header_files ();
3279
3280   processing_acc_compilation = 1;
3281
3282   /* In a coff file, we've already installed the minimal symbols that came
3283      from the coff (non-stab) symbol table, so always act like an
3284      incremental load here. */
3285   if (stabsects->next == NULL)
3286     {
3287       stabsize = bfd_section_size (sym_bfd, stabsects->section);
3288       DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
3289       DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
3290     }
3291   else
3292     {
3293       struct stab_section_list *stabsect;
3294
3295       DBX_SYMCOUNT (objfile) = 0;
3296       for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
3297         {
3298           stabsize = bfd_section_size (sym_bfd, stabsect->section);
3299           DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
3300         }
3301
3302       DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
3303
3304       symbuf_sections = stabsects->next;
3305       symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
3306       symbuf_read = 0;
3307     }
3308
3309   dbx_symfile_read (objfile, 0);
3310 }
3311 \f
3312 /* Scan and build partial symbols for an ELF symbol file.
3313    This ELF file has already been processed to get its minimal symbols.
3314
3315    This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3316    rolled into one.
3317
3318    OBJFILE is the object file we are reading symbols from.
3319    ADDR is the address relative to which the symbols are (e.g.
3320    the base address of the text segment).
3321    MAINLINE is true if we are reading the main symbol
3322    table (as opposed to a shared lib or dynamically loaded file).
3323    STABSECT is the BFD section information for the .stab section.
3324    STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
3325    .stabstr section exists.
3326
3327    This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
3328    adjusted for elf details. */
3329
3330 void
3331 elfstab_build_psymtabs (struct objfile *objfile, int mainline,
3332                         asection *stabsect,
3333                         file_ptr stabstroffset, unsigned int stabstrsize)
3334 {
3335   int val;
3336   bfd *sym_bfd = objfile->obfd;
3337   char *name = bfd_get_filename (sym_bfd);
3338   struct dbx_symfile_info *info;
3339   struct cleanup *back_to = NULL;
3340
3341   /* There is already a dbx_symfile_info allocated by our caller.
3342      It might even contain some info from the ELF symtab to help us.  */
3343   info = objfile->sym_stab_info;
3344
3345   /* Find the first and last text address.  dbx_symfile_read seems to
3346      want this.  */
3347   find_text_range (sym_bfd, objfile);
3348
3349 #define ELF_STABS_SYMBOL_SIZE   12      /* XXX FIXME XXX */
3350   DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
3351   DBX_SYMCOUNT (objfile)
3352     = bfd_section_size (objfile->obfd, stabsect) / DBX_SYMBOL_SIZE (objfile);
3353   DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
3354   DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos;
3355   DBX_STAB_SECTION (objfile) = stabsect;
3356
3357   if (stabstrsize > bfd_get_size (sym_bfd))
3358     error ("ridiculous string table size: %d bytes", stabstrsize);
3359   DBX_STRINGTAB (objfile) = (char *)
3360     obstack_alloc (&objfile->objfile_obstack, stabstrsize + 1);
3361   OBJSTAT (objfile, sz_strtab += stabstrsize + 1);
3362
3363   /* Now read in the string table in one big gulp.  */
3364
3365   val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
3366   if (val < 0)
3367     perror_with_name (name);
3368   val = bfd_bread (DBX_STRINGTAB (objfile), stabstrsize, sym_bfd);
3369   if (val != stabstrsize)
3370     perror_with_name (name);
3371
3372   stabsread_new_init ();
3373   buildsym_new_init ();
3374   free_header_files ();
3375   init_header_files ();
3376
3377   processing_acc_compilation = 1;
3378
3379   symbuf_read = 0;
3380   symbuf_left = bfd_section_size (objfile->obfd, stabsect);
3381   stabs_data = symfile_relocate_debug_section (objfile->obfd, stabsect, NULL);
3382   if (stabs_data)
3383     back_to = make_cleanup (free_current_contents, (void *) &stabs_data);
3384
3385   /* In an elf file, we've already installed the minimal symbols that came
3386      from the elf (non-stab) symbol table, so always act like an
3387      incremental load here.  dbx_symfile_read should not generate any new
3388      minimal symbols, since we will have already read the ELF dynamic symbol
3389      table and normal symbol entries won't be in the ".stab" section; but in
3390      case it does, it will install them itself.  */
3391   dbx_symfile_read (objfile, 0);
3392
3393   if (back_to)
3394     do_cleanups (back_to);
3395 }
3396 \f
3397 /* Scan and build partial symbols for a file with special sections for stabs
3398    and stabstrings.  The file has already been processed to get its minimal
3399    symbols, and any other symbols that might be necessary to resolve GSYMs.
3400
3401    This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
3402    rolled into one.
3403
3404    OBJFILE is the object file we are reading symbols from.
3405    ADDR is the address relative to which the symbols are (e.g. the base address
3406    of the text segment).
3407    MAINLINE is true if we are reading the main symbol table (as opposed to a
3408    shared lib or dynamically loaded file).
3409    STAB_NAME is the name of the section that contains the stabs.
3410    STABSTR_NAME is the name of the section that contains the stab strings.
3411
3412    This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
3413
3414 void
3415 stabsect_build_psymtabs (struct objfile *objfile, int mainline, char *stab_name,
3416                          char *stabstr_name, char *text_name)
3417 {
3418   int val;
3419   bfd *sym_bfd = objfile->obfd;
3420   char *name = bfd_get_filename (sym_bfd);
3421   asection *stabsect;
3422   asection *stabstrsect;
3423   asection *text_sect;
3424
3425   stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
3426   stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
3427
3428   if (!stabsect)
3429     return;
3430
3431   if (!stabstrsect)
3432     error ("stabsect_build_psymtabs:  Found stabs (%s), but not string section (%s)",
3433            stab_name, stabstr_name);
3434
3435   objfile->sym_stab_info = (struct dbx_symfile_info *)
3436     xmalloc (sizeof (struct dbx_symfile_info));
3437   memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
3438
3439   text_sect = bfd_get_section_by_name (sym_bfd, text_name);
3440   if (!text_sect)
3441     error ("Can't find %s section in symbol file", text_name);
3442   DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
3443   DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
3444
3445   DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
3446   DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
3447     / DBX_SYMBOL_SIZE (objfile);
3448   DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
3449   DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos;      /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
3450
3451   if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
3452     error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile));
3453   DBX_STRINGTAB (objfile) = (char *)
3454     obstack_alloc (&objfile->objfile_obstack, DBX_STRINGTAB_SIZE (objfile) + 1);
3455   OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1);
3456
3457   /* Now read in the string table in one big gulp.  */
3458
3459   val = bfd_get_section_contents (sym_bfd,      /* bfd */
3460                                   stabstrsect,  /* bfd section */
3461                                   DBX_STRINGTAB (objfile),      /* input buffer */
3462                                   0,    /* offset into section */
3463                                   DBX_STRINGTAB_SIZE (objfile));        /* amount to read */
3464
3465   if (!val)
3466     perror_with_name (name);
3467
3468   stabsread_new_init ();
3469   buildsym_new_init ();
3470   free_header_files ();
3471   init_header_files ();
3472
3473   /* Now, do an incremental load */
3474
3475   processing_acc_compilation = 1;
3476   dbx_symfile_read (objfile, 0);
3477 }
3478 \f
3479 static struct sym_fns aout_sym_fns =
3480 {
3481   bfd_target_aout_flavour,
3482   dbx_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
3483   dbx_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
3484   dbx_symfile_read,             /* sym_read: read a symbol file into symtab */
3485   dbx_symfile_finish,           /* sym_finish: finished with file, cleanup */
3486   default_symfile_offsets,      /* sym_offsets: parse user's offsets to internal form */
3487   NULL                          /* next: pointer to next struct sym_fns */
3488 };
3489
3490 void
3491 _initialize_dbxread (void)
3492 {
3493   add_symtab_fns (&aout_sym_fns);
3494 }