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