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, Boston, MA 02111-1307, USA. */
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
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 */
36 #include "gdb_string.h"
38 #if defined(USG) || defined(__CYGNUSCLIB__)
39 #include <sys/types.h>
47 #include "breakpoint.h"
50 #include "gdbcore.h" /* for bfd stuff */
51 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
55 #include "stabsread.h"
56 #include "gdb-stabs.h"
58 #include "language.h" /* Needed inside partial-stab.h */
59 #include "complaints.h"
61 #include "aout/aout64.h"
62 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
65 /* This macro returns the size field of a minimal symbol, which is normally
66 stored in the "info" field. The macro can be overridden for specific
67 targets (e.g. MIPS16) that use the info field for other purposes. */
69 #define MSYMBOL_SIZE(msym) ((long) MSYMBOL_INFO (msym))
73 /* We put a pointer to this structure in the read_symtab_private field
78 /* Offset within the file symbol table of first local symbol for this
83 /* Length (in bytes) of the section of the symbol table devoted to
84 this file's symbols (actually, the section bracketed may contain
85 more than just this file's symbols). If ldsymlen is 0, the only
86 reason for this thing's existence is the dependency list. Nothing
87 else will happen when it is read in. */
91 /* The size of each symbol in the symbol file (in external form). */
95 /* Further information needed to locate the symbols if they are in
100 int file_string_offset;
103 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
104 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
105 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
106 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
107 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
108 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
109 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
112 /* Remember what we deduced to be the source language of this psymtab. */
114 static enum language psymtab_language = language_unknown;
116 /* Nonzero means give verbose info on gdb action. From main.c. */
118 extern int info_verbose;
120 /* The BFD for this file -- implicit parameter to next_symbol_text. */
122 static bfd *symfile_bfd;
124 /* The size of each symbol in the symbol file (in external form).
125 This is set by dbx_symfile_read when building psymtabs, and by
126 dbx_psymtab_to_symtab when building symtabs. */
128 static unsigned symbol_size;
130 /* This is the offset of the symbol table in the executable file. */
132 static unsigned symbol_table_offset;
134 /* This is the offset of the string table in the executable file. */
136 static unsigned string_table_offset;
138 /* For elf+stab executables, the n_strx field is not a simple index
139 into the string table. Instead, each .o file has a base offset in
140 the string table, and the associated symbols contain offsets from
141 this base. The following two variables contain the base offset for
142 the current and next .o files. */
144 static unsigned int file_string_table_offset;
145 static unsigned int next_file_string_table_offset;
147 /* .o and NLM files contain unrelocated addresses which are based at
148 0. When non-zero, this flag disables some of the special cases for
149 Solaris elf+stab text addresses at location 0. */
151 static int symfile_relocatable = 0;
153 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
154 relative to the function start address. */
156 static int block_address_function_relative = 0;
158 /* The lowest text address we have yet encountered. This is needed
159 because in an a.out file, there is no header field which tells us
160 what address the program is actually going to be loaded at, so we
161 need to make guesses based on the symbols (which *are* relocated to
162 reflect the address it will be loaded at). */
164 static CORE_ADDR lowest_text_address;
166 /* Non-zero if there is any line number info in the objfile. Prevents
167 end_psymtab from discarding an otherwise empty psymtab. */
169 static int has_line_numbers;
171 /* Complaints about the symbols we have encountered. */
173 struct complaint lbrac_complaint =
174 {"bad block start address patched", 0, 0};
176 struct complaint string_table_offset_complaint =
177 {"bad string table offset in symbol %d", 0, 0};
179 struct complaint unknown_symtype_complaint =
180 {"unknown symbol type %s", 0, 0};
182 struct complaint unknown_symchar_complaint =
183 {"unknown symbol descriptor `%c'", 0, 0};
185 struct complaint lbrac_rbrac_complaint =
186 {"block start larger than block end", 0, 0};
188 struct complaint lbrac_unmatched_complaint =
189 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
191 struct complaint lbrac_mismatch_complaint =
192 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
194 struct complaint repeated_header_complaint =
195 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
197 struct complaint unclaimed_bincl_complaint =
198 {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
200 /* find_text_range --- find start and end of loadable code sections
202 The find_text_range function finds the shortest address range that
203 encloses all sections containing executable code, and stores it in
204 objfile's text_addr and text_size members.
206 dbx_symfile_read will use this to finish off the partial symbol
207 table, in some cases. */
210 find_text_range (bfd *sym_bfd, struct objfile *objfile)
214 CORE_ADDR start, end;
216 for (sec = sym_bfd->sections; sec; sec = sec->next)
217 if (bfd_get_section_flags (sym_bfd, sec) & SEC_CODE)
219 CORE_ADDR sec_start = bfd_section_vma (sym_bfd, sec);
220 CORE_ADDR sec_end = sec_start + bfd_section_size (sym_bfd, sec);
224 if (sec_start < start) start = sec_start;
225 if (sec_end > end) end = sec_end;
237 error ("Can't find any code sections in symbol file");
239 DBX_TEXT_ADDR (objfile) = start;
240 DBX_TEXT_SIZE (objfile) = end - start;
245 /* During initial symbol readin, we need to have a structure to keep
246 track of which psymtabs have which bincls in them. This structure
247 is used during readin to setup the list of dependencies within each
248 partial symbol table. */
250 struct header_file_location
252 char *name; /* Name of header file */
253 int instance; /* See above */
254 struct partial_symtab *pst; /* Partial symtab that has the
255 BINCL/EINCL defs for this file */
258 /* The actual list and controling variables */
259 static struct header_file_location *bincl_list, *next_bincl;
260 static int bincls_allocated;
262 /* Local function prototypes */
265 process_now PARAMS ((struct objfile *));
268 free_header_files PARAMS ((void));
271 init_header_files PARAMS ((void));
274 read_ofile_symtab PARAMS ((struct partial_symtab *));
277 dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
280 dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
283 read_dbx_dynamic_symtab PARAMS ((struct section_offsets *,
284 struct objfile *objfile));
287 read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
291 free_bincl_list PARAMS ((struct objfile *));
293 static struct partial_symtab *
294 find_corresponding_bincl_psymtab PARAMS ((char *, int));
297 add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
300 init_bincl_list PARAMS ((int, struct objfile *));
303 dbx_next_symbol_text PARAMS ((struct objfile *));
306 fill_symbuf PARAMS ((bfd *));
309 dbx_symfile_init PARAMS ((struct objfile *));
312 dbx_new_init PARAMS ((struct objfile *));
315 dbx_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
318 dbx_symfile_finish PARAMS ((struct objfile *));
321 record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
324 add_new_header_file PARAMS ((char *, int));
327 add_old_header_file PARAMS ((char *, int));
330 add_this_object_header_file PARAMS ((int));
332 /* Free up old header file tables */
337 if (this_object_header_files)
339 free ((PTR)this_object_header_files);
340 this_object_header_files = NULL;
342 n_allocated_this_object_header_files = 0;
345 /* Allocate new header file tables */
350 n_allocated_this_object_header_files = 10;
351 this_object_header_files = (int *) xmalloc (10 * sizeof (int));
354 /* Add header file number I for this object file
355 at the next successive FILENUM. */
358 add_this_object_header_file (i)
361 if (n_this_object_header_files == n_allocated_this_object_header_files)
363 n_allocated_this_object_header_files *= 2;
364 this_object_header_files
365 = (int *) xrealloc ((char *) this_object_header_files,
366 n_allocated_this_object_header_files * sizeof (int));
369 this_object_header_files[n_this_object_header_files++] = i;
372 /* Add to this file an "old" header file, one already seen in
373 a previous object file. NAME is the header file's name.
374 INSTANCE is its instance code, to select among multiple
375 symbol tables for the same header file. */
378 add_old_header_file (name, instance)
382 register struct header_file *p = HEADER_FILES (current_objfile);
385 for (i = 0; i < N_HEADER_FILES (current_objfile); i++)
386 if (STREQ (p[i].name, name) && instance == p[i].instance)
388 add_this_object_header_file (i);
391 complain (&repeated_header_complaint, name, symnum);
394 /* Add to this file a "new" header file: definitions for its types follow.
395 NAME is the header file's name.
396 Most often this happens only once for each distinct header file,
397 but not necessarily. If it happens more than once, INSTANCE has
398 a different value each time, and references to the header file
399 use INSTANCE values to select among them.
401 dbx output contains "begin" and "end" markers for each new header file,
402 but at this level we just need to know which files there have been;
403 so we record the file when its "begin" is seen and ignore the "end". */
406 add_new_header_file (name, instance)
411 register struct header_file *hfile;
413 /* Make sure there is room for one more header file. */
415 i = N_ALLOCATED_HEADER_FILES (current_objfile);
417 if (N_HEADER_FILES (current_objfile) == i)
421 N_ALLOCATED_HEADER_FILES (current_objfile) = 10;
422 HEADER_FILES (current_objfile) = (struct header_file *)
423 xmalloc (10 * sizeof (struct header_file));
428 N_ALLOCATED_HEADER_FILES (current_objfile) = i;
429 HEADER_FILES (current_objfile) = (struct header_file *)
430 xrealloc ((char *) HEADER_FILES (current_objfile),
431 (i * sizeof (struct header_file)));
435 /* Create an entry for this header file. */
437 i = N_HEADER_FILES (current_objfile)++;
438 hfile = HEADER_FILES (current_objfile) + i;
439 hfile->name = savestring (name, strlen(name));
440 hfile->instance = instance;
443 = (struct type **) xmalloc (10 * sizeof (struct type *));
444 memset (hfile->vector, 0, 10 * sizeof (struct type *));
446 add_this_object_header_file (i);
450 static struct type **
451 explicit_lookup_type (real_filenum, index)
452 int real_filenum, index;
454 register struct header_file *f = &HEADER_FILES (current_objfile)[real_filenum];
456 if (index >= f->length)
459 f->vector = (struct type **)
460 xrealloc (f->vector, f->length * sizeof (struct type *));
461 memset (&f->vector[f->length / 2],
462 '\0', f->length * sizeof (struct type *) / 2);
464 return &f->vector[index];
469 record_minimal_symbol (name, address, type, objfile)
473 struct objfile *objfile;
475 enum minimal_symbol_type ms_type;
477 asection *bfd_section;
483 section = SECT_OFF_TEXT;
484 bfd_section = DBX_TEXT_SECTION (objfile);
488 section = SECT_OFF_DATA;
489 bfd_section = DBX_DATA_SECTION (objfile);
493 section = SECT_OFF_BSS;
494 bfd_section = DBX_BSS_SECTION (objfile);
504 section = SECT_OFF_DATA;
505 bfd_section = DBX_DATA_SECTION (objfile);
508 /* I don't think this type actually exists; since a N_SETV is the result
509 of going over many .o files, it doesn't make sense to have one
511 ms_type = mst_file_data;
512 section = SECT_OFF_DATA;
513 bfd_section = DBX_DATA_SECTION (objfile);
520 ms_type = mst_file_text;
521 section = SECT_OFF_TEXT;
522 bfd_section = DBX_TEXT_SECTION (objfile);
525 ms_type = mst_file_data;
527 /* Check for __DYNAMIC, which is used by Sun shared libraries.
528 Record it as global even if it's local, not global, so
529 lookup_minimal_symbol can find it. We don't check symbol_leading_char
530 because for SunOS4 it always is '_'. */
531 if (name[8] == 'C' && STREQ ("__DYNAMIC", name))
534 /* Same with virtual function tables, both global and static. */
536 char *tempstring = name;
537 if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
539 if (VTBL_PREFIX_P ((tempstring)))
542 section = SECT_OFF_DATA;
543 bfd_section = DBX_DATA_SECTION (objfile);
546 ms_type = mst_file_bss;
547 section = SECT_OFF_BSS;
548 bfd_section = DBX_BSS_SECTION (objfile);
551 ms_type = mst_unknown;
557 if ((ms_type == mst_file_text || ms_type == mst_text)
558 && address < lowest_text_address)
559 lowest_text_address = address;
561 prim_record_minimal_symbol_and_info
562 (name, address, ms_type, NULL, section, bfd_section, objfile);
565 /* Scan and build partial symbols for a symbol file.
566 We have been initialized by a call to dbx_symfile_init, which
567 put all the relevant info into a "struct dbx_symfile_info",
568 hung off the objfile structure.
570 SECTION_OFFSETS contains offsets relative to which the symbols in the
571 various sections are (depending where the sections were actually loaded).
572 MAINLINE is true if we are reading the main symbol
573 table (as opposed to a shared lib or dynamically loaded file). */
576 dbx_symfile_read (objfile, section_offsets, mainline)
577 struct objfile *objfile;
578 struct section_offsets *section_offsets;
579 int mainline; /* FIXME comments above */
583 struct cleanup *back_to;
585 val = strlen (objfile->name);
587 sym_bfd = objfile->obfd;
589 /* .o and .nlm files are relocatables with text, data and bss segs based at
590 0. This flag disables special (Solaris stabs-in-elf only) fixups for
591 symbols with a value of 0. */
593 symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC;
595 /* This is true for Solaris (and all other systems which put stabs
596 in sections, hopefully, since it would be silly to do things
597 differently from Solaris), and false for SunOS4 and other a.out
599 block_address_function_relative =
600 ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3))
601 || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3))
602 || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4))
603 || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2))
604 || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3)));
606 val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
608 perror_with_name (objfile->name);
610 /* If we are reinitializing, or if we have never loaded syms yet, init */
612 || objfile->global_psymbols.size == 0
613 || objfile->static_psymbols.size == 0)
614 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
616 symbol_size = DBX_SYMBOL_SIZE (objfile);
617 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
619 free_pending_blocks ();
620 back_to = make_cleanup ((make_cleanup_func) really_free_pendings, 0);
622 init_minimal_symbol_collection ();
623 make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
625 /* Now that the symbol table data of the executable file are all in core,
626 process them and define symbols accordingly. */
628 read_dbx_symtab (section_offsets, objfile,
629 DBX_TEXT_ADDR (objfile),
630 DBX_TEXT_SIZE (objfile));
632 /* Add the dynamic symbols. */
634 read_dbx_dynamic_symtab (section_offsets, objfile);
636 /* Install any minimal symbols that have been collected as the current
637 minimal symbols for this objfile. */
639 install_minimal_symbols (objfile);
641 do_cleanups (back_to);
644 /* Initialize anything that needs initializing when a completely new
645 symbol file is specified (not just adding some symbols from another
646 file, e.g. a shared library). */
649 dbx_new_init (ignore)
650 struct objfile *ignore;
652 stabsread_new_init ();
653 buildsym_new_init ();
654 init_header_files ();
658 /* dbx_symfile_init ()
659 is the dbx-specific initialization routine for reading symbols.
660 It is passed a struct objfile which contains, among other things,
661 the BFD for the file whose symbols are being read, and a slot for a pointer
662 to "private data" which we fill with goodies.
664 We read the string table into malloc'd space and stash a pointer to it.
666 Since BFD doesn't know how to read debug symbols in a format-independent
667 way (and may never do so...), we have to do it ourselves. We will never
668 be called unless this is an a.out (or very similar) file.
669 FIXME, there should be a cleaner peephole into the BFD environment here. */
671 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
674 dbx_symfile_init (objfile)
675 struct objfile *objfile;
678 bfd *sym_bfd = objfile->obfd;
679 char *name = bfd_get_filename (sym_bfd);
681 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
683 /* Allocate struct to keep track of the symfile */
684 objfile->sym_stab_info = (struct dbx_symfile_info *)
685 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
686 memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
688 DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
689 DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
690 DBX_BSS_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".bss");
692 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
693 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
694 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
696 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
698 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
700 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
702 error ("Can't find .text section in symbol file");
703 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
704 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
706 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
707 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
708 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
710 /* Read the string table and stash it away in the psymbol_obstack. It is
711 only needed as long as we need to expand psymbols into full symbols,
712 so when we blow away the psymbol the string table goes away as well.
713 Note that gdb used to use the results of attempting to malloc the
714 string table, based on the size it read, as a form of sanity check
715 for botched byte swapping, on the theory that a byte swapped string
716 table size would be so totally bogus that the malloc would fail. Now
717 that we put in on the psymbol_obstack, we can't do this since gdb gets
718 a fatal error (out of virtual memory) if the size is bogus. We can
719 however at least check to see if the size is less than the size of
720 the size field itself, or larger than the size of the entire file.
721 Note that all valid string tables have a size greater than zero, since
722 the bytes used to hold the size are included in the count. */
724 if (STRING_TABLE_OFFSET == 0)
726 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
727 will never be zero, even when there is no string table. This
728 would appear to be a bug in bfd. */
729 DBX_STRINGTAB_SIZE (objfile) = 0;
730 DBX_STRINGTAB (objfile) = NULL;
734 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
736 perror_with_name (name);
738 memset ((PTR) size_temp, 0, sizeof (size_temp));
739 val = bfd_read ((PTR) size_temp, sizeof (size_temp), 1, sym_bfd);
742 perror_with_name (name);
746 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
747 EOF if there is no string table, and attempting to read the size
748 from EOF will read zero bytes. */
749 DBX_STRINGTAB_SIZE (objfile) = 0;
750 DBX_STRINGTAB (objfile) = NULL;
754 /* Read some data that would appear to be the string table size.
755 If there really is a string table, then it is probably the right
756 size. Byteswap if necessary and validate the size. Note that
757 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
758 random data that happened to be at STRING_TABLE_OFFSET, because
759 bfd can't tell us there is no string table, the sanity checks may
760 or may not catch this. */
761 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
763 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
764 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
765 error ("ridiculous string table size (%d bytes).",
766 DBX_STRINGTAB_SIZE (objfile));
768 DBX_STRINGTAB (objfile) =
769 (char *) obstack_alloc (&objfile -> psymbol_obstack,
770 DBX_STRINGTAB_SIZE (objfile));
771 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile));
773 /* Now read in the string table in one big gulp. */
775 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
777 perror_with_name (name);
778 val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
780 if (val != DBX_STRINGTAB_SIZE (objfile))
781 perror_with_name (name);
786 /* Perform any local cleanups required when we are done with a particular
787 objfile. I.E, we are in the process of discarding all symbol information
788 for an objfile, freeing up all memory held for it, and unlinking the
789 objfile struct from the global list of known objfiles. */
792 dbx_symfile_finish (objfile)
793 struct objfile *objfile;
795 if (objfile->sym_stab_info != NULL)
797 if (HEADER_FILES (objfile) != NULL)
799 register int i = N_HEADER_FILES (objfile);
800 register struct header_file *hfiles = HEADER_FILES (objfile);
804 free (hfiles [i].name);
805 free (hfiles [i].vector);
809 mfree (objfile -> md, objfile->sym_stab_info);
811 free_header_files ();
815 /* Buffer for reading the symbol table entries. */
816 static struct external_nlist symbuf[4096];
817 static int symbuf_idx;
818 static int symbuf_end;
820 /* cont_elem is used for continuing information in cfront.
821 It saves information about which types need to be fixed up and
822 completed after all the stabs are read. */
825 /* sym and stabsstring for continuing information in cfront */
828 /* state dependancies (statics that must be preserved) */
832 int (*func) PARAMS ((struct objfile *, struct symbol *, char *));
833 /* other state dependancies include:
834 (assumption is that these will not change since process_now FIXME!!)
841 static struct cont_elem *cont_list = 0;
842 static int cont_limit = 0;
843 static int cont_count = 0;
845 /* Arrange for function F to be called with arguments SYM and P later
846 in the stabs reading process. */
848 process_later (sym, p, f)
851 int (*f) PARAMS ((struct objfile *, struct symbol *, char *));
854 /* Allocate more space for the deferred list. */
855 if (cont_count >= cont_limit - 1)
857 cont_limit += 32; /* chunk size */
860 = (struct cont_elem *) xrealloc (cont_list,
862 * sizeof (struct cont_elem)));
864 error ("Virtual memory exhausted\n");
867 /* Save state variables so we can process these stabs later. */
868 cont_list[cont_count].sym_idx = symbuf_idx;
869 cont_list[cont_count].sym_end = symbuf_end;
870 cont_list[cont_count].symnum = symnum;
871 cont_list[cont_count].sym = sym;
872 cont_list[cont_count].stabs = p;
873 cont_list[cont_count].func = f;
877 /* Call deferred funtions in CONT_LIST. */
880 process_now (objfile)
881 struct objfile *objfile;
890 int (*func) PARAMS ((struct objfile *, struct symbol *, char *));
892 /* Save the state of our caller, we'll want to restore it before
894 save_symbuf_idx = symbuf_idx;
895 save_symbuf_end = symbuf_end;
896 save_symnum = symnum;
898 /* Iterate over all the deferred stabs. */
899 for (i = 0; i < cont_count; i++)
901 /* Restore the state for this deferred stab. */
902 symbuf_idx = cont_list[i].sym_idx;
903 symbuf_end = cont_list[i].sym_end;
904 symnum = cont_list[i].symnum;
905 sym = cont_list[i].sym;
906 stabs = cont_list[i].stabs;
907 func = cont_list[i].func;
909 /* Call the function to handle this deferrd stab. */
910 err = (*func) (objfile, sym, stabs);
912 error ("Internal error: unable to resolve stab.\n");
915 /* Restore our caller's state. */
916 symbuf_idx = save_symbuf_idx;
917 symbuf_end = save_symbuf_end;
918 symnum = save_symnum;
923 /* Name of last function encountered. Used in Solaris to approximate
924 object file boundaries. */
925 static char *last_function_name;
927 /* The address in memory of the string table of the object file we are
928 reading (which might not be the "main" object file, but might be a
929 shared library or some other dynamically loaded thing). This is
930 set by read_dbx_symtab when building psymtabs, and by
931 read_ofile_symtab when building symtabs, and is used only by
932 next_symbol_text. FIXME: If that is true, we don't need it when
933 building psymtabs, right? */
934 static char *stringtab_global;
936 /* These variables are used to control fill_symbuf when the stabs
937 symbols are not contiguous (as may be the case when a COFF file is
938 linked using --split-by-reloc). */
939 static struct stab_section_list *symbuf_sections;
940 static unsigned int symbuf_left;
941 static unsigned int symbuf_read;
943 /* Refill the symbol table input buffer
944 and set the variables that control fetching entries from it.
945 Reports an error if no data available.
946 This function can read past the end of the symbol table
947 (into the string table) but this does no harm. */
950 fill_symbuf (sym_bfd)
956 if (symbuf_sections == NULL)
957 count = sizeof (symbuf);
960 if (symbuf_left <= 0)
962 file_ptr filepos = symbuf_sections->section->filepos;
963 if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
964 perror_with_name (bfd_get_filename (sym_bfd));
965 symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
966 symbol_table_offset = filepos - symbuf_read;
967 symbuf_sections = symbuf_sections->next;
971 if (count > sizeof (symbuf))
972 count = sizeof (symbuf);
975 nbytes = bfd_read ((PTR)symbuf, count, 1, sym_bfd);
977 perror_with_name (bfd_get_filename (sym_bfd));
978 else if (nbytes == 0)
979 error ("Premature end of file reading symbol table");
980 symbuf_end = nbytes / symbol_size;
982 symbuf_left -= nbytes;
983 symbuf_read += nbytes;
986 #define SWAP_SYMBOL(symp, abfd) \
988 (symp)->n_strx = bfd_h_get_32(abfd, \
989 (unsigned char *)&(symp)->n_strx); \
990 (symp)->n_desc = bfd_h_get_16 (abfd, \
991 (unsigned char *)&(symp)->n_desc); \
992 (symp)->n_value = bfd_h_get_32 (abfd, \
993 (unsigned char *)&(symp)->n_value); \
996 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
998 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
999 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
1000 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
1001 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
1004 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1005 that hasn't been swapped. Swap the symbol at the same time
1006 that symbuf_idx is incremented. */
1008 /* dbx allows the text of a symbol name to be continued into the
1009 next symbol name! When such a continuation is encountered
1010 (a \ at the end of the text of a name)
1011 call this function to get the continuation. */
1014 dbx_next_symbol_text (objfile)
1015 struct objfile *objfile;
1017 struct internal_nlist nlist;
1019 if (symbuf_idx == symbuf_end)
1020 fill_symbuf (symfile_bfd);
1023 INTERNALIZE_SYMBOL(nlist, &symbuf[symbuf_idx], symfile_bfd);
1024 OBJSTAT (objfile, n_stabs++);
1028 return nlist.n_strx + stringtab_global + file_string_table_offset;
1031 /* Initialize the list of bincls to contain none and have some
1035 init_bincl_list (number, objfile)
1037 struct objfile *objfile;
1039 bincls_allocated = number;
1040 next_bincl = bincl_list = (struct header_file_location *)
1041 xmmalloc (objfile -> md, bincls_allocated * sizeof(struct header_file_location));
1044 /* Add a bincl to the list. */
1047 add_bincl_to_list (pst, name, instance)
1048 struct partial_symtab *pst;
1052 if (next_bincl >= bincl_list + bincls_allocated)
1054 int offset = next_bincl - bincl_list;
1055 bincls_allocated *= 2;
1056 bincl_list = (struct header_file_location *)
1057 xmrealloc (pst->objfile->md, (char *)bincl_list,
1058 bincls_allocated * sizeof (struct header_file_location));
1059 next_bincl = bincl_list + offset;
1061 next_bincl->pst = pst;
1062 next_bincl->instance = instance;
1063 next_bincl++->name = name;
1066 /* Given a name, value pair, find the corresponding
1067 bincl in the list. Return the partial symtab associated
1068 with that header_file_location. */
1070 static struct partial_symtab *
1071 find_corresponding_bincl_psymtab (name, instance)
1075 struct header_file_location *bincl;
1077 for (bincl = bincl_list; bincl < next_bincl; bincl++)
1078 if (bincl->instance == instance
1079 && STREQ (name, bincl->name))
1082 complain (&repeated_header_complaint, name, symnum);
1083 return (struct partial_symtab *) 0;
1086 /* Free the storage allocated for the bincl list. */
1089 free_bincl_list (objfile)
1090 struct objfile *objfile;
1092 mfree (objfile -> md, (PTR)bincl_list);
1093 bincls_allocated = 0;
1096 /* Scan a SunOs dynamic symbol table for symbols of interest and
1097 add them to the minimal symbol table. */
1100 read_dbx_dynamic_symtab (section_offsets, objfile)
1101 struct section_offsets *section_offsets;
1102 struct objfile *objfile;
1104 bfd *abfd = objfile->obfd;
1105 struct cleanup *back_to;
1115 CORE_ADDR sym_value;
1118 /* Check that the symbol file has dynamic symbols that we know about.
1119 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1120 on a sun4 host (and vice versa) and bfd is not configured
1121 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1122 so we ignore the dynamic symbols in this case. */
1123 if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
1124 || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
1125 || bfd_get_arch (abfd) == bfd_arch_unknown)
1128 dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
1129 if (dynsym_size < 0)
1132 dynsyms = (asymbol **) xmalloc (dynsym_size);
1133 back_to = make_cleanup (free, dynsyms);
1135 dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
1136 if (dynsym_count < 0)
1138 do_cleanups (back_to);
1142 /* Enter dynamic symbols into the minimal symbol table
1143 if this is a stripped executable. */
1144 if (bfd_get_symcount (abfd) <= 0)
1147 for (counter = 0; counter < dynsym_count; counter++, symptr++)
1149 asymbol *sym = *symptr;
1153 sec = bfd_get_section (sym);
1155 /* BFD symbols are section relative. */
1156 sym_value = sym->value + sec->vma;
1158 if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
1160 sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1163 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
1165 sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA);
1168 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
1170 sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS);
1176 if (sym->flags & BSF_GLOBAL)
1179 record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value,
1184 /* Symbols from shared libraries have a dynamic relocation entry
1185 that points to the associated slot in the procedure linkage table.
1186 We make a mininal symbol table entry with type mst_solib_trampoline
1187 at the address in the procedure linkage table. */
1188 dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
1189 if (dynrel_size < 0)
1191 do_cleanups (back_to);
1195 dynrels = (arelent **) xmalloc (dynrel_size);
1196 make_cleanup (free, dynrels);
1198 dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
1199 if (dynrel_count < 0)
1201 do_cleanups (back_to);
1205 for (counter = 0, relptr = dynrels;
1206 counter < dynrel_count;
1207 counter++, relptr++)
1209 arelent *rel = *relptr;
1211 rel->address + ANOFFSET (section_offsets, SECT_OFF_DATA);
1213 switch (bfd_get_arch (abfd))
1215 case bfd_arch_sparc:
1216 if (rel->howto->type != RELOC_JMP_SLOT)
1220 /* `16' is the type BFD produces for a jump table relocation. */
1221 if (rel->howto->type != 16)
1224 /* Adjust address in the jump table to point to
1225 the start of the bsr instruction. */
1232 name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr);
1233 prim_record_minimal_symbol (name, address, mst_solib_trampoline,
1237 do_cleanups (back_to);
1240 /* Given pointers to an a.out symbol table in core containing dbx
1241 style data, setup partial_symtab's describing each source file for
1242 which debugging information is available.
1243 SYMFILE_NAME is the name of the file we are reading from
1244 and SECTION_OFFSETS is the set of offsets for the various sections
1245 of the file (a set of zeros if the mainline program). */
1248 read_dbx_symtab (section_offsets, objfile, text_addr, text_size)
1249 struct section_offsets *section_offsets;
1250 struct objfile *objfile;
1251 CORE_ADDR text_addr;
1254 register struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */
1255 struct internal_nlist nlist;
1257 register char *namestring;
1259 int past_first_source_file = 0;
1260 CORE_ADDR last_o_file_start = 0;
1261 CORE_ADDR last_function_start = 0;
1262 struct cleanup *back_to;
1264 int textlow_not_set;
1266 /* Current partial symtab */
1267 struct partial_symtab *pst;
1269 /* List of current psymtab's include files */
1270 char **psymtab_include_list;
1271 int includes_allocated;
1274 /* Index within current psymtab dependency list */
1275 struct partial_symtab **dependency_list;
1276 int dependencies_used, dependencies_allocated;
1278 /* FIXME. We probably want to change stringtab_global rather than add this
1279 while processing every symbol entry. FIXME. */
1280 file_string_table_offset = 0;
1281 next_file_string_table_offset = 0;
1283 stringtab_global = DBX_STRINGTAB (objfile);
1285 pst = (struct partial_symtab *) 0;
1287 includes_allocated = 30;
1289 psymtab_include_list = (char **) alloca (includes_allocated *
1292 dependencies_allocated = 30;
1293 dependencies_used = 0;
1295 (struct partial_symtab **) alloca (dependencies_allocated *
1296 sizeof (struct partial_symtab *));
1298 /* Init bincl list */
1299 init_bincl_list (20, objfile);
1300 back_to = make_cleanup ((make_cleanup_func) free_bincl_list, objfile);
1302 last_source_file = NULL;
1304 lowest_text_address = (CORE_ADDR)-1;
1306 symfile_bfd = objfile->obfd; /* For next_text_symbol */
1307 abfd = objfile->obfd;
1308 symbuf_end = symbuf_idx = 0;
1309 next_symbol_text_func = dbx_next_symbol_text;
1310 textlow_not_set = 1;
1311 has_line_numbers = 0;
1313 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1315 /* Get the symbol for this run and pull out some info */
1316 QUIT; /* allow this to be interruptable */
1317 if (symbuf_idx == symbuf_end)
1319 bufp = &symbuf[symbuf_idx++];
1322 * Special case to speed up readin.
1324 if (bfd_h_get_8 (abfd, bufp->e_type) == N_SLINE)
1326 has_line_numbers = 1;
1330 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1331 OBJSTAT (objfile, n_stabs++);
1333 /* Ok. There is a lot of code duplicated in the rest of this
1334 switch statement (for efficiency reasons). Since I don't
1335 like duplicating code, I will do my penance here, and
1336 describe the code which is duplicated:
1338 *) The assignment to namestring.
1339 *) The call to strchr.
1340 *) The addition of a partial symbol the the two partial
1341 symbol lists. This last is a large section of code, so
1342 I've imbedded it in the following macro.
1345 /* Set namestring based on nlist. If the string table index is invalid,
1346 give a fake name, and print a single error message per symbol file read,
1347 rather than abort the symbol reading or flood the user with messages. */
1349 /*FIXME: Too many adds and indirections in here for the inner loop. */
1350 #define SET_NAMESTRING()\
1351 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1352 DBX_STRINGTAB_SIZE (objfile)) { \
1353 complain (&string_table_offset_complaint, symnum); \
1354 namestring = "<bad string table offset>"; \
1356 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1357 DBX_STRINGTAB (objfile)
1359 #define CUR_SYMBOL_TYPE nlist.n_type
1360 #define CUR_SYMBOL_VALUE nlist.n_value
1361 #define CUR_SYMBOL_STRX nlist.n_strx
1362 #define DBXREAD_ONLY
1363 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1364 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1365 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1366 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1368 #include "partial-stab.h"
1371 /* If there's stuff to be cleaned up, clean it up. */
1372 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
1373 /*FIXME, does this have a bug at start address 0? */
1374 && last_o_file_start
1375 && objfile -> ei.entry_point < nlist.n_value
1376 && objfile -> ei.entry_point >= last_o_file_start)
1378 objfile -> ei.entry_file_lowpc = last_o_file_start;
1379 objfile -> ei.entry_file_highpc = nlist.n_value;
1384 /* Don't set pst->texthigh lower than it already is. */
1385 CORE_ADDR text_end =
1386 (lowest_text_address == (CORE_ADDR)-1
1387 ? (text_addr + section_offsets->offsets[SECT_OFF_TEXT])
1388 : lowest_text_address)
1391 end_psymtab (pst, psymtab_include_list, includes_used,
1392 symnum * symbol_size,
1393 text_end > pst->texthigh ? text_end : pst->texthigh,
1394 dependency_list, dependencies_used, textlow_not_set);
1397 do_cleanups (back_to);
1400 /* Allocate and partially fill a partial symtab. It will be
1401 completely filled at the end of the symbol list.
1403 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1404 is the address relative to which its symbols are (incremental) or 0
1408 struct partial_symtab *
1409 start_psymtab (objfile, section_offsets,
1410 filename, textlow, ldsymoff, global_syms, static_syms)
1411 struct objfile *objfile;
1412 struct section_offsets *section_offsets;
1416 struct partial_symbol **global_syms;
1417 struct partial_symbol **static_syms;
1419 struct partial_symtab *result =
1420 start_psymtab_common(objfile, section_offsets,
1421 filename, textlow, global_syms, static_syms);
1423 result->read_symtab_private = (char *)
1424 obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
1425 LDSYMOFF(result) = ldsymoff;
1426 result->read_symtab = dbx_psymtab_to_symtab;
1427 SYMBOL_SIZE(result) = symbol_size;
1428 SYMBOL_OFFSET(result) = symbol_table_offset;
1429 STRING_OFFSET(result) = string_table_offset;
1430 FILE_STRING_OFFSET(result) = file_string_table_offset;
1432 /* If we're handling an ELF file, drag some section-relocation info
1433 for this source file out of the ELF symbol table, to compensate for
1434 Sun brain death. This replaces the section_offsets in this psymtab,
1436 elfstab_offset_sections (objfile, result);
1438 /* Deduce the source language from the filename for this psymtab. */
1439 psymtab_language = deduce_language_from_filename (filename);
1444 /* Close off the current usage of PST.
1445 Returns PST or NULL if the partial symtab was empty and thrown away.
1447 FIXME: List variables and peculiarities of same. */
1449 struct partial_symtab *
1450 end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
1451 capping_text, dependency_list, number_dependencies, textlow_not_set)
1452 struct partial_symtab *pst;
1453 char **include_list;
1455 int capping_symbol_offset;
1456 CORE_ADDR capping_text;
1457 struct partial_symtab **dependency_list;
1458 int number_dependencies;
1459 int textlow_not_set;
1462 struct objfile *objfile = pst -> objfile;
1464 if (capping_symbol_offset != -1)
1465 LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
1466 pst->texthigh = capping_text;
1468 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1469 /* Under Solaris, the N_SO symbols always have a value of 0,
1470 instead of the usual address of the .o file. Therefore,
1471 we have to do some tricks to fill in texthigh and textlow.
1472 The first trick is in partial-stab.h: if we see a static
1473 or global function, and the textlow for the current pst
1474 is not set (ie: textlow_not_set), then we use that function's
1475 address for the textlow of the pst. */
1477 /* Now, to fill in texthigh, we remember the last function seen
1478 in the .o file (also in partial-stab.h). Also, there's a hack in
1479 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1480 to here via the misc_info field. Therefore, we can fill in
1481 a reliable texthigh by taking the address plus size of the
1482 last function in the file. */
1484 if (pst->texthigh == 0 && last_function_name)
1488 struct minimal_symbol *minsym;
1490 p = strchr (last_function_name, ':');
1492 p = last_function_name;
1493 n = p - last_function_name;
1495 strncpy (p, last_function_name, n);
1498 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1501 /* Sun Fortran appends an underscore to the minimal symbol name,
1502 try again with an appended underscore if the minimal symbol
1506 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1510 pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
1512 last_function_name = NULL;
1515 /* this test will be true if the last .o file is only data */
1516 if (textlow_not_set)
1517 pst->textlow = pst->texthigh;
1520 struct partial_symtab *p1;
1522 /* If we know our own starting text address, then walk through all other
1523 psymtabs for this objfile, and if any didn't know their ending text
1524 address, set it to our starting address. Take care to not set our
1525 own ending address to our starting address, nor to set addresses on
1526 `dependency' files that have both textlow and texthigh zero. */
1528 ALL_OBJFILE_PSYMTABS (objfile, p1)
1530 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst)
1532 p1->texthigh = pst->textlow;
1533 /* if this file has only data, then make textlow match texthigh */
1534 if (p1->textlow == 0)
1535 p1->textlow = p1->texthigh;
1540 /* End of kludge for patching Solaris textlow and texthigh. */
1541 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1543 pst->n_global_syms =
1544 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1545 pst->n_static_syms =
1546 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1548 pst->number_of_dependencies = number_dependencies;
1549 if (number_dependencies)
1551 pst->dependencies = (struct partial_symtab **)
1552 obstack_alloc (&objfile->psymbol_obstack,
1553 number_dependencies * sizeof (struct partial_symtab *));
1554 memcpy (pst->dependencies, dependency_list,
1555 number_dependencies * sizeof (struct partial_symtab *));
1558 pst->dependencies = 0;
1560 for (i = 0; i < num_includes; i++)
1562 struct partial_symtab *subpst =
1563 allocate_psymtab (include_list[i], objfile);
1565 subpst->section_offsets = pst->section_offsets;
1566 subpst->read_symtab_private =
1567 (char *) obstack_alloc (&objfile->psymbol_obstack,
1568 sizeof (struct symloc));
1572 subpst->texthigh = 0;
1574 /* We could save slight bits of space by only making one of these,
1575 shared by the entire set of include files. FIXME-someday. */
1576 subpst->dependencies = (struct partial_symtab **)
1577 obstack_alloc (&objfile->psymbol_obstack,
1578 sizeof (struct partial_symtab *));
1579 subpst->dependencies[0] = pst;
1580 subpst->number_of_dependencies = 1;
1582 subpst->globals_offset =
1583 subpst->n_global_syms =
1584 subpst->statics_offset =
1585 subpst->n_static_syms = 0;
1589 subpst->read_symtab = pst->read_symtab;
1592 sort_pst_symbols (pst);
1594 /* If there is already a psymtab or symtab for a file of this name, remove it.
1595 (If there is a symtab, more drastic things also happen.)
1596 This happens in VxWorks. */
1597 free_named_symtabs (pst->filename);
1599 if (num_includes == 0
1600 && number_dependencies == 0
1601 && pst->n_global_syms == 0
1602 && pst->n_static_syms == 0
1603 && has_line_numbers == 0)
1605 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1606 it is on the obstack, but we can forget to chain it on the list. */
1607 /* Empty psymtabs happen as a result of header files which don't have
1608 any symbols in them. There can be a lot of them. But this check
1609 is wrong, in that a psymtab with N_SLINE entries but nothing else
1610 is not empty, but we don't realize that. Fixing that without slowing
1611 things down might be tricky. */
1613 discard_psymtab (pst);
1615 /* Indicate that psymtab was thrown away. */
1616 pst = (struct partial_symtab *)NULL;
1622 dbx_psymtab_to_symtab_1 (pst)
1623 struct partial_symtab *pst;
1625 struct cleanup *old_chain;
1633 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1638 /* Read in all partial symtabs on which this one is dependent */
1639 for (i = 0; i < pst->number_of_dependencies; i++)
1640 if (!pst->dependencies[i]->readin)
1642 /* Inform about additional files that need to be read in. */
1645 fputs_filtered (" ", gdb_stdout);
1647 fputs_filtered ("and ", gdb_stdout);
1649 printf_filtered ("%s...", pst->dependencies[i]->filename);
1650 wrap_here (""); /* Flush output */
1651 gdb_flush (gdb_stdout);
1653 dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1656 if (LDSYMLEN(pst)) /* Otherwise it's a dummy */
1658 /* Init stuff necessary for reading in symbols */
1661 old_chain = make_cleanup ((make_cleanup_func) really_free_pendings, 0);
1662 file_string_table_offset = FILE_STRING_OFFSET (pst);
1663 symbol_size = SYMBOL_SIZE (pst);
1665 /* Read in this file's symbols */
1666 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
1667 read_ofile_symtab (pst);
1668 sort_symtab_syms (pst->symtab);
1670 do_cleanups (old_chain);
1676 /* Read in all of the symbols for a given psymtab for real.
1677 Be verbose about it if the user wants that. */
1680 dbx_psymtab_to_symtab (pst)
1681 struct partial_symtab *pst;
1690 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1695 if (LDSYMLEN(pst) || pst->number_of_dependencies)
1697 /* Print the message now, before reading the string table,
1698 to avoid disconcerting pauses. */
1701 printf_filtered ("Reading in symbols for %s...", pst->filename);
1702 gdb_flush (gdb_stdout);
1705 sym_bfd = pst->objfile->obfd;
1707 next_symbol_text_func = dbx_next_symbol_text;
1709 dbx_psymtab_to_symtab_1 (pst);
1711 /* Match with global symbols. This only needs to be done once,
1712 after all of the symtabs and dependencies have been read in. */
1713 scan_file_globals (pst->objfile);
1715 /* Finish up the debug error message. */
1717 printf_filtered ("done.\n");
1721 /* Read in a defined section of a specific object file's symbols. */
1724 read_ofile_symtab (pst)
1725 struct partial_symtab *pst;
1727 register char *namestring;
1728 register struct external_nlist *bufp;
1729 struct internal_nlist nlist;
1731 unsigned max_symnum;
1733 struct objfile *objfile;
1734 int sym_offset; /* Offset to start of symbols to read */
1735 int sym_size; /* Size of symbols to read */
1736 CORE_ADDR text_offset; /* Start of text segment for symbols */
1737 int text_size; /* Size of text segment for symbols */
1738 struct section_offsets *section_offsets;
1740 objfile = pst->objfile;
1741 sym_offset = LDSYMOFF(pst);
1742 sym_size = LDSYMLEN(pst);
1743 text_offset = pst->textlow;
1744 text_size = pst->texthigh - pst->textlow;
1745 section_offsets = pst->section_offsets;
1747 current_objfile = objfile;
1748 subfile_stack = NULL;
1750 stringtab_global = DBX_STRINGTAB (objfile);
1751 last_source_file = NULL;
1753 abfd = objfile->obfd;
1754 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
1755 symbuf_end = symbuf_idx = 0;
1757 /* It is necessary to actually read one symbol *before* the start
1758 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1759 occurs before the N_SO symbol.
1761 Detecting this in read_dbx_symtab
1762 would slow down initial readin, so we look for it here instead. */
1763 if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1765 bfd_seek (symfile_bfd, sym_offset - symbol_size, SEEK_CUR);
1767 bufp = &symbuf[symbuf_idx++];
1768 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1769 OBJSTAT (objfile, n_stabs++);
1773 processing_gcc_compilation = 0;
1774 if (nlist.n_type == N_TEXT)
1776 const char *tempstring = namestring;
1778 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1779 processing_gcc_compilation = 1;
1780 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1781 processing_gcc_compilation = 2;
1782 if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
1784 if (STREQN (tempstring, "__gnu_compiled", 14))
1785 processing_gcc_compilation = 2;
1788 /* Try to select a C++ demangling based on the compilation unit
1791 if (processing_gcc_compilation)
1793 if (AUTO_DEMANGLING)
1795 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1801 /* The N_SO starting this symtab is the first symbol, so we
1802 better not check the symbol before it. I'm not this can
1803 happen, but it doesn't hurt to check for it. */
1804 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
1805 processing_gcc_compilation = 0;
1808 if (symbuf_idx == symbuf_end)
1810 bufp = &symbuf[symbuf_idx];
1811 if (bfd_h_get_8 (abfd, bufp->e_type) != N_SO)
1812 error("First symbol in segment of executable not a source symbol");
1814 max_symnum = sym_size / symbol_size;
1817 symnum < max_symnum;
1820 QUIT; /* Allow this to be interruptable */
1821 if (symbuf_idx == symbuf_end)
1823 bufp = &symbuf[symbuf_idx++];
1824 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1825 OBJSTAT (objfile, n_stabs++);
1827 type = bfd_h_get_8 (abfd, bufp->e_type);
1831 if (type & N_STAB) {
1832 process_one_symbol (type, nlist.n_desc, nlist.n_value,
1833 namestring, section_offsets, objfile);
1835 /* We skip checking for a new .o or -l file; that should never
1836 happen in this routine. */
1837 else if (type == N_TEXT)
1839 /* I don't think this code will ever be executed, because
1840 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1841 the N_SO symbol which starts this source file.
1842 However, there is no reason not to accept
1843 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1845 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1846 processing_gcc_compilation = 1;
1847 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1848 processing_gcc_compilation = 2;
1850 if (AUTO_DEMANGLING)
1852 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1855 else if (type & N_EXT || type == (unsigned char)N_TEXT
1856 || type == (unsigned char)N_NBTEXT
1858 /* Global symbol: see if we came across a dbx defintion for
1859 a corresponding symbol. If so, store the value. Remove
1860 syms from the chain when their values are stored, but
1861 search the whole chain, as there may be several syms from
1862 different files with the same name. */
1863 /* This is probably not true. Since the files will be read
1864 in one at a time, each reference to a global symbol will
1865 be satisfied in each file as it appears. So we skip this
1871 current_objfile = NULL;
1873 /* In a Solaris elf file, this variable, which comes from the
1874 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1875 which comes from pst->textlow is correct. */
1876 if (last_source_start_addr == 0)
1877 last_source_start_addr = text_offset;
1879 /* In reordered executables last_source_start_addr may not be the
1880 lower bound for this symtab, instead use text_offset which comes
1881 from pst->textlow which is correct. */
1882 if (last_source_start_addr > text_offset)
1883 last_source_start_addr = text_offset;
1885 pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT);
1887 /* Process items which we had to "process_later" due to dependancies
1889 process_now (objfile);
1895 /* This handles a single symbol from the symbol-file, building symbols
1896 into a GDB symtab. It takes these arguments and an implicit argument.
1898 TYPE is the type field of the ".stab" symbol entry.
1899 DESC is the desc field of the ".stab" entry.
1900 VALU is the value field of the ".stab" entry.
1901 NAME is the symbol name, in our address space.
1902 SECTION_OFFSETS is a set of amounts by which the sections of this object
1903 file were relocated when it was loaded into memory.
1904 All symbols that refer
1905 to memory locations need to be offset by these amounts.
1906 OBJFILE is the object file from which we are reading symbols.
1907 It is used in end_symtab. */
1910 process_one_symbol (type, desc, valu, name, section_offsets, objfile)
1914 struct section_offsets *section_offsets;
1915 struct objfile *objfile;
1917 #ifdef SUN_FIXED_LBRAC_BUG
1918 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1919 to correct the address of N_LBRAC's. If it is not defined, then
1920 we never need to correct the addresses. */
1922 /* This records the last pc address we've seen. We depend on there being
1923 an SLINE or FUN or SO before the first LBRAC, since the variable does
1924 not get reset in between reads of different symbol files. */
1925 static CORE_ADDR last_pc_address;
1928 register struct context_stack *new;
1929 /* This remembers the address of the start of a function. It is used
1930 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1931 relative to the current function's start address. On systems
1932 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1933 used to relocate these symbol types rather than SECTION_OFFSETS. */
1934 static CORE_ADDR function_start_offset;
1936 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1937 file. Used to detect the SunPRO solaris compiler. */
1938 static int n_opt_found;
1940 /* The stab type used for the definition of the last function.
1941 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1942 static int function_stab_type = 0;
1944 if (!block_address_function_relative)
1945 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1946 function start address, so just use the text offset. */
1947 function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
1949 /* Something is wrong if we see real data before
1950 seeing a source file name. */
1952 if (last_source_file == NULL && type != (unsigned char)N_SO)
1954 /* Ignore any symbols which appear before an N_SO symbol.
1955 Currently no one puts symbols there, but we should deal
1956 gracefully with the case. A complain()t might be in order,
1957 but this should not be an error (). */
1966 if (*name == '\000')
1968 /* This N_FUN marks the end of a function. This closes off the
1970 within_function = 0;
1971 new = pop_context ();
1973 /* Make a block for the local symbols within. */
1974 finish_block (new->name, &local_symbols, new->old_blocks,
1975 new->start_addr, new->start_addr + valu,
1978 /* May be switching to an assembler file which may not be using
1979 block relative stabs, so reset the offset. */
1980 if (block_address_function_relative)
1981 function_start_offset = 0;
1986 /* Relocate for dynamic loading */
1987 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1988 #ifdef SMASH_TEXT_ADDRESS
1989 SMASH_TEXT_ADDRESS (valu);
1991 goto define_a_symbol;
1994 /* This "symbol" just indicates the start of an inner lexical
1995 context within a function. */
1997 /* Ignore extra outermost context from SunPRO cc and acc. */
1998 if (n_opt_found && desc == 1)
2001 if (block_address_function_relative)
2002 /* Relocate for Sun ELF acc fn-relative syms. */
2003 valu += function_start_offset;
2005 /* On most machines, the block addresses are relative to the
2006 N_SO, the linker did not relocate them (sigh). */
2007 valu += last_source_start_addr;
2009 #ifdef SUN_FIXED_LBRAC_BUG
2010 if (!SUN_FIXED_LBRAC_BUG && valu < last_pc_address) {
2011 /* Patch current LBRAC pc value to match last handy pc value */
2012 complain (&lbrac_complaint);
2013 valu = last_pc_address;
2016 new = push_context (desc, valu);
2020 /* This "symbol" just indicates the end of an inner lexical
2021 context that was started with N_LBRAC. */
2023 /* Ignore extra outermost context from SunPRO cc and acc. */
2024 if (n_opt_found && desc == 1)
2027 if (block_address_function_relative)
2028 /* Relocate for Sun ELF acc fn-relative syms. */
2029 valu += function_start_offset;
2031 /* On most machines, the block addresses are relative to the
2032 N_SO, the linker did not relocate them (sigh). */
2033 valu += last_source_start_addr;
2035 new = pop_context();
2036 if (desc != new->depth)
2037 complain (&lbrac_mismatch_complaint, symnum);
2039 /* Some compilers put the variable decls inside of an
2040 LBRAC/RBRAC block. This macro should be nonzero if this
2041 is true. DESC is N_DESC from the N_RBRAC symbol.
2042 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2043 or the GCC2_COMPILED_SYMBOL. */
2044 #if !defined (VARIABLES_INSIDE_BLOCK)
2045 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2048 /* Can only use new->locals as local symbols here if we're in
2049 gcc or on a machine that puts them before the lbrack. */
2050 if (!VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
2051 local_symbols = new->locals;
2053 if (context_stack_depth
2054 > !VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
2056 /* This is not the outermost LBRAC...RBRAC pair in the function,
2057 its local symbols preceded it, and are the ones just recovered
2058 from the context stack. Define the block for them (but don't
2059 bother if the block contains no symbols. Should we complain
2060 on blocks without symbols? I can't think of any useful purpose
2062 if (local_symbols != NULL)
2064 /* Muzzle a compiler bug that makes end < start. (which
2065 compilers? Is this ever harmful?). */
2066 if (new->start_addr > valu)
2068 complain (&lbrac_rbrac_complaint);
2069 new->start_addr = valu;
2071 /* Make a block for the local symbols within. */
2072 finish_block (0, &local_symbols, new->old_blocks,
2073 new->start_addr, valu, objfile);
2078 /* This is the outermost LBRAC...RBRAC pair. There is no
2079 need to do anything; leave the symbols that preceded it
2080 to be attached to the function's own block. We need to
2081 indicate that we just moved outside of the function. */
2082 within_function = 0;
2085 if (VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
2086 /* Now pop locals of block just finished. */
2087 local_symbols = new->locals;
2092 /* This kind of symbol indicates the start of an object file. */
2093 /* Relocate for dynamic loading */
2094 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2098 /* This type of symbol indicates the start of data
2099 for one source file.
2100 Finish the symbol table of the previous source file
2101 (if any) and start accumulating a new symbol table. */
2102 /* Relocate for dynamic loading */
2103 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2107 #ifdef SUN_FIXED_LBRAC_BUG
2108 last_pc_address = valu; /* Save for SunOS bug circumcision */
2111 #ifdef PCC_SOL_BROKEN
2112 /* pcc bug, occasionally puts out SO for SOL. */
2113 if (context_stack_depth > 0)
2115 start_subfile (name, NULL);
2119 if (last_source_file)
2121 /* Check if previous symbol was also an N_SO (with some
2122 sanity checks). If so, that one was actually the directory
2123 name, and the current one is the real file name.
2125 if (previous_stab_code == (unsigned char) N_SO)
2127 patch_subfile_names (current_subfile, name);
2128 break; /* Ignore repeated SOs */
2130 end_symtab (valu, objfile, SECT_OFF_TEXT);
2134 /* Null name means this just marks the end of text for this .o file.
2135 Don't start a new symtab in this case. */
2136 if (*name == '\000')
2139 if (block_address_function_relative)
2140 function_start_offset = 0;
2143 start_symtab (name, NULL, valu);
2144 record_debugformat ("stabs");
2148 /* This type of symbol indicates the start of data for
2149 a sub-source-file, one whose contents were copied or
2150 included in the compilation of the main source file
2151 (whose name was given in the N_SO symbol.) */
2152 /* Relocate for dynamic loading */
2153 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2154 start_subfile (name, current_subfile->dirname);
2159 add_new_header_file (name, valu);
2160 start_subfile (name, current_subfile->dirname);
2164 start_subfile (pop_subfile (), current_subfile->dirname);
2168 add_old_header_file (name, valu);
2172 /* This type of "symbol" really just records
2173 one line-number -- core-address correspondence.
2174 Enter it in the line list for this symbol table. */
2176 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2177 valu += function_start_offset;
2179 #ifdef SUN_FIXED_LBRAC_BUG
2180 last_pc_address = valu; /* Save for SunOS bug circumcision */
2182 record_line (current_subfile, desc, valu);
2186 common_block_start (name, objfile);
2190 common_block_end (objfile);
2193 /* The following symbol types need to have the appropriate offset added
2194 to their value; then we process symbol definitions in the name. */
2196 case N_STSYM: /* Static symbol in data seg */
2197 case N_LCSYM: /* Static symbol in BSS seg */
2198 case N_ROSYM: /* Static symbol in Read-only data seg */
2199 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2200 Solaris2's stabs-in-elf makes *most* symbols relative
2201 but leaves a few absolute (at least for Solaris 2.1 and version
2202 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2203 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2204 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2205 This leaves us no choice but to search for the 'S' or 'V'...
2206 (or pass the whole section_offsets stuff down ONE MORE function
2207 call level, which we really don't want to do). */
2211 /* .o files and NLMs have non-zero text seg offsets, but don't need
2212 their static syms offset in this fashion. XXX - This is really a
2213 crock that should be fixed in the solib handling code so that I
2214 don't have to work around it here. */
2216 if (!symfile_relocatable)
2218 p = strchr (name, ':');
2219 if (p != 0 && p[1] == 'S')
2221 /* The linker relocated it. We don't want to add an
2222 elfstab_offset_sections-type offset, but we *do* want
2223 to add whatever solib.c passed to symbol_file_add as
2224 addr (this is known to affect SunOS4, and I suspect ELF
2225 too). Since elfstab_offset_sections currently does not
2226 muck with the text offset (there is no Ttext.text
2227 symbol), we can get addr from the text offset. If
2228 elfstab_offset_sections ever starts dealing with the
2229 text offset, and we still need to do this, we need to
2230 invent a SECT_OFF_ADDR_KLUDGE or something. */
2231 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2232 goto define_a_symbol;
2235 /* Since it's not the kludge case, re-dispatch to the right handler. */
2237 case N_STSYM: goto case_N_STSYM;
2238 case N_LCSYM: goto case_N_LCSYM;
2239 case N_ROSYM: goto case_N_ROSYM;
2244 case_N_STSYM: /* Static symbol in data seg */
2245 case N_DSLINE: /* Source line number, data seg */
2246 valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
2247 goto define_a_symbol;
2249 case_N_LCSYM: /* Static symbol in BSS seg */
2250 case N_BSLINE: /* Source line number, bss seg */
2251 /* N_BROWS: overlaps with N_BSLINE */
2252 valu += ANOFFSET (section_offsets, SECT_OFF_BSS);
2253 goto define_a_symbol;
2255 case_N_ROSYM: /* Static symbol in Read-only data seg */
2256 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA);
2257 goto define_a_symbol;
2259 case N_ENTRY: /* Alternate entry point */
2260 /* Relocate for dynamic loading */
2261 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2262 goto define_a_symbol;
2264 /* The following symbol types we don't know how to process. Handle
2265 them in a "default" way, but complain to people who care. */
2267 case N_CATCH: /* Exception handler catcher */
2268 case N_EHDECL: /* Exception handler name */
2269 case N_PC: /* Global symbol in Pascal */
2270 case N_M2C: /* Modula-2 compilation unit */
2271 /* N_MOD2: overlaps with N_EHDECL */
2272 case N_SCOPE: /* Modula-2 scope information */
2273 case N_ECOML: /* End common (local name) */
2274 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
2279 complain (&unknown_symtype_complaint, local_hex_string (type));
2282 /* The following symbol types don't need the address field relocated,
2283 since it is either unused, or is absolute. */
2285 case N_GSYM: /* Global variable */
2286 case N_NSYMS: /* Number of symbols (ultrix) */
2287 case N_NOMAP: /* No map? (ultrix) */
2288 case N_RSYM: /* Register variable */
2289 case N_DEFD: /* Modula-2 GNU module dependency */
2290 case N_SSYM: /* Struct or union element */
2291 case N_LSYM: /* Local symbol in stack */
2292 case N_PSYM: /* Parameter variable */
2293 case N_LENG: /* Length of preceding symbol type */
2297 char *colon_pos = strchr (name, ':');
2298 if (colon_pos == NULL)
2301 deftype = colon_pos[1];
2307 function_stab_type = type;
2309 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2310 /* Deal with the SunPRO 3.0 compiler which omits the address
2311 from N_FUN symbols. */
2313 && valu == ANOFFSET (section_offsets, SECT_OFF_TEXT))
2315 struct minimal_symbol *msym;
2319 p = strchr (name, ':');
2324 strncpy (p, name, n);
2327 msym = lookup_minimal_symbol (p, last_source_file,
2331 /* Sun Fortran appends an underscore to the minimal
2332 symbol name, try again with an appended underscore
2333 if the minimal symbol was not found. */
2336 msym = lookup_minimal_symbol (p, last_source_file,
2340 valu = SYMBOL_VALUE_ADDRESS (msym);
2344 #ifdef SUN_FIXED_LBRAC_BUG
2345 /* The Sun acc compiler, under SunOS4, puts out
2346 functions with N_GSYM or N_STSYM. The problem is
2347 that the address of the symbol is no good (for N_GSYM
2348 it doesn't even attept an address; for N_STSYM it
2349 puts out an address but then it gets relocated
2350 relative to the data segment, not the text segment).
2351 Currently we can't fix this up later as we do for
2352 some types of symbol in scan_file_globals.
2353 Fortunately we do have a way of finding the address -
2354 we know that the value in last_pc_address is either
2355 the one we want (if we're dealing with the first
2356 function in an object file), or somewhere in the
2357 previous function. This means that we can use the
2358 minimal symbol table to get the address. */
2360 /* Starting with release 3.0, the Sun acc compiler,
2361 under SunOS4, puts out functions with N_FUN and a value
2362 of zero. This gets relocated to the start of the text
2363 segment of the module, which is no good either.
2364 Under SunOS4 we can deal with this as N_SLINE and N_SO
2365 entries contain valid absolute addresses.
2366 Release 3.0 acc also puts out N_OPT entries, which makes
2367 it possible to discern acc from cc or gcc. */
2369 if (type == N_GSYM || type == N_STSYM
2371 && n_opt_found && !block_address_function_relative))
2373 struct minimal_symbol *m;
2374 int l = colon_pos - name;
2376 m = lookup_minimal_symbol_by_pc (last_pc_address);
2377 if (m && STREQN (SYMBOL_NAME (m), name, l)
2378 && SYMBOL_NAME (m) [l] == '\0')
2379 /* last_pc_address was in this function */
2380 valu = SYMBOL_VALUE (m);
2381 else if (m && SYMBOL_NAME (m+1)
2382 && STREQN (SYMBOL_NAME (m+1), name, l)
2383 && SYMBOL_NAME (m+1) [l] == '\0')
2384 /* last_pc_address was in last function */
2385 valu = SYMBOL_VALUE (m+1);
2387 /* Not found - use last_pc_address (for finish_block) */
2388 valu = last_pc_address;
2391 last_pc_address = valu; /* Save for SunOS bug circumcision */
2394 if (block_address_function_relative)
2395 /* For Solaris 2.0 compilers, the block addresses and
2396 N_SLINE's are relative to the start of the
2397 function. On normal systems, and when using gcc on
2398 Solaris 2.0, these addresses are just absolute, or
2399 relative to the N_SO, depending on
2400 BLOCK_ADDRESS_ABSOLUTE. */
2401 function_start_offset = valu;
2403 within_function = 1;
2404 if (context_stack_depth > 0)
2406 new = pop_context ();
2407 /* Make a block for the local symbols within. */
2408 finish_block (new->name, &local_symbols, new->old_blocks,
2409 new->start_addr, valu, objfile);
2411 /* Stack must be empty now. */
2412 if (context_stack_depth != 0)
2413 complain (&lbrac_unmatched_complaint, symnum);
2415 new = push_context (0, valu);
2416 new->name = define_symbol (valu, name, desc, type, objfile);
2420 define_symbol (valu, name, desc, type, objfile);
2426 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2427 for a bunch of other flags, too. Someday we may parse their
2428 flags; for now we ignore theirs and hope they'll ignore ours. */
2429 case N_OPT: /* Solaris 2: Compiler options */
2432 if (STREQ (name, GCC2_COMPILED_FLAG_SYMBOL))
2434 processing_gcc_compilation = 2;
2435 #if 1 /* Works, but is experimental. -fnf */
2436 if (AUTO_DEMANGLING)
2438 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
2447 /* The following symbol types can be ignored. */
2448 case N_OBJ: /* Solaris 2: Object file dir and name */
2449 /* N_UNDF: Solaris 2: file separator mark */
2450 /* N_UNDF: -- we will never encounter it, since we only process one
2451 file's symbols at once. */
2452 case N_ENDM: /* Solaris 2: End of module */
2453 case N_MAIN: /* Name of main routine. */
2454 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
2458 /* '#' is a GNU C extension to allow one symbol to refer to another
2461 Generally this is used so that an alias can refer to its main
2465 /* Initialize symbol reference names and determine if this is
2466 a definition. If symbol reference is being defined, go
2467 ahead and add it. Otherwise, just return sym. */
2472 /* If this stab defines a new reference ID that is not on the
2473 reference list, then put it on the reference list.
2475 We go ahead and advance NAME past the reference, even though
2476 it is not strictly necessary at this time. */
2477 refnum = symbol_reference_defined (&s);
2479 if (!ref_search (refnum))
2480 ref_add (refnum, 0, name, valu);
2485 previous_stab_code = type;
2488 /* FIXME: The only difference between this and elfstab_build_psymtabs
2489 is the call to install_minimal_symbols for elf, and the support for
2490 split sections. If the differences are really that small, the code
2491 should be shared. */
2493 /* Scan and build partial symbols for an coff symbol file.
2494 The coff file has already been processed to get its minimal symbols.
2496 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2499 OBJFILE is the object file we are reading symbols from.
2500 ADDR is the address relative to which the symbols are (e.g.
2501 the base address of the text segment).
2502 MAINLINE is true if we are reading the main symbol
2503 table (as opposed to a shared lib or dynamically loaded file).
2504 TEXTADDR is the address of the text section.
2505 TEXTSIZE is the size of the text section.
2506 STABSECTS is the list of .stab sections in OBJFILE.
2507 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2508 .stabstr section exists.
2510 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2511 adjusted for coff details. */
2514 coffstab_build_psymtabs (objfile, section_offsets, mainline,
2515 textaddr, textsize, stabsects,
2516 stabstroffset, stabstrsize)
2517 struct objfile *objfile;
2518 struct section_offsets *section_offsets;
2521 unsigned int textsize;
2522 struct stab_section_list *stabsects;
2523 file_ptr stabstroffset;
2524 unsigned int stabstrsize;
2527 bfd *sym_bfd = objfile->obfd;
2528 char *name = bfd_get_filename (sym_bfd);
2529 struct dbx_symfile_info *info;
2530 unsigned int stabsize;
2532 /* There is already a dbx_symfile_info allocated by our caller.
2533 It might even contain some info from the coff symtab to help us. */
2534 info = objfile->sym_stab_info;
2536 DBX_TEXT_ADDR (objfile) = textaddr;
2537 DBX_TEXT_SIZE (objfile) = textsize;
2539 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2540 DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE;
2541 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2543 if (stabstrsize > bfd_get_size (sym_bfd))
2544 error ("ridiculous string table size: %d bytes", stabstrsize);
2545 DBX_STRINGTAB (objfile) = (char *)
2546 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2547 OBJSTAT (objfile, sz_strtab += stabstrsize+1);
2549 /* Now read in the string table in one big gulp. */
2551 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2553 perror_with_name (name);
2554 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2555 if (val != stabstrsize)
2556 perror_with_name (name);
2558 stabsread_new_init ();
2559 buildsym_new_init ();
2560 free_header_files ();
2561 init_header_files ();
2563 processing_acc_compilation = 1;
2565 /* In a coff file, we've already installed the minimal symbols that came
2566 from the coff (non-stab) symbol table, so always act like an
2567 incremental load here. */
2568 if (stabsects->next == NULL)
2570 stabsize = bfd_section_size (sym_bfd, stabsects->section);
2571 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2572 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2576 struct stab_section_list *stabsect;
2578 DBX_SYMCOUNT (objfile) = 0;
2579 for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
2581 stabsize = bfd_section_size (sym_bfd, stabsect->section);
2582 DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
2585 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2587 symbuf_sections = stabsects->next;
2588 symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
2592 dbx_symfile_read (objfile, section_offsets, 0);
2595 /* Scan and build partial symbols for an ELF symbol file.
2596 This ELF file has already been processed to get its minimal symbols,
2597 and any DWARF symbols that were in it.
2599 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2602 OBJFILE is the object file we are reading symbols from.
2603 ADDR is the address relative to which the symbols are (e.g.
2604 the base address of the text segment).
2605 MAINLINE is true if we are reading the main symbol
2606 table (as opposed to a shared lib or dynamically loaded file).
2607 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2609 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2610 .stabstr section exists.
2612 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2613 adjusted for elf details. */
2616 elfstab_build_psymtabs (objfile, section_offsets, mainline,
2617 staboffset, stabsize,
2618 stabstroffset, stabstrsize)
2619 struct objfile *objfile;
2620 struct section_offsets *section_offsets;
2622 file_ptr staboffset;
2623 unsigned int stabsize;
2624 file_ptr stabstroffset;
2625 unsigned int stabstrsize;
2628 bfd *sym_bfd = objfile->obfd;
2629 char *name = bfd_get_filename (sym_bfd);
2630 struct dbx_symfile_info *info;
2631 asection *text_sect;
2633 /* There is already a dbx_symfile_info allocated by our caller.
2634 It might even contain some info from the ELF symtab to help us. */
2635 info = objfile->sym_stab_info;
2637 /* Find the first and last text address. dbx_symfile_read seems to
2639 find_text_range (sym_bfd, objfile);
2641 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2642 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
2643 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2644 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2645 DBX_SYMTAB_OFFSET (objfile) = staboffset;
2647 if (stabstrsize > bfd_get_size (sym_bfd))
2648 error ("ridiculous string table size: %d bytes", stabstrsize);
2649 DBX_STRINGTAB (objfile) = (char *)
2650 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2651 OBJSTAT (objfile, sz_strtab += stabstrsize+1);
2653 /* Now read in the string table in one big gulp. */
2655 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2657 perror_with_name (name);
2658 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2659 if (val != stabstrsize)
2660 perror_with_name (name);
2662 stabsread_new_init ();
2663 buildsym_new_init ();
2664 free_header_files ();
2665 init_header_files ();
2666 install_minimal_symbols (objfile);
2668 processing_acc_compilation = 1;
2670 /* In an elf file, we've already installed the minimal symbols that came
2671 from the elf (non-stab) symbol table, so always act like an
2672 incremental load here. */
2673 dbx_symfile_read (objfile, section_offsets, 0);
2676 /* Scan and build partial symbols for a file with special sections for stabs
2677 and stabstrings. The file has already been processed to get its minimal
2678 symbols, and any other symbols that might be necessary to resolve GSYMs.
2680 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2683 OBJFILE is the object file we are reading symbols from.
2684 ADDR is the address relative to which the symbols are (e.g. the base address
2685 of the text segment).
2686 MAINLINE is true if we are reading the main symbol table (as opposed to a
2687 shared lib or dynamically loaded file).
2688 STAB_NAME is the name of the section that contains the stabs.
2689 STABSTR_NAME is the name of the section that contains the stab strings.
2691 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2694 stabsect_build_psymtabs (objfile, section_offsets, mainline, stab_name,
2695 stabstr_name, text_name)
2696 struct objfile *objfile;
2697 struct section_offsets *section_offsets;
2704 bfd *sym_bfd = objfile->obfd;
2705 char *name = bfd_get_filename (sym_bfd);
2707 asection *stabstrsect;
2708 asection *text_sect;
2710 stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
2711 stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
2717 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2718 stab_name, stabstr_name);
2720 objfile->sym_stab_info = (struct dbx_symfile_info *)
2721 xmalloc (sizeof (struct dbx_symfile_info));
2722 memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
2724 text_sect = bfd_get_section_by_name (sym_bfd, text_name);
2726 error ("Can't find %s section in symbol file", text_name);
2727 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
2728 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
2730 DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
2731 DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
2732 / DBX_SYMBOL_SIZE (objfile);
2733 DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
2734 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2736 if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
2737 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile));
2738 DBX_STRINGTAB (objfile) = (char *)
2739 obstack_alloc (&objfile->psymbol_obstack, DBX_STRINGTAB_SIZE (objfile) + 1);
2740 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1);
2742 /* Now read in the string table in one big gulp. */
2744 val = bfd_get_section_contents (sym_bfd, /* bfd */
2745 stabstrsect, /* bfd section */
2746 DBX_STRINGTAB (objfile), /* input buffer */
2747 0, /* offset into section */
2748 DBX_STRINGTAB_SIZE (objfile)); /* amount to read */
2751 perror_with_name (name);
2753 stabsread_new_init ();
2754 buildsym_new_init ();
2755 free_header_files ();
2756 init_header_files ();
2757 install_minimal_symbols (objfile);
2759 /* Now, do an incremental load */
2761 processing_acc_compilation = 1;
2762 dbx_symfile_read (objfile, section_offsets, 0);
2765 static struct sym_fns aout_sym_fns =
2767 bfd_target_aout_flavour,
2768 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2769 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2770 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2771 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2772 default_symfile_offsets,
2773 /* sym_offsets: parse user's offsets to internal form */
2774 NULL /* next: pointer to next struct sym_fns */
2778 _initialize_dbxread ()
2780 add_symtab_fns(&aout_sym_fns);