1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This module provides three functions: dbx_symfile_init,
23 which initializes to read a symbol file; dbx_new_init, which
24 discards existing cached information when all symbols are being
25 discarded; and dbx_symfile_read, which reads a symbol table
28 dbx_symfile_read only does the minimum work necessary for letting the
29 user "name" things symbolically; it does not read the entire symtab.
30 Instead, it reads the external and static symbols and puts them in partial
31 symbol tables. When more extensive information is requested of a
32 file, the corresponding partial symbol table is mutated into a full
33 fledged symbol table by going back and reading the symbols
34 for real. dbx_psymtab_to_symtab() is the function that does this */
37 #include "gdb_string.h"
39 #if defined(USG) || defined(__CYGNUSCLIB__)
40 #include <sys/types.h>
48 #include "breakpoint.h"
51 #include "gdbcore.h" /* for bfd stuff */
52 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
56 #include "stabsread.h"
57 #include "gdb-stabs.h"
59 #include "language.h" /* Needed inside partial-stab.h */
60 #include "complaints.h"
62 #include "aout/aout64.h"
63 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
66 /* This macro returns the size field of a minimal symbol, which is normally
67 stored in the "info" field. The macro can be overridden for specific
68 targets (e.g. MIPS16) that use the info field for other purposes. */
70 #define MSYMBOL_SIZE(msym) ((long) MSYMBOL_INFO (msym))
74 /* We put a pointer to this structure in the read_symtab_private field
80 /* Offset within the file symbol table of first local symbol for this
85 /* Length (in bytes) of the section of the symbol table devoted to
86 this file's symbols (actually, the section bracketed may contain
87 more than just this file's symbols). If ldsymlen is 0, the only
88 reason for this thing's existence is the dependency list. Nothing
89 else will happen when it is read in. */
93 /* The size of each symbol in the symbol file (in external form). */
97 /* Further information needed to locate the symbols if they are in
102 int file_string_offset;
105 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
106 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
107 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
108 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
109 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
110 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
111 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
114 /* Remember what we deduced to be the source language of this psymtab. */
116 static enum language psymtab_language = language_unknown;
118 /* Nonzero means give verbose info on gdb action. From main.c. */
120 extern int info_verbose;
122 /* The BFD for this file -- implicit parameter to next_symbol_text. */
124 static bfd *symfile_bfd;
126 /* The size of each symbol in the symbol file (in external form).
127 This is set by dbx_symfile_read when building psymtabs, and by
128 dbx_psymtab_to_symtab when building symtabs. */
130 static unsigned symbol_size;
132 /* This is the offset of the symbol table in the executable file. */
134 static unsigned symbol_table_offset;
136 /* This is the offset of the string table in the executable file. */
138 static unsigned string_table_offset;
140 /* For elf+stab executables, the n_strx field is not a simple index
141 into the string table. Instead, each .o file has a base offset in
142 the string table, and the associated symbols contain offsets from
143 this base. The following two variables contain the base offset for
144 the current and next .o files. */
146 static unsigned int file_string_table_offset;
147 static unsigned int next_file_string_table_offset;
149 /* .o and NLM files contain unrelocated addresses which are based at
150 0. When non-zero, this flag disables some of the special cases for
151 Solaris elf+stab text addresses at location 0. */
153 static int symfile_relocatable = 0;
155 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
156 relative to the function start address. */
158 static int block_address_function_relative = 0;
160 /* The lowest text address we have yet encountered. This is needed
161 because in an a.out file, there is no header field which tells us
162 what address the program is actually going to be loaded at, so we
163 need to make guesses based on the symbols (which *are* relocated to
164 reflect the address it will be loaded at). */
166 static CORE_ADDR lowest_text_address;
168 /* Non-zero if there is any line number info in the objfile. Prevents
169 end_psymtab from discarding an otherwise empty psymtab. */
171 static int has_line_numbers;
173 /* Complaints about the symbols we have encountered. */
175 struct complaint lbrac_complaint =
176 {"bad block start address patched", 0, 0};
178 struct complaint string_table_offset_complaint =
179 {"bad string table offset in symbol %d", 0, 0};
181 struct complaint unknown_symtype_complaint =
182 {"unknown symbol type %s", 0, 0};
184 struct complaint unknown_symchar_complaint =
185 {"unknown symbol descriptor `%c'", 0, 0};
187 struct complaint lbrac_rbrac_complaint =
188 {"block start larger than block end", 0, 0};
190 struct complaint lbrac_unmatched_complaint =
191 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
193 struct complaint lbrac_mismatch_complaint =
194 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
196 struct complaint repeated_header_complaint =
197 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
199 struct complaint unclaimed_bincl_complaint =
200 {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
202 /* find_text_range --- find start and end of loadable code sections
204 The find_text_range function finds the shortest address range that
205 encloses all sections containing executable code, and stores it in
206 objfile's text_addr and text_size members.
208 dbx_symfile_read will use this to finish off the partial symbol
209 table, in some cases. */
212 find_text_range (bfd * sym_bfd, struct objfile *objfile)
216 CORE_ADDR start, end;
218 for (sec = sym_bfd->sections; sec; sec = sec->next)
219 if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE)
221 CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec);
222 CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec);
226 if (sec_start < start)
241 error ("Can't find any code sections in symbol file");
243 DBX_TEXT_ADDR (objfile) = start;
244 DBX_TEXT_SIZE (objfile) = end - start;
249 /* During initial symbol readin, we need to have a structure to keep
250 track of which psymtabs have which bincls in them. This structure
251 is used during readin to setup the list of dependencies within each
252 partial symbol table. */
254 struct header_file_location
256 char *name; /* Name of header file */
257 int instance; /* See above */
258 struct partial_symtab *pst; /* Partial symtab that has the
259 BINCL/EINCL defs for this file */
262 /* The actual list and controling variables */
263 static struct header_file_location *bincl_list, *next_bincl;
264 static int bincls_allocated;
266 /* Local function prototypes */
268 extern void _initialize_dbxread (void);
270 static void process_now (struct objfile *);
272 static void free_header_files (void);
274 static void init_header_files (void);
276 static void read_ofile_symtab (struct partial_symtab *);
278 static void dbx_psymtab_to_symtab (struct partial_symtab *);
280 static void dbx_psymtab_to_symtab_1 (struct partial_symtab *);
282 static void read_dbx_dynamic_symtab (struct objfile *objfile);
284 static void read_dbx_symtab (struct objfile *);
286 static void free_bincl_list (struct objfile *);
288 static struct partial_symtab *find_corresponding_bincl_psymtab (char *, int);
290 static void add_bincl_to_list (struct partial_symtab *, char *, int);
292 static void init_bincl_list (int, struct objfile *);
294 static char *dbx_next_symbol_text (struct objfile *);
296 static void fill_symbuf (bfd *);
298 static void dbx_symfile_init (struct objfile *);
300 static void dbx_new_init (struct objfile *);
302 static void dbx_symfile_read (struct objfile *, int);
304 static void dbx_symfile_finish (struct objfile *);
306 static void record_minimal_symbol (char *, CORE_ADDR, int, struct objfile *);
308 static void add_new_header_file (char *, int);
310 static void add_old_header_file (char *, int);
312 static void add_this_object_header_file (int);
314 static struct partial_symtab *start_psymtab (struct objfile *, char *,
316 struct partial_symbol **,
317 struct partial_symbol **);
319 /* Free up old header file tables */
322 free_header_files (void)
324 if (this_object_header_files)
326 free ((PTR) this_object_header_files);
327 this_object_header_files = NULL;
329 n_allocated_this_object_header_files = 0;
332 /* Allocate new header file tables */
335 init_header_files (void)
337 n_allocated_this_object_header_files = 10;
338 this_object_header_files = (int *) xmalloc (10 * sizeof (int));
341 /* Add header file number I for this object file
342 at the next successive FILENUM. */
345 add_this_object_header_file (int i)
347 if (n_this_object_header_files == n_allocated_this_object_header_files)
349 n_allocated_this_object_header_files *= 2;
350 this_object_header_files
351 = (int *) xrealloc ((char *) this_object_header_files,
352 n_allocated_this_object_header_files * sizeof (int));
355 this_object_header_files[n_this_object_header_files++] = i;
358 /* Add to this file an "old" header file, one already seen in
359 a previous object file. NAME is the header file's name.
360 INSTANCE is its instance code, to select among multiple
361 symbol tables for the same header file. */
364 add_old_header_file (char *name, int instance)
366 register struct header_file *p = HEADER_FILES (current_objfile);
369 for (i = 0; i < N_HEADER_FILES (current_objfile); i++)
370 if (STREQ (p[i].name, name) && instance == p[i].instance)
372 add_this_object_header_file (i);
375 complain (&repeated_header_complaint, name, symnum);
378 /* Add to this file a "new" header file: definitions for its types follow.
379 NAME is the header file's name.
380 Most often this happens only once for each distinct header file,
381 but not necessarily. If it happens more than once, INSTANCE has
382 a different value each time, and references to the header file
383 use INSTANCE values to select among them.
385 dbx output contains "begin" and "end" markers for each new header file,
386 but at this level we just need to know which files there have been;
387 so we record the file when its "begin" is seen and ignore the "end". */
390 add_new_header_file (char *name, int instance)
393 register struct header_file *hfile;
395 /* Make sure there is room for one more header file. */
397 i = N_ALLOCATED_HEADER_FILES (current_objfile);
399 if (N_HEADER_FILES (current_objfile) == i)
403 N_ALLOCATED_HEADER_FILES (current_objfile) = 10;
404 HEADER_FILES (current_objfile) = (struct header_file *)
405 xmalloc (10 * sizeof (struct header_file));
410 N_ALLOCATED_HEADER_FILES (current_objfile) = i;
411 HEADER_FILES (current_objfile) = (struct header_file *)
412 xrealloc ((char *) HEADER_FILES (current_objfile),
413 (i * sizeof (struct header_file)));
417 /* Create an entry for this header file. */
419 i = N_HEADER_FILES (current_objfile)++;
420 hfile = HEADER_FILES (current_objfile) + i;
421 hfile->name = savestring (name, strlen (name));
422 hfile->instance = instance;
425 = (struct type **) xmalloc (10 * sizeof (struct type *));
426 memset (hfile->vector, 0, 10 * sizeof (struct type *));
428 add_this_object_header_file (i);
432 static struct type **
433 explicit_lookup_type (int real_filenum, int index)
435 register struct header_file *f = &HEADER_FILES (current_objfile)[real_filenum];
437 if (index >= f->length)
440 f->vector = (struct type **)
441 xrealloc (f->vector, f->length * sizeof (struct type *));
442 memset (&f->vector[f->length / 2],
443 '\0', f->length * sizeof (struct type *) / 2);
445 return &f->vector[index];
450 record_minimal_symbol (char *name, CORE_ADDR address, int type,
451 struct objfile *objfile)
453 enum minimal_symbol_type ms_type;
455 asection *bfd_section;
461 section = SECT_OFF_TEXT (objfile);
462 bfd_section = DBX_TEXT_SECTION (objfile);
466 section = SECT_OFF_DATA (objfile);
467 bfd_section = DBX_DATA_SECTION (objfile);
471 section = SECT_OFF_BSS (objfile);
472 bfd_section = DBX_BSS_SECTION (objfile);
482 section = SECT_OFF_DATA (objfile);
483 bfd_section = DBX_DATA_SECTION (objfile);
486 /* I don't think this type actually exists; since a N_SETV is the result
487 of going over many .o files, it doesn't make sense to have one
489 ms_type = mst_file_data;
490 section = SECT_OFF_DATA (objfile);
491 bfd_section = DBX_DATA_SECTION (objfile);
498 ms_type = mst_file_text;
499 section = SECT_OFF_TEXT (objfile);
500 bfd_section = DBX_TEXT_SECTION (objfile);
503 ms_type = mst_file_data;
505 /* Check for __DYNAMIC, which is used by Sun shared libraries.
506 Record it as global even if it's local, not global, so
507 lookup_minimal_symbol can find it. We don't check symbol_leading_char
508 because for SunOS4 it always is '_'. */
509 if (name[8] == 'C' && STREQ ("__DYNAMIC", name))
512 /* Same with virtual function tables, both global and static. */
514 char *tempstring = name;
515 if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
517 if (VTBL_PREFIX_P ((tempstring)))
520 section = SECT_OFF_DATA (objfile);
521 bfd_section = DBX_DATA_SECTION (objfile);
524 ms_type = mst_file_bss;
525 section = SECT_OFF_BSS (objfile);
526 bfd_section = DBX_BSS_SECTION (objfile);
529 ms_type = mst_unknown;
535 if ((ms_type == mst_file_text || ms_type == mst_text)
536 && address < lowest_text_address)
537 lowest_text_address = address;
539 prim_record_minimal_symbol_and_info
540 (name, address, ms_type, NULL, section, bfd_section, objfile);
543 /* Scan and build partial symbols for a symbol file.
544 We have been initialized by a call to dbx_symfile_init, which
545 put all the relevant info into a "struct dbx_symfile_info",
546 hung off the objfile structure.
548 MAINLINE is true if we are reading the main symbol
549 table (as opposed to a shared lib or dynamically loaded file). */
552 dbx_symfile_read (struct objfile *objfile, int mainline)
556 struct cleanup *back_to;
558 sym_bfd = objfile->obfd;
560 /* .o and .nlm files are relocatables with text, data and bss segs based at
561 0. This flag disables special (Solaris stabs-in-elf only) fixups for
562 symbols with a value of 0. */
564 symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC;
566 /* This is true for Solaris (and all other systems which put stabs
567 in sections, hopefully, since it would be silly to do things
568 differently from Solaris), and false for SunOS4 and other a.out
570 block_address_function_relative =
571 ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3))
572 || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3))
573 || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4))
574 || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2))
575 || (0 == strncmp (bfd_get_target (sym_bfd), "epoc-pe", 7))
576 || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3)));
578 val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
580 perror_with_name (objfile->name);
582 /* If we are reinitializing, or if we have never loaded syms yet, init */
584 || objfile->global_psymbols.size == 0
585 || objfile->static_psymbols.size == 0)
586 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
588 symbol_size = DBX_SYMBOL_SIZE (objfile);
589 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
591 free_pending_blocks ();
592 back_to = make_cleanup (really_free_pendings, 0);
594 init_minimal_symbol_collection ();
595 make_cleanup_discard_minimal_symbols ();
597 /* Read stabs data from executable file and define symbols. */
599 read_dbx_symtab (objfile);
601 /* Add the dynamic symbols. */
603 read_dbx_dynamic_symtab (objfile);
605 /* Install any minimal symbols that have been collected as the current
606 minimal symbols for this objfile. */
608 install_minimal_symbols (objfile);
610 do_cleanups (back_to);
613 /* Initialize anything that needs initializing when a completely new
614 symbol file is specified (not just adding some symbols from another
615 file, e.g. a shared library). */
618 dbx_new_init (struct objfile *ignore)
620 stabsread_new_init ();
621 buildsym_new_init ();
622 init_header_files ();
626 /* dbx_symfile_init ()
627 is the dbx-specific initialization routine for reading symbols.
628 It is passed a struct objfile which contains, among other things,
629 the BFD for the file whose symbols are being read, and a slot for a pointer
630 to "private data" which we fill with goodies.
632 We read the string table into malloc'd space and stash a pointer to it.
634 Since BFD doesn't know how to read debug symbols in a format-independent
635 way (and may never do so...), we have to do it ourselves. We will never
636 be called unless this is an a.out (or very similar) file.
637 FIXME, there should be a cleaner peephole into the BFD environment here. */
639 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
642 dbx_symfile_init (struct objfile *objfile)
645 bfd *sym_bfd = objfile->obfd;
646 char *name = bfd_get_filename (sym_bfd);
648 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
650 /* Allocate struct to keep track of the symfile */
651 objfile->sym_stab_info = (struct dbx_symfile_info *)
652 xmmalloc (objfile->md, sizeof (struct dbx_symfile_info));
653 memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
655 DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
656 DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
657 DBX_BSS_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".bss");
659 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
660 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
661 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
663 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
665 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
667 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
669 error ("Can't find .text section in symbol file");
670 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
671 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
673 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
674 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
675 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
677 /* Read the string table and stash it away in the psymbol_obstack. It is
678 only needed as long as we need to expand psymbols into full symbols,
679 so when we blow away the psymbol the string table goes away as well.
680 Note that gdb used to use the results of attempting to malloc the
681 string table, based on the size it read, as a form of sanity check
682 for botched byte swapping, on the theory that a byte swapped string
683 table size would be so totally bogus that the malloc would fail. Now
684 that we put in on the psymbol_obstack, we can't do this since gdb gets
685 a fatal error (out of virtual memory) if the size is bogus. We can
686 however at least check to see if the size is less than the size of
687 the size field itself, or larger than the size of the entire file.
688 Note that all valid string tables have a size greater than zero, since
689 the bytes used to hold the size are included in the count. */
691 if (STRING_TABLE_OFFSET == 0)
693 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
694 will never be zero, even when there is no string table. This
695 would appear to be a bug in bfd. */
696 DBX_STRINGTAB_SIZE (objfile) = 0;
697 DBX_STRINGTAB (objfile) = NULL;
701 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
703 perror_with_name (name);
705 memset ((PTR) size_temp, 0, sizeof (size_temp));
706 val = bfd_read ((PTR) size_temp, sizeof (size_temp), 1, sym_bfd);
709 perror_with_name (name);
713 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
714 EOF if there is no string table, and attempting to read the size
715 from EOF will read zero bytes. */
716 DBX_STRINGTAB_SIZE (objfile) = 0;
717 DBX_STRINGTAB (objfile) = NULL;
721 /* Read some data that would appear to be the string table size.
722 If there really is a string table, then it is probably the right
723 size. Byteswap if necessary and validate the size. Note that
724 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
725 random data that happened to be at STRING_TABLE_OFFSET, because
726 bfd can't tell us there is no string table, the sanity checks may
727 or may not catch this. */
728 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
730 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
731 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
732 error ("ridiculous string table size (%d bytes).",
733 DBX_STRINGTAB_SIZE (objfile));
735 DBX_STRINGTAB (objfile) =
736 (char *) obstack_alloc (&objfile->psymbol_obstack,
737 DBX_STRINGTAB_SIZE (objfile));
738 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile));
740 /* Now read in the string table in one big gulp. */
742 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
744 perror_with_name (name);
745 val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
747 if (val != DBX_STRINGTAB_SIZE (objfile))
748 perror_with_name (name);
753 /* Perform any local cleanups required when we are done with a particular
754 objfile. I.E, we are in the process of discarding all symbol information
755 for an objfile, freeing up all memory held for it, and unlinking the
756 objfile struct from the global list of known objfiles. */
759 dbx_symfile_finish (struct objfile *objfile)
761 if (objfile->sym_stab_info != NULL)
763 if (HEADER_FILES (objfile) != NULL)
765 register int i = N_HEADER_FILES (objfile);
766 register struct header_file *hfiles = HEADER_FILES (objfile);
770 free (hfiles[i].name);
771 free (hfiles[i].vector);
775 mfree (objfile->md, objfile->sym_stab_info);
777 free_header_files ();
781 /* Buffer for reading the symbol table entries. */
782 static struct external_nlist symbuf[4096];
783 static int symbuf_idx;
784 static int symbuf_end;
786 /* cont_elem is used for continuing information in cfront.
787 It saves information about which types need to be fixed up and
788 completed after all the stabs are read. */
791 /* sym and stabsstring for continuing information in cfront */
794 /* state dependencies (statics that must be preserved) */
798 int (*func) (struct objfile *, struct symbol *, char *);
799 /* other state dependencies include:
800 (assumption is that these will not change since process_now FIXME!!)
807 static struct cont_elem *cont_list = 0;
808 static int cont_limit = 0;
809 static int cont_count = 0;
811 /* Arrange for function F to be called with arguments SYM and P later
812 in the stabs reading process. */
814 process_later (struct symbol *sym, char *p,
815 int (*f) (struct objfile *, struct symbol *, char *))
818 /* Allocate more space for the deferred list. */
819 if (cont_count >= cont_limit - 1)
821 cont_limit += 32; /* chunk size */
824 = (struct cont_elem *) xrealloc (cont_list,
826 * sizeof (struct cont_elem)));
828 error ("Virtual memory exhausted\n");
831 /* Save state variables so we can process these stabs later. */
832 cont_list[cont_count].sym_idx = symbuf_idx;
833 cont_list[cont_count].sym_end = symbuf_end;
834 cont_list[cont_count].symnum = symnum;
835 cont_list[cont_count].sym = sym;
836 cont_list[cont_count].stabs = p;
837 cont_list[cont_count].func = f;
841 /* Call deferred funtions in CONT_LIST. */
844 process_now (struct objfile *objfile)
853 int (*func) (struct objfile *, struct symbol *, char *);
855 /* Save the state of our caller, we'll want to restore it before
857 save_symbuf_idx = symbuf_idx;
858 save_symbuf_end = symbuf_end;
859 save_symnum = symnum;
861 /* Iterate over all the deferred stabs. */
862 for (i = 0; i < cont_count; i++)
864 /* Restore the state for this deferred stab. */
865 symbuf_idx = cont_list[i].sym_idx;
866 symbuf_end = cont_list[i].sym_end;
867 symnum = cont_list[i].symnum;
868 sym = cont_list[i].sym;
869 stabs = cont_list[i].stabs;
870 func = cont_list[i].func;
872 /* Call the function to handle this deferrd stab. */
873 err = (*func) (objfile, sym, stabs);
875 error ("Internal error: unable to resolve stab.\n");
878 /* Restore our caller's state. */
879 symbuf_idx = save_symbuf_idx;
880 symbuf_end = save_symbuf_end;
881 symnum = save_symnum;
886 /* Name of last function encountered. Used in Solaris to approximate
887 object file boundaries. */
888 static char *last_function_name;
890 /* The address in memory of the string table of the object file we are
891 reading (which might not be the "main" object file, but might be a
892 shared library or some other dynamically loaded thing). This is
893 set by read_dbx_symtab when building psymtabs, and by
894 read_ofile_symtab when building symtabs, and is used only by
895 next_symbol_text. FIXME: If that is true, we don't need it when
896 building psymtabs, right? */
897 static char *stringtab_global;
899 /* These variables are used to control fill_symbuf when the stabs
900 symbols are not contiguous (as may be the case when a COFF file is
901 linked using --split-by-reloc). */
902 static struct stab_section_list *symbuf_sections;
903 static unsigned int symbuf_left;
904 static unsigned int symbuf_read;
906 /* Refill the symbol table input buffer
907 and set the variables that control fetching entries from it.
908 Reports an error if no data available.
909 This function can read past the end of the symbol table
910 (into the string table) but this does no harm. */
913 fill_symbuf (bfd *sym_bfd)
918 if (symbuf_sections == NULL)
919 count = sizeof (symbuf);
922 if (symbuf_left <= 0)
924 file_ptr filepos = symbuf_sections->section->filepos;
925 if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
926 perror_with_name (bfd_get_filename (sym_bfd));
927 symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
928 symbol_table_offset = filepos - symbuf_read;
929 symbuf_sections = symbuf_sections->next;
933 if (count > sizeof (symbuf))
934 count = sizeof (symbuf);
937 nbytes = bfd_read ((PTR) symbuf, count, 1, sym_bfd);
939 perror_with_name (bfd_get_filename (sym_bfd));
940 else if (nbytes == 0)
941 error ("Premature end of file reading symbol table");
942 symbuf_end = nbytes / symbol_size;
944 symbuf_left -= nbytes;
945 symbuf_read += nbytes;
948 #define SWAP_SYMBOL(symp, abfd) \
950 (symp)->n_strx = bfd_h_get_32(abfd, \
951 (unsigned char *)&(symp)->n_strx); \
952 (symp)->n_desc = bfd_h_get_16 (abfd, \
953 (unsigned char *)&(symp)->n_desc); \
954 (symp)->n_value = bfd_h_get_32 (abfd, \
955 (unsigned char *)&(symp)->n_value); \
958 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
960 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
961 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
962 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
963 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
966 /* Invariant: The symbol pointed to by symbuf_idx is the first one
967 that hasn't been swapped. Swap the symbol at the same time
968 that symbuf_idx is incremented. */
970 /* dbx allows the text of a symbol name to be continued into the
971 next symbol name! When such a continuation is encountered
972 (a \ at the end of the text of a name)
973 call this function to get the continuation. */
976 dbx_next_symbol_text (struct objfile *objfile)
978 struct internal_nlist nlist;
980 if (symbuf_idx == symbuf_end)
981 fill_symbuf (symfile_bfd);
984 INTERNALIZE_SYMBOL (nlist, &symbuf[symbuf_idx], symfile_bfd);
985 OBJSTAT (objfile, n_stabs++);
989 return nlist.n_strx + stringtab_global + file_string_table_offset;
992 /* Initialize the list of bincls to contain none and have some
996 init_bincl_list (int number, struct objfile *objfile)
998 bincls_allocated = number;
999 next_bincl = bincl_list = (struct header_file_location *)
1000 xmmalloc (objfile->md, bincls_allocated * sizeof (struct header_file_location));
1003 /* Add a bincl to the list. */
1006 add_bincl_to_list (struct partial_symtab *pst, char *name, int instance)
1008 if (next_bincl >= bincl_list + bincls_allocated)
1010 int offset = next_bincl - bincl_list;
1011 bincls_allocated *= 2;
1012 bincl_list = (struct header_file_location *)
1013 xmrealloc (pst->objfile->md, (char *) bincl_list,
1014 bincls_allocated * sizeof (struct header_file_location));
1015 next_bincl = bincl_list + offset;
1017 next_bincl->pst = pst;
1018 next_bincl->instance = instance;
1019 next_bincl++->name = name;
1022 /* Given a name, value pair, find the corresponding
1023 bincl in the list. Return the partial symtab associated
1024 with that header_file_location. */
1026 static struct partial_symtab *
1027 find_corresponding_bincl_psymtab (char *name, int instance)
1029 struct header_file_location *bincl;
1031 for (bincl = bincl_list; bincl < next_bincl; bincl++)
1032 if (bincl->instance == instance
1033 && STREQ (name, bincl->name))
1036 complain (&repeated_header_complaint, name, symnum);
1037 return (struct partial_symtab *) 0;
1040 /* Free the storage allocated for the bincl list. */
1043 free_bincl_list (struct objfile *objfile)
1045 mfree (objfile->md, (PTR) bincl_list);
1046 bincls_allocated = 0;
1050 do_free_bincl_list_cleanup (void *objfile)
1052 free_bincl_list (objfile);
1055 static struct cleanup *
1056 make_cleanup_free_bincl_list (struct objfile *objfile)
1058 return make_cleanup (do_free_bincl_list_cleanup, objfile);
1061 /* Scan a SunOs dynamic symbol table for symbols of interest and
1062 add them to the minimal symbol table. */
1065 read_dbx_dynamic_symtab (struct objfile *objfile)
1067 bfd *abfd = objfile->obfd;
1068 struct cleanup *back_to;
1078 CORE_ADDR sym_value;
1081 /* Check that the symbol file has dynamic symbols that we know about.
1082 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1083 on a sun4 host (and vice versa) and bfd is not configured
1084 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1085 so we ignore the dynamic symbols in this case. */
1086 if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
1087 || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
1088 || bfd_get_arch (abfd) == bfd_arch_unknown)
1091 dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
1092 if (dynsym_size < 0)
1095 dynsyms = (asymbol **) xmalloc (dynsym_size);
1096 back_to = make_cleanup (free, dynsyms);
1098 dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
1099 if (dynsym_count < 0)
1101 do_cleanups (back_to);
1105 /* Enter dynamic symbols into the minimal symbol table
1106 if this is a stripped executable. */
1107 if (bfd_get_symcount (abfd) <= 0)
1110 for (counter = 0; counter < dynsym_count; counter++, symptr++)
1112 asymbol *sym = *symptr;
1116 sec = bfd_get_section (sym);
1118 /* BFD symbols are section relative. */
1119 sym_value = sym->value + sec->vma;
1121 if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
1123 sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1126 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
1128 sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
1131 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
1133 sym_value += ANOFFSET (objfile->section_offsets, SECT_OFF_BSS (objfile));
1139 if (sym->flags & BSF_GLOBAL)
1142 record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value,
1147 /* Symbols from shared libraries have a dynamic relocation entry
1148 that points to the associated slot in the procedure linkage table.
1149 We make a mininal symbol table entry with type mst_solib_trampoline
1150 at the address in the procedure linkage table. */
1151 dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
1152 if (dynrel_size < 0)
1154 do_cleanups (back_to);
1158 dynrels = (arelent **) xmalloc (dynrel_size);
1159 make_cleanup (free, dynrels);
1161 dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
1162 if (dynrel_count < 0)
1164 do_cleanups (back_to);
1168 for (counter = 0, relptr = dynrels;
1169 counter < dynrel_count;
1170 counter++, relptr++)
1172 arelent *rel = *relptr;
1174 rel->address + ANOFFSET (objfile->section_offsets, SECT_OFF_DATA (objfile));
1176 switch (bfd_get_arch (abfd))
1178 case bfd_arch_sparc:
1179 if (rel->howto->type != RELOC_JMP_SLOT)
1183 /* `16' is the type BFD produces for a jump table relocation. */
1184 if (rel->howto->type != 16)
1187 /* Adjust address in the jump table to point to
1188 the start of the bsr instruction. */
1195 name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr);
1196 prim_record_minimal_symbol (name, address, mst_solib_trampoline,
1200 do_cleanups (back_to);
1203 /* Setup partial_symtab's describing each source file for which
1204 debugging information is available. */
1207 read_dbx_symtab (struct objfile *objfile)
1209 register struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */
1210 struct internal_nlist nlist;
1211 CORE_ADDR text_addr;
1214 register char *namestring;
1216 int past_first_source_file = 0;
1217 CORE_ADDR last_o_file_start = 0;
1218 CORE_ADDR last_function_start = 0;
1219 struct cleanup *back_to;
1221 int textlow_not_set;
1223 /* Current partial symtab */
1224 struct partial_symtab *pst;
1226 /* List of current psymtab's include files */
1227 char **psymtab_include_list;
1228 int includes_allocated;
1231 /* Index within current psymtab dependency list */
1232 struct partial_symtab **dependency_list;
1233 int dependencies_used, dependencies_allocated;
1235 text_addr = DBX_TEXT_ADDR (objfile);
1236 text_size = DBX_TEXT_SIZE (objfile);
1238 /* FIXME. We probably want to change stringtab_global rather than add this
1239 while processing every symbol entry. FIXME. */
1240 file_string_table_offset = 0;
1241 next_file_string_table_offset = 0;
1243 stringtab_global = DBX_STRINGTAB (objfile);
1245 pst = (struct partial_symtab *) 0;
1247 includes_allocated = 30;
1249 psymtab_include_list = (char **) alloca (includes_allocated *
1252 dependencies_allocated = 30;
1253 dependencies_used = 0;
1255 (struct partial_symtab **) alloca (dependencies_allocated *
1256 sizeof (struct partial_symtab *));
1258 /* Init bincl list */
1259 init_bincl_list (20, objfile);
1260 back_to = make_cleanup_free_bincl_list (objfile);
1262 last_source_file = NULL;
1264 lowest_text_address = (CORE_ADDR) -1;
1266 symfile_bfd = objfile->obfd; /* For next_text_symbol */
1267 abfd = objfile->obfd;
1268 symbuf_end = symbuf_idx = 0;
1269 next_symbol_text_func = dbx_next_symbol_text;
1270 textlow_not_set = 1;
1271 has_line_numbers = 0;
1273 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1275 /* Get the symbol for this run and pull out some info */
1276 QUIT; /* allow this to be interruptable */
1277 if (symbuf_idx == symbuf_end)
1279 bufp = &symbuf[symbuf_idx++];
1282 * Special case to speed up readin.
1284 if (bfd_h_get_8 (abfd, bufp->e_type) == N_SLINE)
1286 has_line_numbers = 1;
1290 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1291 OBJSTAT (objfile, n_stabs++);
1293 /* Ok. There is a lot of code duplicated in the rest of this
1294 switch statement (for efficiency reasons). Since I don't
1295 like duplicating code, I will do my penance here, and
1296 describe the code which is duplicated:
1298 *) The assignment to namestring.
1299 *) The call to strchr.
1300 *) The addition of a partial symbol the the two partial
1301 symbol lists. This last is a large section of code, so
1302 I've imbedded it in the following macro.
1305 /* Set namestring based on nlist. If the string table index is invalid,
1306 give a fake name, and print a single error message per symbol file read,
1307 rather than abort the symbol reading or flood the user with messages. */
1309 /*FIXME: Too many adds and indirections in here for the inner loop. */
1310 #define SET_NAMESTRING()\
1311 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1312 DBX_STRINGTAB_SIZE (objfile)) { \
1313 complain (&string_table_offset_complaint, symnum); \
1314 namestring = "<bad string table offset>"; \
1316 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1317 DBX_STRINGTAB (objfile)
1319 #define CUR_SYMBOL_TYPE nlist.n_type
1320 #define CUR_SYMBOL_VALUE nlist.n_value
1321 #define CUR_SYMBOL_STRX nlist.n_strx
1322 #define DBXREAD_ONLY
1323 #define START_PSYMTAB(ofile,fname,low,symoff,global_syms,static_syms)\
1324 start_psymtab(ofile, fname, low, symoff, global_syms, static_syms)
1325 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1326 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1328 #include "partial-stab.h"
1331 /* If there's stuff to be cleaned up, clean it up. */
1332 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
1333 /*FIXME, does this have a bug at start address 0? */
1334 && last_o_file_start
1335 && objfile->ei.entry_point < nlist.n_value
1336 && objfile->ei.entry_point >= last_o_file_start)
1338 objfile->ei.entry_file_lowpc = last_o_file_start;
1339 objfile->ei.entry_file_highpc = nlist.n_value;
1344 /* Don't set pst->texthigh lower than it already is. */
1345 CORE_ADDR text_end =
1346 (lowest_text_address == (CORE_ADDR) -1
1347 ? (text_addr + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile)))
1348 : lowest_text_address)
1351 end_psymtab (pst, psymtab_include_list, includes_used,
1352 symnum * symbol_size,
1353 text_end > pst->texthigh ? text_end : pst->texthigh,
1354 dependency_list, dependencies_used, textlow_not_set);
1357 do_cleanups (back_to);
1360 /* Allocate and partially fill a partial symtab. It will be
1361 completely filled at the end of the symbol list.
1363 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1364 is the address relative to which its symbols are (incremental) or 0
1368 static struct partial_symtab *
1369 start_psymtab (struct objfile *objfile, char *filename, CORE_ADDR textlow,
1370 int ldsymoff, struct partial_symbol **global_syms,
1371 struct partial_symbol **static_syms)
1373 struct partial_symtab *result =
1374 start_psymtab_common (objfile, objfile->section_offsets,
1375 filename, textlow, global_syms, static_syms);
1377 result->read_symtab_private = (char *)
1378 obstack_alloc (&objfile->psymbol_obstack, sizeof (struct symloc));
1379 LDSYMOFF (result) = ldsymoff;
1380 result->read_symtab = dbx_psymtab_to_symtab;
1381 SYMBOL_SIZE (result) = symbol_size;
1382 SYMBOL_OFFSET (result) = symbol_table_offset;
1383 STRING_OFFSET (result) = string_table_offset;
1384 FILE_STRING_OFFSET (result) = file_string_table_offset;
1386 /* If we're handling an ELF file, drag some section-relocation info
1387 for this source file out of the ELF symbol table, to compensate for
1388 Sun brain death. This replaces the section_offsets in this psymtab,
1390 elfstab_offset_sections (objfile, result);
1392 /* Deduce the source language from the filename for this psymtab. */
1393 psymtab_language = deduce_language_from_filename (filename);
1398 /* Close off the current usage of PST.
1399 Returns PST or NULL if the partial symtab was empty and thrown away.
1401 FIXME: List variables and peculiarities of same. */
1403 struct partial_symtab *
1404 end_psymtab (struct partial_symtab *pst, char **include_list, int num_includes,
1405 int capping_symbol_offset, CORE_ADDR capping_text,
1406 struct partial_symtab **dependency_list, int number_dependencies,
1407 int textlow_not_set)
1410 struct objfile *objfile = pst->objfile;
1412 if (capping_symbol_offset != -1)
1413 LDSYMLEN (pst) = capping_symbol_offset - LDSYMOFF (pst);
1414 pst->texthigh = capping_text;
1416 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1417 /* Under Solaris, the N_SO symbols always have a value of 0,
1418 instead of the usual address of the .o file. Therefore,
1419 we have to do some tricks to fill in texthigh and textlow.
1420 The first trick is in partial-stab.h: if we see a static
1421 or global function, and the textlow for the current pst
1422 is not set (ie: textlow_not_set), then we use that function's
1423 address for the textlow of the pst. */
1425 /* Now, to fill in texthigh, we remember the last function seen
1426 in the .o file (also in partial-stab.h). Also, there's a hack in
1427 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1428 to here via the misc_info field. Therefore, we can fill in
1429 a reliable texthigh by taking the address plus size of the
1430 last function in the file. */
1432 if (pst->texthigh == 0 && last_function_name)
1436 struct minimal_symbol *minsym;
1438 p = strchr (last_function_name, ':');
1440 p = last_function_name;
1441 n = p - last_function_name;
1443 strncpy (p, last_function_name, n);
1446 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1449 /* Sun Fortran appends an underscore to the minimal symbol name,
1450 try again with an appended underscore if the minimal symbol
1454 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1458 pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
1460 last_function_name = NULL;
1463 /* this test will be true if the last .o file is only data */
1464 if (textlow_not_set)
1465 pst->textlow = pst->texthigh;
1468 struct partial_symtab *p1;
1470 /* If we know our own starting text address, then walk through all other
1471 psymtabs for this objfile, and if any didn't know their ending text
1472 address, set it to our starting address. Take care to not set our
1473 own ending address to our starting address, nor to set addresses on
1474 `dependency' files that have both textlow and texthigh zero. */
1476 ALL_OBJFILE_PSYMTABS (objfile, p1)
1478 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst)
1480 p1->texthigh = pst->textlow;
1481 /* if this file has only data, then make textlow match texthigh */
1482 if (p1->textlow == 0)
1483 p1->textlow = p1->texthigh;
1488 /* End of kludge for patching Solaris textlow and texthigh. */
1489 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1491 pst->n_global_syms =
1492 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1493 pst->n_static_syms =
1494 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1496 pst->number_of_dependencies = number_dependencies;
1497 if (number_dependencies)
1499 pst->dependencies = (struct partial_symtab **)
1500 obstack_alloc (&objfile->psymbol_obstack,
1501 number_dependencies * sizeof (struct partial_symtab *));
1502 memcpy (pst->dependencies, dependency_list,
1503 number_dependencies * sizeof (struct partial_symtab *));
1506 pst->dependencies = 0;
1508 for (i = 0; i < num_includes; i++)
1510 struct partial_symtab *subpst =
1511 allocate_psymtab (include_list[i], objfile);
1513 /* Copy the sesction_offsets array from the main psymtab. */
1514 subpst->section_offsets = pst->section_offsets;
1515 subpst->read_symtab_private =
1516 (char *) obstack_alloc (&objfile->psymbol_obstack,
1517 sizeof (struct symloc));
1521 subpst->texthigh = 0;
1523 /* We could save slight bits of space by only making one of these,
1524 shared by the entire set of include files. FIXME-someday. */
1525 subpst->dependencies = (struct partial_symtab **)
1526 obstack_alloc (&objfile->psymbol_obstack,
1527 sizeof (struct partial_symtab *));
1528 subpst->dependencies[0] = pst;
1529 subpst->number_of_dependencies = 1;
1531 subpst->globals_offset =
1532 subpst->n_global_syms =
1533 subpst->statics_offset =
1534 subpst->n_static_syms = 0;
1538 subpst->read_symtab = pst->read_symtab;
1541 sort_pst_symbols (pst);
1543 /* If there is already a psymtab or symtab for a file of this name, remove it.
1544 (If there is a symtab, more drastic things also happen.)
1545 This happens in VxWorks. */
1546 free_named_symtabs (pst->filename);
1548 if (num_includes == 0
1549 && number_dependencies == 0
1550 && pst->n_global_syms == 0
1551 && pst->n_static_syms == 0
1552 && has_line_numbers == 0)
1554 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1555 it is on the obstack, but we can forget to chain it on the list. */
1556 /* Empty psymtabs happen as a result of header files which don't have
1557 any symbols in them. There can be a lot of them. But this check
1558 is wrong, in that a psymtab with N_SLINE entries but nothing else
1559 is not empty, but we don't realize that. Fixing that without slowing
1560 things down might be tricky. */
1562 discard_psymtab (pst);
1564 /* Indicate that psymtab was thrown away. */
1565 pst = (struct partial_symtab *) NULL;
1571 dbx_psymtab_to_symtab_1 (struct partial_symtab *pst)
1573 struct cleanup *old_chain;
1581 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1586 /* Read in all partial symtabs on which this one is dependent */
1587 for (i = 0; i < pst->number_of_dependencies; i++)
1588 if (!pst->dependencies[i]->readin)
1590 /* Inform about additional files that need to be read in. */
1593 fputs_filtered (" ", gdb_stdout);
1595 fputs_filtered ("and ", gdb_stdout);
1597 printf_filtered ("%s...", pst->dependencies[i]->filename);
1598 wrap_here (""); /* Flush output */
1599 gdb_flush (gdb_stdout);
1601 dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1604 if (LDSYMLEN (pst)) /* Otherwise it's a dummy */
1606 /* Init stuff necessary for reading in symbols */
1609 old_chain = make_cleanup (really_free_pendings, 0);
1610 file_string_table_offset = FILE_STRING_OFFSET (pst);
1611 symbol_size = SYMBOL_SIZE (pst);
1613 /* Read in this file's symbols */
1614 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
1615 read_ofile_symtab (pst);
1616 sort_symtab_syms (pst->symtab);
1618 do_cleanups (old_chain);
1624 /* Read in all of the symbols for a given psymtab for real.
1625 Be verbose about it if the user wants that. */
1628 dbx_psymtab_to_symtab (struct partial_symtab *pst)
1637 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1642 if (LDSYMLEN (pst) || pst->number_of_dependencies)
1644 /* Print the message now, before reading the string table,
1645 to avoid disconcerting pauses. */
1648 printf_filtered ("Reading in symbols for %s...", pst->filename);
1649 gdb_flush (gdb_stdout);
1652 sym_bfd = pst->objfile->obfd;
1654 next_symbol_text_func = dbx_next_symbol_text;
1656 dbx_psymtab_to_symtab_1 (pst);
1658 /* Match with global symbols. This only needs to be done once,
1659 after all of the symtabs and dependencies have been read in. */
1660 scan_file_globals (pst->objfile);
1662 /* Finish up the debug error message. */
1664 printf_filtered ("done.\n");
1668 /* Read in a defined section of a specific object file's symbols. */
1671 read_ofile_symtab (struct partial_symtab *pst)
1673 register char *namestring;
1674 register struct external_nlist *bufp;
1675 struct internal_nlist nlist;
1677 unsigned max_symnum;
1679 struct objfile *objfile;
1680 int sym_offset; /* Offset to start of symbols to read */
1681 int sym_size; /* Size of symbols to read */
1682 CORE_ADDR text_offset; /* Start of text segment for symbols */
1683 int text_size; /* Size of text segment for symbols */
1684 struct section_offsets *section_offsets;
1686 objfile = pst->objfile;
1687 sym_offset = LDSYMOFF (pst);
1688 sym_size = LDSYMLEN (pst);
1689 text_offset = pst->textlow;
1690 text_size = pst->texthigh - pst->textlow;
1691 /* This cannot be simply objfile->section_offsets because of
1692 elfstab_offset_sections() which initializes the psymtab section
1693 offsets information in a special way, and that is different from
1694 objfile->section_offsets. */
1695 section_offsets = pst->section_offsets;
1697 current_objfile = objfile;
1698 subfile_stack = NULL;
1700 stringtab_global = DBX_STRINGTAB (objfile);
1701 last_source_file = NULL;
1703 abfd = objfile->obfd;
1704 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
1705 symbuf_end = symbuf_idx = 0;
1707 /* It is necessary to actually read one symbol *before* the start
1708 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1709 occurs before the N_SO symbol.
1711 Detecting this in read_dbx_symtab
1712 would slow down initial readin, so we look for it here instead. */
1713 if (!processing_acc_compilation && sym_offset >= (int) symbol_size)
1715 bfd_seek (symfile_bfd, sym_offset - symbol_size, SEEK_CUR);
1717 bufp = &symbuf[symbuf_idx++];
1718 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1719 OBJSTAT (objfile, n_stabs++);
1723 processing_gcc_compilation = 0;
1724 if (nlist.n_type == N_TEXT)
1726 const char *tempstring = namestring;
1728 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1729 processing_gcc_compilation = 1;
1730 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1731 processing_gcc_compilation = 2;
1732 if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
1734 if (STREQN (tempstring, "__gnu_compiled", 14))
1735 processing_gcc_compilation = 2;
1738 /* Try to select a C++ demangling based on the compilation unit
1741 if (processing_gcc_compilation)
1743 if (AUTO_DEMANGLING)
1745 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1751 /* The N_SO starting this symtab is the first symbol, so we
1752 better not check the symbol before it. I'm not this can
1753 happen, but it doesn't hurt to check for it. */
1754 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
1755 processing_gcc_compilation = 0;
1758 if (symbuf_idx == symbuf_end)
1760 bufp = &symbuf[symbuf_idx];
1761 if (bfd_h_get_8 (abfd, bufp->e_type) != N_SO)
1762 error ("First symbol in segment of executable not a source symbol");
1764 max_symnum = sym_size / symbol_size;
1767 symnum < max_symnum;
1770 QUIT; /* Allow this to be interruptable */
1771 if (symbuf_idx == symbuf_end)
1773 bufp = &symbuf[symbuf_idx++];
1774 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1775 OBJSTAT (objfile, n_stabs++);
1777 type = bfd_h_get_8 (abfd, bufp->e_type);
1783 process_one_symbol (type, nlist.n_desc, nlist.n_value,
1784 namestring, section_offsets, objfile);
1786 /* We skip checking for a new .o or -l file; that should never
1787 happen in this routine. */
1788 else if (type == N_TEXT)
1790 /* I don't think this code will ever be executed, because
1791 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1792 the N_SO symbol which starts this source file.
1793 However, there is no reason not to accept
1794 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1796 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1797 processing_gcc_compilation = 1;
1798 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1799 processing_gcc_compilation = 2;
1801 if (AUTO_DEMANGLING)
1803 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1806 else if (type & N_EXT || type == (unsigned char) N_TEXT
1807 || type == (unsigned char) N_NBTEXT
1810 /* Global symbol: see if we came across a dbx defintion for
1811 a corresponding symbol. If so, store the value. Remove
1812 syms from the chain when their values are stored, but
1813 search the whole chain, as there may be several syms from
1814 different files with the same name. */
1815 /* This is probably not true. Since the files will be read
1816 in one at a time, each reference to a global symbol will
1817 be satisfied in each file as it appears. So we skip this
1823 current_objfile = NULL;
1825 /* In a Solaris elf file, this variable, which comes from the
1826 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1827 which comes from pst->textlow is correct. */
1828 if (last_source_start_addr == 0)
1829 last_source_start_addr = text_offset;
1831 /* In reordered executables last_source_start_addr may not be the
1832 lower bound for this symtab, instead use text_offset which comes
1833 from pst->textlow which is correct. */
1834 if (last_source_start_addr > text_offset)
1835 last_source_start_addr = text_offset;
1837 pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT (objfile));
1839 /* Process items which we had to "process_later" due to dependencies
1841 process_now (objfile);
1847 /* This handles a single symbol from the symbol-file, building symbols
1848 into a GDB symtab. It takes these arguments and an implicit argument.
1850 TYPE is the type field of the ".stab" symbol entry.
1851 DESC is the desc field of the ".stab" entry.
1852 VALU is the value field of the ".stab" entry.
1853 NAME is the symbol name, in our address space.
1854 SECTION_OFFSETS is a set of amounts by which the sections of this object
1855 file were relocated when it was loaded into memory.
1856 Note that these section_offsets are not the
1857 objfile->section_offsets but the pst->section_offsets.
1858 All symbols that refer
1859 to memory locations need to be offset by these amounts.
1860 OBJFILE is the object file from which we are reading symbols.
1861 It is used in end_symtab. */
1864 process_one_symbol (int type, int desc, CORE_ADDR valu, char *name,
1865 struct section_offsets *section_offsets,
1866 struct objfile *objfile)
1868 #ifdef SUN_FIXED_LBRAC_BUG
1869 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1870 to correct the address of N_LBRAC's. If it is not defined, then
1871 we never need to correct the addresses. */
1873 /* This records the last pc address we've seen. We depend on there being
1874 an SLINE or FUN or SO before the first LBRAC, since the variable does
1875 not get reset in between reads of different symbol files. */
1876 static CORE_ADDR last_pc_address;
1879 register struct context_stack *new;
1880 /* This remembers the address of the start of a function. It is used
1881 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1882 relative to the current function's start address. On systems
1883 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1884 used to relocate these symbol types rather than SECTION_OFFSETS. */
1885 static CORE_ADDR function_start_offset;
1887 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1888 file. Used to detect the SunPRO solaris compiler. */
1889 static int n_opt_found;
1891 /* The stab type used for the definition of the last function.
1892 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1893 static int function_stab_type = 0;
1895 if (!block_address_function_relative)
1896 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1897 function start address, so just use the text offset. */
1898 function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
1900 /* Something is wrong if we see real data before
1901 seeing a source file name. */
1903 if (last_source_file == NULL && type != (unsigned char) N_SO)
1905 /* Ignore any symbols which appear before an N_SO symbol.
1906 Currently no one puts symbols there, but we should deal
1907 gracefully with the case. A complain()t might be in order,
1908 but this should not be an error (). */
1917 if (*name == '\000')
1919 /* This N_FUN marks the end of a function. This closes off the
1921 within_function = 0;
1922 new = pop_context ();
1924 /* Make a block for the local symbols within. */
1925 finish_block (new->name, &local_symbols, new->old_blocks,
1926 new->start_addr, new->start_addr + valu,
1929 /* May be switching to an assembler file which may not be using
1930 block relative stabs, so reset the offset. */
1931 if (block_address_function_relative)
1932 function_start_offset = 0;
1937 /* Relocate for dynamic loading */
1938 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
1939 #ifdef SMASH_TEXT_ADDRESS
1940 SMASH_TEXT_ADDRESS (valu);
1942 goto define_a_symbol;
1945 /* This "symbol" just indicates the start of an inner lexical
1946 context within a function. */
1948 /* Ignore extra outermost context from SunPRO cc and acc. */
1949 if (n_opt_found && desc == 1)
1952 if (block_address_function_relative)
1953 /* Relocate for Sun ELF acc fn-relative syms. */
1954 valu += function_start_offset;
1956 /* On most machines, the block addresses are relative to the
1957 N_SO, the linker did not relocate them (sigh). */
1958 valu += last_source_start_addr;
1960 #ifdef SUN_FIXED_LBRAC_BUG
1961 if (!SUN_FIXED_LBRAC_BUG && valu < last_pc_address)
1963 /* Patch current LBRAC pc value to match last handy pc value */
1964 complain (&lbrac_complaint);
1965 valu = last_pc_address;
1968 new = push_context (desc, valu);
1972 /* This "symbol" just indicates the end of an inner lexical
1973 context that was started with N_LBRAC. */
1975 /* Ignore extra outermost context from SunPRO cc and acc. */
1976 if (n_opt_found && desc == 1)
1979 if (block_address_function_relative)
1980 /* Relocate for Sun ELF acc fn-relative syms. */
1981 valu += function_start_offset;
1983 /* On most machines, the block addresses are relative to the
1984 N_SO, the linker did not relocate them (sigh). */
1985 valu += last_source_start_addr;
1987 new = pop_context ();
1988 if (desc != new->depth)
1989 complain (&lbrac_mismatch_complaint, symnum);
1991 /* Some compilers put the variable decls inside of an
1992 LBRAC/RBRAC block. This macro should be nonzero if this
1993 is true. DESC is N_DESC from the N_RBRAC symbol.
1994 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1995 or the GCC2_COMPILED_SYMBOL. */
1996 #if !defined (VARIABLES_INSIDE_BLOCK)
1997 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2000 /* Can only use new->locals as local symbols here if we're in
2001 gcc or on a machine that puts them before the lbrack. */
2002 if (!VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation))
2003 local_symbols = new->locals;
2005 if (context_stack_depth
2006 > !VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation))
2008 /* This is not the outermost LBRAC...RBRAC pair in the function,
2009 its local symbols preceded it, and are the ones just recovered
2010 from the context stack. Define the block for them (but don't
2011 bother if the block contains no symbols. Should we complain
2012 on blocks without symbols? I can't think of any useful purpose
2014 if (local_symbols != NULL)
2016 /* Muzzle a compiler bug that makes end < start. (which
2017 compilers? Is this ever harmful?). */
2018 if (new->start_addr > valu)
2020 complain (&lbrac_rbrac_complaint);
2021 new->start_addr = valu;
2023 /* Make a block for the local symbols within. */
2024 finish_block (0, &local_symbols, new->old_blocks,
2025 new->start_addr, valu, objfile);
2030 /* This is the outermost LBRAC...RBRAC pair. There is no
2031 need to do anything; leave the symbols that preceded it
2032 to be attached to the function's own block. We need to
2033 indicate that we just moved outside of the function. */
2034 within_function = 0;
2037 if (VARIABLES_INSIDE_BLOCK (desc, processing_gcc_compilation))
2038 /* Now pop locals of block just finished. */
2039 local_symbols = new->locals;
2044 /* This kind of symbol indicates the start of an object file. */
2045 /* Relocate for dynamic loading */
2046 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2050 /* This type of symbol indicates the start of data
2051 for one source file.
2052 Finish the symbol table of the previous source file
2053 (if any) and start accumulating a new symbol table. */
2054 /* Relocate for dynamic loading */
2055 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2059 #ifdef SUN_FIXED_LBRAC_BUG
2060 last_pc_address = valu; /* Save for SunOS bug circumcision */
2063 #ifdef PCC_SOL_BROKEN
2064 /* pcc bug, occasionally puts out SO for SOL. */
2065 if (context_stack_depth > 0)
2067 start_subfile (name, NULL);
2071 if (last_source_file)
2073 /* Check if previous symbol was also an N_SO (with some
2074 sanity checks). If so, that one was actually the directory
2075 name, and the current one is the real file name.
2077 if (previous_stab_code == (unsigned char) N_SO)
2079 patch_subfile_names (current_subfile, name);
2080 break; /* Ignore repeated SOs */
2082 end_symtab (valu, objfile, SECT_OFF_TEXT (objfile));
2086 /* Null name means this just marks the end of text for this .o file.
2087 Don't start a new symtab in this case. */
2088 if (*name == '\000')
2091 if (block_address_function_relative)
2092 function_start_offset = 0;
2095 start_symtab (name, NULL, valu);
2096 record_debugformat ("stabs");
2100 /* This type of symbol indicates the start of data for
2101 a sub-source-file, one whose contents were copied or
2102 included in the compilation of the main source file
2103 (whose name was given in the N_SO symbol.) */
2104 /* Relocate for dynamic loading */
2105 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2106 start_subfile (name, current_subfile->dirname);
2111 add_new_header_file (name, valu);
2112 start_subfile (name, current_subfile->dirname);
2116 start_subfile (pop_subfile (), current_subfile->dirname);
2120 add_old_header_file (name, valu);
2124 /* This type of "symbol" really just records
2125 one line-number -- core-address correspondence.
2126 Enter it in the line list for this symbol table. */
2128 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2129 valu += function_start_offset;
2131 #ifdef SUN_FIXED_LBRAC_BUG
2132 last_pc_address = valu; /* Save for SunOS bug circumcision */
2134 record_line (current_subfile, desc, valu);
2138 common_block_start (name, objfile);
2142 common_block_end (objfile);
2145 /* The following symbol types need to have the appropriate offset added
2146 to their value; then we process symbol definitions in the name. */
2148 case N_STSYM: /* Static symbol in data seg */
2149 case N_LCSYM: /* Static symbol in BSS seg */
2150 case N_ROSYM: /* Static symbol in Read-only data seg */
2151 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2152 Solaris2's stabs-in-elf makes *most* symbols relative
2153 but leaves a few absolute (at least for Solaris 2.1 and version
2154 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2155 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2156 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2157 This leaves us no choice but to search for the 'S' or 'V'...
2158 (or pass the whole section_offsets stuff down ONE MORE function
2159 call level, which we really don't want to do). */
2163 /* .o files and NLMs have non-zero text seg offsets, but don't need
2164 their static syms offset in this fashion. XXX - This is really a
2165 crock that should be fixed in the solib handling code so that I
2166 don't have to work around it here. */
2168 if (!symfile_relocatable)
2170 p = strchr (name, ':');
2171 if (p != 0 && p[1] == 'S')
2173 /* The linker relocated it. We don't want to add an
2174 elfstab_offset_sections-type offset, but we *do* want
2175 to add whatever solib.c passed to symbol_file_add as
2176 addr (this is known to affect SunOS4, and I suspect ELF
2177 too). Since elfstab_offset_sections currently does not
2178 muck with the text offset (there is no Ttext.text
2179 symbol), we can get addr from the text offset. If
2180 elfstab_offset_sections ever starts dealing with the
2181 text offset, and we still need to do this, we need to
2182 invent a SECT_OFF_ADDR_KLUDGE or something. */
2183 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2184 goto define_a_symbol;
2187 /* Since it's not the kludge case, re-dispatch to the right handler. */
2201 case_N_STSYM: /* Static symbol in data seg */
2202 case N_DSLINE: /* Source line number, data seg */
2203 valu += ANOFFSET (section_offsets, SECT_OFF_DATA (objfile));
2204 goto define_a_symbol;
2206 case_N_LCSYM: /* Static symbol in BSS seg */
2207 case N_BSLINE: /* Source line number, bss seg */
2208 /* N_BROWS: overlaps with N_BSLINE */
2209 valu += ANOFFSET (section_offsets, SECT_OFF_BSS (objfile));
2210 goto define_a_symbol;
2212 case_N_ROSYM: /* Static symbol in Read-only data seg */
2213 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA (objfile));
2214 goto define_a_symbol;
2216 case N_ENTRY: /* Alternate entry point */
2217 /* Relocate for dynamic loading */
2218 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile));
2219 goto define_a_symbol;
2221 /* The following symbol types we don't know how to process. Handle
2222 them in a "default" way, but complain to people who care. */
2224 case N_CATCH: /* Exception handler catcher */
2225 case N_EHDECL: /* Exception handler name */
2226 case N_PC: /* Global symbol in Pascal */
2227 case N_M2C: /* Modula-2 compilation unit */
2228 /* N_MOD2: overlaps with N_EHDECL */
2229 case N_SCOPE: /* Modula-2 scope information */
2230 case N_ECOML: /* End common (local name) */
2231 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
2236 complain (&unknown_symtype_complaint, local_hex_string (type));
2239 /* The following symbol types don't need the address field relocated,
2240 since it is either unused, or is absolute. */
2242 case N_GSYM: /* Global variable */
2243 case N_NSYMS: /* Number of symbols (ultrix) */
2244 case N_NOMAP: /* No map? (ultrix) */
2245 case N_RSYM: /* Register variable */
2246 case N_DEFD: /* Modula-2 GNU module dependency */
2247 case N_SSYM: /* Struct or union element */
2248 case N_LSYM: /* Local symbol in stack */
2249 case N_PSYM: /* Parameter variable */
2250 case N_LENG: /* Length of preceding symbol type */
2254 char *colon_pos = strchr (name, ':');
2255 if (colon_pos == NULL)
2258 deftype = colon_pos[1];
2264 function_stab_type = type;
2266 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2267 /* Deal with the SunPRO 3.0 compiler which omits the address
2268 from N_FUN symbols. */
2270 && valu == ANOFFSET (section_offsets, SECT_OFF_TEXT (objfile)))
2272 find_stab_function_addr (name, last_source_file, objfile);
2275 #ifdef SUN_FIXED_LBRAC_BUG
2276 /* The Sun acc compiler, under SunOS4, puts out
2277 functions with N_GSYM or N_STSYM. The problem is
2278 that the address of the symbol is no good (for N_GSYM
2279 it doesn't even attept an address; for N_STSYM it
2280 puts out an address but then it gets relocated
2281 relative to the data segment, not the text segment).
2282 Currently we can't fix this up later as we do for
2283 some types of symbol in scan_file_globals.
2284 Fortunately we do have a way of finding the address -
2285 we know that the value in last_pc_address is either
2286 the one we want (if we're dealing with the first
2287 function in an object file), or somewhere in the
2288 previous function. This means that we can use the
2289 minimal symbol table to get the address. */
2291 /* Starting with release 3.0, the Sun acc compiler,
2292 under SunOS4, puts out functions with N_FUN and a value
2293 of zero. This gets relocated to the start of the text
2294 segment of the module, which is no good either.
2295 Under SunOS4 we can deal with this as N_SLINE and N_SO
2296 entries contain valid absolute addresses.
2297 Release 3.0 acc also puts out N_OPT entries, which makes
2298 it possible to discern acc from cc or gcc. */
2300 if (type == N_GSYM || type == N_STSYM
2302 && n_opt_found && !block_address_function_relative))
2304 struct minimal_symbol *m;
2305 int l = colon_pos - name;
2307 m = lookup_minimal_symbol_by_pc (last_pc_address);
2308 if (m && STREQN (SYMBOL_NAME (m), name, l)
2309 && SYMBOL_NAME (m)[l] == '\0')
2310 /* last_pc_address was in this function */
2311 valu = SYMBOL_VALUE (m);
2312 else if (m && SYMBOL_NAME (m + 1)
2313 && STREQN (SYMBOL_NAME (m + 1), name, l)
2314 && SYMBOL_NAME (m + 1)[l] == '\0')
2315 /* last_pc_address was in last function */
2316 valu = SYMBOL_VALUE (m + 1);
2318 /* Not found - use last_pc_address (for finish_block) */
2319 valu = last_pc_address;
2322 last_pc_address = valu; /* Save for SunOS bug circumcision */
2325 if (block_address_function_relative)
2326 /* For Solaris 2.0 compilers, the block addresses and
2327 N_SLINE's are relative to the start of the
2328 function. On normal systems, and when using gcc on
2329 Solaris 2.0, these addresses are just absolute, or
2330 relative to the N_SO, depending on
2331 BLOCK_ADDRESS_ABSOLUTE. */
2332 function_start_offset = valu;
2334 within_function = 1;
2336 if (context_stack_depth > 1)
2338 complain (&lbrac_unmatched_complaint, symnum);
2342 if (context_stack_depth > 0)
2344 new = pop_context ();
2345 /* Make a block for the local symbols within. */
2346 finish_block (new->name, &local_symbols, new->old_blocks,
2347 new->start_addr, valu, objfile);
2350 new = push_context (0, valu);
2351 new->name = define_symbol (valu, name, desc, type, objfile);
2355 define_symbol (valu, name, desc, type, objfile);
2361 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2362 for a bunch of other flags, too. Someday we may parse their
2363 flags; for now we ignore theirs and hope they'll ignore ours. */
2364 case N_OPT: /* Solaris 2: Compiler options */
2367 if (STREQ (name, GCC2_COMPILED_FLAG_SYMBOL))
2369 processing_gcc_compilation = 2;
2370 #if 1 /* Works, but is experimental. -fnf */
2371 if (AUTO_DEMANGLING)
2373 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
2382 /* The following symbol types can be ignored. */
2383 case N_OBJ: /* Solaris 2: Object file dir and name */
2384 /* N_UNDF: Solaris 2: file separator mark */
2385 /* N_UNDF: -- we will never encounter it, since we only process one
2386 file's symbols at once. */
2387 case N_ENDM: /* Solaris 2: End of module */
2388 case N_MAIN: /* Name of main routine. */
2389 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
2393 /* '#' is a GNU C extension to allow one symbol to refer to another
2396 Generally this is used so that an alias can refer to its main
2400 /* Initialize symbol reference names and determine if this is
2401 a definition. If symbol reference is being defined, go
2402 ahead and add it. Otherwise, just return sym. */
2407 /* If this stab defines a new reference ID that is not on the
2408 reference list, then put it on the reference list.
2410 We go ahead and advance NAME past the reference, even though
2411 it is not strictly necessary at this time. */
2412 refnum = symbol_reference_defined (&s);
2414 if (!ref_search (refnum))
2415 ref_add (refnum, 0, name, valu);
2420 previous_stab_code = type;
2423 /* FIXME: The only difference between this and elfstab_build_psymtabs
2424 is the call to install_minimal_symbols for elf, and the support for
2425 split sections. If the differences are really that small, the code
2426 should be shared. */
2428 /* Scan and build partial symbols for an coff symbol file.
2429 The coff file has already been processed to get its minimal symbols.
2431 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2434 OBJFILE is the object file we are reading symbols from.
2435 ADDR is the address relative to which the symbols are (e.g.
2436 the base address of the text segment).
2437 MAINLINE is true if we are reading the main symbol
2438 table (as opposed to a shared lib or dynamically loaded file).
2439 TEXTADDR is the address of the text section.
2440 TEXTSIZE is the size of the text section.
2441 STABSECTS is the list of .stab sections in OBJFILE.
2442 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2443 .stabstr section exists.
2445 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2446 adjusted for coff details. */
2449 coffstab_build_psymtabs (struct objfile *objfile, int mainline,
2450 CORE_ADDR textaddr, unsigned int textsize,
2451 struct stab_section_list *stabsects,
2452 file_ptr stabstroffset, unsigned int stabstrsize)
2455 bfd *sym_bfd = objfile->obfd;
2456 char *name = bfd_get_filename (sym_bfd);
2457 struct dbx_symfile_info *info;
2458 unsigned int stabsize;
2460 /* There is already a dbx_symfile_info allocated by our caller.
2461 It might even contain some info from the coff symtab to help us. */
2462 info = objfile->sym_stab_info;
2464 DBX_TEXT_ADDR (objfile) = textaddr;
2465 DBX_TEXT_SIZE (objfile) = textsize;
2467 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2468 DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE;
2469 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2471 if (stabstrsize > bfd_get_size (sym_bfd))
2472 error ("ridiculous string table size: %d bytes", stabstrsize);
2473 DBX_STRINGTAB (objfile) = (char *)
2474 obstack_alloc (&objfile->psymbol_obstack, stabstrsize + 1);
2475 OBJSTAT (objfile, sz_strtab += stabstrsize + 1);
2477 /* Now read in the string table in one big gulp. */
2479 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2481 perror_with_name (name);
2482 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2483 if (val != stabstrsize)
2484 perror_with_name (name);
2486 stabsread_new_init ();
2487 buildsym_new_init ();
2488 free_header_files ();
2489 init_header_files ();
2491 processing_acc_compilation = 1;
2493 /* In a coff file, we've already installed the minimal symbols that came
2494 from the coff (non-stab) symbol table, so always act like an
2495 incremental load here. */
2496 if (stabsects->next == NULL)
2498 stabsize = bfd_section_size (sym_bfd, stabsects->section);
2499 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2500 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2504 struct stab_section_list *stabsect;
2506 DBX_SYMCOUNT (objfile) = 0;
2507 for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
2509 stabsize = bfd_section_size (sym_bfd, stabsect->section);
2510 DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
2513 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2515 symbuf_sections = stabsects->next;
2516 symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
2520 dbx_symfile_read (objfile, 0);
2523 /* Scan and build partial symbols for an ELF symbol file.
2524 This ELF file has already been processed to get its minimal symbols,
2525 and any DWARF symbols that were in it.
2527 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2530 OBJFILE is the object file we are reading symbols from.
2531 ADDR is the address relative to which the symbols are (e.g.
2532 the base address of the text segment).
2533 MAINLINE is true if we are reading the main symbol
2534 table (as opposed to a shared lib or dynamically loaded file).
2535 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2537 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2538 .stabstr section exists.
2540 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2541 adjusted for elf details. */
2544 elfstab_build_psymtabs (struct objfile *objfile, int mainline,
2545 file_ptr staboffset, unsigned int stabsize,
2546 file_ptr stabstroffset, unsigned int stabstrsize)
2549 bfd *sym_bfd = objfile->obfd;
2550 char *name = bfd_get_filename (sym_bfd);
2551 struct dbx_symfile_info *info;
2553 /* There is already a dbx_symfile_info allocated by our caller.
2554 It might even contain some info from the ELF symtab to help us. */
2555 info = objfile->sym_stab_info;
2557 /* Find the first and last text address. dbx_symfile_read seems to
2559 find_text_range (sym_bfd, objfile);
2561 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2562 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
2563 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2564 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2565 DBX_SYMTAB_OFFSET (objfile) = staboffset;
2567 if (stabstrsize > bfd_get_size (sym_bfd))
2568 error ("ridiculous string table size: %d bytes", stabstrsize);
2569 DBX_STRINGTAB (objfile) = (char *)
2570 obstack_alloc (&objfile->psymbol_obstack, stabstrsize + 1);
2571 OBJSTAT (objfile, sz_strtab += stabstrsize + 1);
2573 /* Now read in the string table in one big gulp. */
2575 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2577 perror_with_name (name);
2578 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2579 if (val != stabstrsize)
2580 perror_with_name (name);
2582 stabsread_new_init ();
2583 buildsym_new_init ();
2584 free_header_files ();
2585 init_header_files ();
2586 install_minimal_symbols (objfile);
2588 processing_acc_compilation = 1;
2590 /* In an elf file, we've already installed the minimal symbols that came
2591 from the elf (non-stab) symbol table, so always act like an
2592 incremental load here. */
2593 dbx_symfile_read (objfile, 0);
2596 /* Scan and build partial symbols for a file with special sections for stabs
2597 and stabstrings. The file has already been processed to get its minimal
2598 symbols, and any other symbols that might be necessary to resolve GSYMs.
2600 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2603 OBJFILE is the object file we are reading symbols from.
2604 ADDR is the address relative to which the symbols are (e.g. the base address
2605 of the text segment).
2606 MAINLINE is true if we are reading the main symbol table (as opposed to a
2607 shared lib or dynamically loaded file).
2608 STAB_NAME is the name of the section that contains the stabs.
2609 STABSTR_NAME is the name of the section that contains the stab strings.
2611 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2614 stabsect_build_psymtabs (struct objfile *objfile, int mainline, char *stab_name,
2615 char *stabstr_name, char *text_name)
2618 bfd *sym_bfd = objfile->obfd;
2619 char *name = bfd_get_filename (sym_bfd);
2621 asection *stabstrsect;
2622 asection *text_sect;
2624 stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
2625 stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
2631 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2632 stab_name, stabstr_name);
2634 objfile->sym_stab_info = (struct dbx_symfile_info *)
2635 xmalloc (sizeof (struct dbx_symfile_info));
2636 memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
2638 text_sect = bfd_get_section_by_name (sym_bfd, text_name);
2640 error ("Can't find %s section in symbol file", text_name);
2641 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
2642 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
2644 DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
2645 DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
2646 / DBX_SYMBOL_SIZE (objfile);
2647 DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
2648 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2650 if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
2651 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile));
2652 DBX_STRINGTAB (objfile) = (char *)
2653 obstack_alloc (&objfile->psymbol_obstack, DBX_STRINGTAB_SIZE (objfile) + 1);
2654 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1);
2656 /* Now read in the string table in one big gulp. */
2658 val = bfd_get_section_contents (sym_bfd, /* bfd */
2659 stabstrsect, /* bfd section */
2660 DBX_STRINGTAB (objfile), /* input buffer */
2661 0, /* offset into section */
2662 DBX_STRINGTAB_SIZE (objfile)); /* amount to read */
2665 perror_with_name (name);
2667 stabsread_new_init ();
2668 buildsym_new_init ();
2669 free_header_files ();
2670 init_header_files ();
2671 install_minimal_symbols (objfile);
2673 /* Now, do an incremental load */
2675 processing_acc_compilation = 1;
2676 dbx_symfile_read (objfile, 0);
2679 static struct sym_fns aout_sym_fns =
2681 bfd_target_aout_flavour,
2682 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2683 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2684 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2685 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2686 default_symfile_offsets, /* sym_offsets: parse user's offsets to internal form */
2687 NULL /* next: pointer to next struct sym_fns */
2691 _initialize_dbxread (void)
2693 add_symtab_fns (&aout_sym_fns);