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