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 /* During initial symbol readin, we need to have a structure to keep
201 track of which psymtabs have which bincls in them. This structure
202 is used during readin to setup the list of dependencies within each
203 partial symbol table. */
205 struct header_file_location
207 char *name; /* Name of header file */
208 int instance; /* See above */
209 struct partial_symtab *pst; /* Partial symtab that has the
210 BINCL/EINCL defs for this file */
213 /* The actual list and controling variables */
214 static struct header_file_location *bincl_list, *next_bincl;
215 static int bincls_allocated;
217 /* Local function prototypes */
220 process_now PARAMS ((struct objfile *));
223 free_header_files PARAMS ((void));
226 init_header_files PARAMS ((void));
229 read_ofile_symtab PARAMS ((struct partial_symtab *));
232 dbx_psymtab_to_symtab PARAMS ((struct partial_symtab *));
235 dbx_psymtab_to_symtab_1 PARAMS ((struct partial_symtab *));
238 read_dbx_dynamic_symtab PARAMS ((struct section_offsets *,
239 struct objfile *objfile));
242 read_dbx_symtab PARAMS ((struct section_offsets *, struct objfile *,
246 free_bincl_list PARAMS ((struct objfile *));
248 static struct partial_symtab *
249 find_corresponding_bincl_psymtab PARAMS ((char *, int));
252 add_bincl_to_list PARAMS ((struct partial_symtab *, char *, int));
255 init_bincl_list PARAMS ((int, struct objfile *));
258 dbx_next_symbol_text PARAMS ((struct objfile *));
261 fill_symbuf PARAMS ((bfd *));
264 dbx_symfile_init PARAMS ((struct objfile *));
267 dbx_new_init PARAMS ((struct objfile *));
270 dbx_symfile_read PARAMS ((struct objfile *, struct section_offsets *, int));
273 dbx_symfile_finish PARAMS ((struct objfile *));
276 record_minimal_symbol PARAMS ((char *, CORE_ADDR, int, struct objfile *));
279 add_new_header_file PARAMS ((char *, int));
282 add_old_header_file PARAMS ((char *, int));
285 add_this_object_header_file PARAMS ((int));
287 /* Free up old header file tables */
292 if (this_object_header_files)
294 free ((PTR)this_object_header_files);
295 this_object_header_files = NULL;
297 n_allocated_this_object_header_files = 0;
300 /* Allocate new header file tables */
305 n_allocated_this_object_header_files = 10;
306 this_object_header_files = (int *) xmalloc (10 * sizeof (int));
309 /* Add header file number I for this object file
310 at the next successive FILENUM. */
313 add_this_object_header_file (i)
316 if (!n_allocated_this_object_header_files)
317 init_header_files ();
319 if (n_this_object_header_files == n_allocated_this_object_header_files)
321 n_allocated_this_object_header_files *= 2;
322 this_object_header_files
323 = (int *) xrealloc ((char *) this_object_header_files,
324 n_allocated_this_object_header_files * sizeof (int));
327 this_object_header_files[n_this_object_header_files++] = i;
330 /* Add to this file an "old" header file, one already seen in
331 a previous object file. NAME is the header file's name.
332 INSTANCE is its instance code, to select among multiple
333 symbol tables for the same header file. */
336 add_old_header_file (name, instance)
340 register struct header_file *p = HEADER_FILES (current_objfile);
343 for (i = 0; i < N_HEADER_FILES (current_objfile); i++)
344 if (STREQ (p[i].name, name) && instance == p[i].instance)
346 add_this_object_header_file (i);
349 complain (&repeated_header_complaint, name, symnum);
352 /* Add to this file a "new" header file: definitions for its types follow.
353 NAME is the header file's name.
354 Most often this happens only once for each distinct header file,
355 but not necessarily. If it happens more than once, INSTANCE has
356 a different value each time, and references to the header file
357 use INSTANCE values to select among them.
359 dbx output contains "begin" and "end" markers for each new header file,
360 but at this level we just need to know which files there have been;
361 so we record the file when its "begin" is seen and ignore the "end". */
364 add_new_header_file (name, instance)
369 register struct header_file *hfile;
371 /* Make sure there is room for one more header file. */
373 i = N_ALLOCATED_HEADER_FILES (current_objfile);
375 if (N_HEADER_FILES (current_objfile) == i)
379 N_ALLOCATED_HEADER_FILES (current_objfile) = 10;
380 HEADER_FILES (current_objfile) = (struct header_file *)
381 xmalloc (10 * sizeof (struct header_file));
386 N_ALLOCATED_HEADER_FILES (current_objfile) = i;
387 HEADER_FILES (current_objfile) = (struct header_file *)
388 xrealloc ((char *) HEADER_FILES (current_objfile),
389 (i * sizeof (struct header_file)));
393 /* Create an entry for this header file. */
395 i = N_HEADER_FILES (current_objfile)++;
396 hfile = HEADER_FILES (current_objfile) + i;
397 hfile->name = savestring (name, strlen(name));
398 hfile->instance = instance;
401 = (struct type **) xmalloc (10 * sizeof (struct type *));
402 memset (hfile->vector, 0, 10 * sizeof (struct type *));
404 add_this_object_header_file (i);
408 static struct type **
409 explicit_lookup_type (real_filenum, index)
410 int real_filenum, index;
412 register struct header_file *f = &HEADER_FILES (current_objfile)[real_filenum];
414 if (index >= f->length)
417 f->vector = (struct type **)
418 xrealloc (f->vector, f->length * sizeof (struct type *));
419 memset (&f->vector[f->length / 2],
420 '\0', f->length * sizeof (struct type *) / 2);
422 return &f->vector[index];
427 record_minimal_symbol (name, address, type, objfile)
431 struct objfile *objfile;
433 enum minimal_symbol_type ms_type;
435 asection *bfd_section;
441 section = SECT_OFF_TEXT;
442 bfd_section = DBX_TEXT_SECTION (objfile);
446 section = SECT_OFF_DATA;
447 bfd_section = DBX_DATA_SECTION (objfile);
451 section = SECT_OFF_BSS;
452 bfd_section = DBX_BSS_SECTION (objfile);
462 section = SECT_OFF_DATA;
463 bfd_section = DBX_DATA_SECTION (objfile);
466 /* I don't think this type actually exists; since a N_SETV is the result
467 of going over many .o files, it doesn't make sense to have one
469 ms_type = mst_file_data;
470 section = SECT_OFF_DATA;
471 bfd_section = DBX_DATA_SECTION (objfile);
478 ms_type = mst_file_text;
479 section = SECT_OFF_TEXT;
480 bfd_section = DBX_TEXT_SECTION (objfile);
483 ms_type = mst_file_data;
485 /* Check for __DYNAMIC, which is used by Sun shared libraries.
486 Record it as global even if it's local, not global, so
487 lookup_minimal_symbol can find it. We don't check symbol_leading_char
488 because for SunOS4 it always is '_'. */
489 if (name[8] == 'C' && STREQ ("__DYNAMIC", name))
492 /* Same with virtual function tables, both global and static. */
494 char *tempstring = name;
495 if (tempstring[0] == bfd_get_symbol_leading_char (objfile->obfd))
497 if (VTBL_PREFIX_P ((tempstring)))
500 section = SECT_OFF_DATA;
501 bfd_section = DBX_DATA_SECTION (objfile);
504 ms_type = mst_file_bss;
505 section = SECT_OFF_BSS;
506 bfd_section = DBX_BSS_SECTION (objfile);
509 ms_type = mst_unknown;
515 if ((ms_type == mst_file_text || ms_type == mst_text)
516 && address < lowest_text_address)
517 lowest_text_address = address;
519 prim_record_minimal_symbol_and_info
520 (name, address, ms_type, NULL, section, bfd_section, objfile);
523 /* Scan and build partial symbols for a symbol file.
524 We have been initialized by a call to dbx_symfile_init, which
525 put all the relevant info into a "struct dbx_symfile_info",
526 hung off the objfile structure.
528 SECTION_OFFSETS contains offsets relative to which the symbols in the
529 various sections are (depending where the sections were actually loaded).
530 MAINLINE is true if we are reading the main symbol
531 table (as opposed to a shared lib or dynamically loaded file). */
534 dbx_symfile_read (objfile, section_offsets, mainline)
535 struct objfile *objfile;
536 struct section_offsets *section_offsets;
537 int mainline; /* FIXME comments above */
541 struct cleanup *back_to;
543 val = strlen (objfile->name);
545 sym_bfd = objfile->obfd;
547 /* .o and .nlm files are relocatables with text, data and bss segs based at
548 0. This flag disables special (Solaris stabs-in-elf only) fixups for
549 symbols with a value of 0. */
551 symfile_relocatable = bfd_get_file_flags (sym_bfd) & HAS_RELOC;
553 /* This is true for Solaris (and all other systems which put stabs
554 in sections, hopefully, since it would be silly to do things
555 differently from Solaris), and false for SunOS4 and other a.out
557 block_address_function_relative =
558 ((0 == strncmp (bfd_get_target (sym_bfd), "elf", 3))
559 || (0 == strncmp (bfd_get_target (sym_bfd), "som", 3))
560 || (0 == strncmp (bfd_get_target (sym_bfd), "coff", 4))
561 || (0 == strncmp (bfd_get_target (sym_bfd), "pe", 2))
562 || (0 == strncmp (bfd_get_target (sym_bfd), "nlm", 3)));
564 val = bfd_seek (sym_bfd, DBX_SYMTAB_OFFSET (objfile), SEEK_SET);
566 perror_with_name (objfile->name);
568 /* If we are reinitializing, or if we have never loaded syms yet, init */
570 || objfile->global_psymbols.size == 0
571 || objfile->static_psymbols.size == 0)
572 init_psymbol_list (objfile, DBX_SYMCOUNT (objfile));
574 symbol_size = DBX_SYMBOL_SIZE (objfile);
575 symbol_table_offset = DBX_SYMTAB_OFFSET (objfile);
577 free_pending_blocks ();
578 back_to = make_cleanup ((make_cleanup_func) really_free_pendings, 0);
580 init_minimal_symbol_collection ();
581 make_cleanup ((make_cleanup_func) discard_minimal_symbols, 0);
583 /* Now that the symbol table data of the executable file are all in core,
584 process them and define symbols accordingly. */
586 read_dbx_symtab (section_offsets, objfile,
587 DBX_TEXT_ADDR (objfile),
588 DBX_TEXT_SIZE (objfile));
590 /* Add the dynamic symbols. */
592 read_dbx_dynamic_symtab (section_offsets, objfile);
594 /* Install any minimal symbols that have been collected as the current
595 minimal symbols for this objfile. */
597 install_minimal_symbols (objfile);
599 do_cleanups (back_to);
602 /* Initialize anything that needs initializing when a completely new
603 symbol file is specified (not just adding some symbols from another
604 file, e.g. a shared library). */
607 dbx_new_init (ignore)
608 struct objfile *ignore;
610 stabsread_new_init ();
611 buildsym_new_init ();
612 init_header_files ();
616 /* dbx_symfile_init ()
617 is the dbx-specific initialization routine for reading symbols.
618 It is passed a struct objfile which contains, among other things,
619 the BFD for the file whose symbols are being read, and a slot for a pointer
620 to "private data" which we fill with goodies.
622 We read the string table into malloc'd space and stash a pointer to it.
624 Since BFD doesn't know how to read debug symbols in a format-independent
625 way (and may never do so...), we have to do it ourselves. We will never
626 be called unless this is an a.out (or very similar) file.
627 FIXME, there should be a cleaner peephole into the BFD environment here. */
629 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
632 dbx_symfile_init (objfile)
633 struct objfile *objfile;
636 bfd *sym_bfd = objfile->obfd;
637 char *name = bfd_get_filename (sym_bfd);
639 unsigned char size_temp[DBX_STRINGTAB_SIZE_SIZE];
641 /* Allocate struct to keep track of the symfile */
642 objfile->sym_stab_info = (struct dbx_symfile_info *)
643 xmmalloc (objfile -> md, sizeof (struct dbx_symfile_info));
644 memset ((PTR) objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
646 DBX_TEXT_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".text");
647 DBX_DATA_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".data");
648 DBX_BSS_SECTION (objfile) = bfd_get_section_by_name (sym_bfd, ".bss");
650 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
651 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
652 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
654 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
656 DBX_SYMFILE_INFO (objfile)->stab_section_info = NULL;
658 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
660 error ("Can't find .text section in symbol file");
661 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
662 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
664 DBX_SYMBOL_SIZE (objfile) = obj_symbol_entry_size (sym_bfd);
665 DBX_SYMCOUNT (objfile) = bfd_get_symcount (sym_bfd);
666 DBX_SYMTAB_OFFSET (objfile) = SYMBOL_TABLE_OFFSET;
668 /* Read the string table and stash it away in the psymbol_obstack. It is
669 only needed as long as we need to expand psymbols into full symbols,
670 so when we blow away the psymbol the string table goes away as well.
671 Note that gdb used to use the results of attempting to malloc the
672 string table, based on the size it read, as a form of sanity check
673 for botched byte swapping, on the theory that a byte swapped string
674 table size would be so totally bogus that the malloc would fail. Now
675 that we put in on the psymbol_obstack, we can't do this since gdb gets
676 a fatal error (out of virtual memory) if the size is bogus. We can
677 however at least check to see if the size is less than the size of
678 the size field itself, or larger than the size of the entire file.
679 Note that all valid string tables have a size greater than zero, since
680 the bytes used to hold the size are included in the count. */
682 if (STRING_TABLE_OFFSET == 0)
684 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
685 will never be zero, even when there is no string table. This
686 would appear to be a bug in bfd. */
687 DBX_STRINGTAB_SIZE (objfile) = 0;
688 DBX_STRINGTAB (objfile) = NULL;
692 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
694 perror_with_name (name);
696 memset ((PTR) size_temp, 0, sizeof (size_temp));
697 val = bfd_read ((PTR) size_temp, sizeof (size_temp), 1, sym_bfd);
700 perror_with_name (name);
704 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
705 EOF if there is no string table, and attempting to read the size
706 from EOF will read zero bytes. */
707 DBX_STRINGTAB_SIZE (objfile) = 0;
708 DBX_STRINGTAB (objfile) = NULL;
712 /* Read some data that would appear to be the string table size.
713 If there really is a string table, then it is probably the right
714 size. Byteswap if necessary and validate the size. Note that
715 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
716 random data that happened to be at STRING_TABLE_OFFSET, because
717 bfd can't tell us there is no string table, the sanity checks may
718 or may not catch this. */
719 DBX_STRINGTAB_SIZE (objfile) = bfd_h_get_32 (sym_bfd, size_temp);
721 if (DBX_STRINGTAB_SIZE (objfile) < sizeof (size_temp)
722 || DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
723 error ("ridiculous string table size (%d bytes).",
724 DBX_STRINGTAB_SIZE (objfile));
726 DBX_STRINGTAB (objfile) =
727 (char *) obstack_alloc (&objfile -> psymbol_obstack,
728 DBX_STRINGTAB_SIZE (objfile));
729 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile));
731 /* Now read in the string table in one big gulp. */
733 val = bfd_seek (sym_bfd, STRING_TABLE_OFFSET, SEEK_SET);
735 perror_with_name (name);
736 val = bfd_read (DBX_STRINGTAB (objfile), DBX_STRINGTAB_SIZE (objfile), 1,
738 if (val != DBX_STRINGTAB_SIZE (objfile))
739 perror_with_name (name);
744 /* Perform any local cleanups required when we are done with a particular
745 objfile. I.E, we are in the process of discarding all symbol information
746 for an objfile, freeing up all memory held for it, and unlinking the
747 objfile struct from the global list of known objfiles. */
750 dbx_symfile_finish (objfile)
751 struct objfile *objfile;
753 if (objfile->sym_stab_info != NULL)
755 if (HEADER_FILES (objfile) != NULL)
757 register int i = N_HEADER_FILES (objfile);
758 register struct header_file *hfiles = HEADER_FILES (objfile);
762 free (hfiles [i].name);
763 free (hfiles [i].vector);
767 mfree (objfile -> md, objfile->sym_stab_info);
769 free_header_files ();
773 /* Buffer for reading the symbol table entries. */
774 static struct external_nlist symbuf[4096];
775 static int symbuf_idx;
776 static int symbuf_end;
778 /* cont_elem is used for continuing information in cfront.
779 It saves information about which types need to be fixed up and
780 completed after all the stabs are read. */
783 /* sym and stabsstring for continuing information in cfront */
786 /* state dependancies (statics that must be preserved) */
790 int (*func) PARAMS ((struct objfile *, struct symbol *, char *));
791 /* other state dependancies include:
792 (assumption is that these will not change since process_now FIXME!!)
799 static struct cont_elem *cont_list = 0;
800 static int cont_limit = 0;
801 static int cont_count = 0;
803 /* Arrange for function F to be called with arguments SYM and P later
804 in the stabs reading process. */
806 process_later (sym, p, f)
809 int (*f) PARAMS ((struct objfile *, struct symbol *, char *));
812 /* Allocate more space for the deferred list. */
813 if (cont_count >= cont_limit - 1)
815 cont_limit += 32; /* chunk size */
818 = (struct cont_elem *) xrealloc (cont_list,
820 * sizeof (struct cont_elem)));
822 error ("Virtual memory exhausted\n");
825 /* Save state variables so we can process these stabs later. */
826 cont_list[cont_count].sym_idx = symbuf_idx;
827 cont_list[cont_count].sym_end = symbuf_end;
828 cont_list[cont_count].symnum = symnum;
829 cont_list[cont_count].sym = sym;
830 cont_list[cont_count].stabs = p;
831 cont_list[cont_count].func = f;
835 /* Call deferred funtions in CONT_LIST. */
838 process_now (objfile)
839 struct objfile *objfile;
848 int (*func) PARAMS ((struct objfile *, struct symbol *, char *));
850 /* Save the state of our caller, we'll want to restore it before
852 save_symbuf_idx = symbuf_idx;
853 save_symbuf_end = symbuf_end;
854 save_symnum = symnum;
856 /* Iterate over all the deferred stabs. */
857 for (i = 0; i < cont_count; i++)
859 /* Restore the state for this deferred stab. */
860 symbuf_idx = cont_list[i].sym_idx;
861 symbuf_end = cont_list[i].sym_end;
862 symnum = cont_list[i].symnum;
863 sym = cont_list[i].sym;
864 stabs = cont_list[i].stabs;
865 func = cont_list[i].func;
867 /* Call the function to handle this deferrd stab. */
868 err = (*func) (objfile, sym, stabs);
870 error ("Internal error: unable to resolve stab.\n");
873 /* Restore our caller's state. */
874 symbuf_idx = save_symbuf_idx;
875 symbuf_end = save_symbuf_end;
876 symnum = save_symnum;
881 /* Name of last function encountered. Used in Solaris to approximate
882 object file boundaries. */
883 static char *last_function_name;
885 /* The address in memory of the string table of the object file we are
886 reading (which might not be the "main" object file, but might be a
887 shared library or some other dynamically loaded thing). This is
888 set by read_dbx_symtab when building psymtabs, and by
889 read_ofile_symtab when building symtabs, and is used only by
890 next_symbol_text. FIXME: If that is true, we don't need it when
891 building psymtabs, right? */
892 static char *stringtab_global;
894 /* These variables are used to control fill_symbuf when the stabs
895 symbols are not contiguous (as may be the case when a COFF file is
896 linked using --split-by-reloc). */
897 static struct stab_section_list *symbuf_sections;
898 static unsigned int symbuf_left;
899 static unsigned int symbuf_read;
901 /* Refill the symbol table input buffer
902 and set the variables that control fetching entries from it.
903 Reports an error if no data available.
904 This function can read past the end of the symbol table
905 (into the string table) but this does no harm. */
908 fill_symbuf (sym_bfd)
914 if (symbuf_sections == NULL)
915 count = sizeof (symbuf);
918 if (symbuf_left <= 0)
920 file_ptr filepos = symbuf_sections->section->filepos;
921 if (bfd_seek (sym_bfd, filepos, SEEK_SET) != 0)
922 perror_with_name (bfd_get_filename (sym_bfd));
923 symbuf_left = bfd_section_size (sym_bfd, symbuf_sections->section);
924 symbol_table_offset = filepos - symbuf_read;
925 symbuf_sections = symbuf_sections->next;
929 if (count > sizeof (symbuf))
930 count = sizeof (symbuf);
933 nbytes = bfd_read ((PTR)symbuf, count, 1, sym_bfd);
935 perror_with_name (bfd_get_filename (sym_bfd));
936 else if (nbytes == 0)
937 error ("Premature end of file reading symbol table");
938 symbuf_end = nbytes / symbol_size;
940 symbuf_left -= nbytes;
941 symbuf_read += nbytes;
944 #define SWAP_SYMBOL(symp, abfd) \
946 (symp)->n_strx = bfd_h_get_32(abfd, \
947 (unsigned char *)&(symp)->n_strx); \
948 (symp)->n_desc = bfd_h_get_16 (abfd, \
949 (unsigned char *)&(symp)->n_desc); \
950 (symp)->n_value = bfd_h_get_32 (abfd, \
951 (unsigned char *)&(symp)->n_value); \
954 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
956 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
957 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
958 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
959 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
962 /* Invariant: The symbol pointed to by symbuf_idx is the first one
963 that hasn't been swapped. Swap the symbol at the same time
964 that symbuf_idx is incremented. */
966 /* dbx allows the text of a symbol name to be continued into the
967 next symbol name! When such a continuation is encountered
968 (a \ at the end of the text of a name)
969 call this function to get the continuation. */
972 dbx_next_symbol_text (objfile)
973 struct objfile *objfile;
975 struct internal_nlist nlist;
977 if (symbuf_idx == symbuf_end)
978 fill_symbuf (symfile_bfd);
981 INTERNALIZE_SYMBOL(nlist, &symbuf[symbuf_idx], symfile_bfd);
982 OBJSTAT (objfile, n_stabs++);
986 return nlist.n_strx + stringtab_global + file_string_table_offset;
989 /* Initialize the list of bincls to contain none and have some
993 init_bincl_list (number, objfile)
995 struct objfile *objfile;
997 bincls_allocated = number;
998 next_bincl = bincl_list = (struct header_file_location *)
999 xmmalloc (objfile -> md, bincls_allocated * sizeof(struct header_file_location));
1002 /* Add a bincl to the list. */
1005 add_bincl_to_list (pst, name, instance)
1006 struct partial_symtab *pst;
1010 if (next_bincl >= bincl_list + bincls_allocated)
1012 int offset = next_bincl - bincl_list;
1013 bincls_allocated *= 2;
1014 bincl_list = (struct header_file_location *)
1015 xmrealloc (pst->objfile->md, (char *)bincl_list,
1016 bincls_allocated * sizeof (struct header_file_location));
1017 next_bincl = bincl_list + offset;
1019 next_bincl->pst = pst;
1020 next_bincl->instance = instance;
1021 next_bincl++->name = name;
1024 /* Given a name, value pair, find the corresponding
1025 bincl in the list. Return the partial symtab associated
1026 with that header_file_location. */
1028 static struct partial_symtab *
1029 find_corresponding_bincl_psymtab (name, instance)
1033 struct header_file_location *bincl;
1035 for (bincl = bincl_list; bincl < next_bincl; bincl++)
1036 if (bincl->instance == instance
1037 && STREQ (name, bincl->name))
1040 complain (&repeated_header_complaint, name, symnum);
1041 return (struct partial_symtab *) 0;
1044 /* Free the storage allocated for the bincl list. */
1047 free_bincl_list (objfile)
1048 struct objfile *objfile;
1050 mfree (objfile -> md, (PTR)bincl_list);
1051 bincls_allocated = 0;
1054 /* Scan a SunOs dynamic symbol table for symbols of interest and
1055 add them to the minimal symbol table. */
1058 read_dbx_dynamic_symtab (section_offsets, objfile)
1059 struct section_offsets *section_offsets;
1060 struct objfile *objfile;
1062 bfd *abfd = objfile->obfd;
1063 struct cleanup *back_to;
1073 CORE_ADDR sym_value;
1076 /* Check that the symbol file has dynamic symbols that we know about.
1077 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1078 on a sun4 host (and vice versa) and bfd is not configured
1079 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1080 so we ignore the dynamic symbols in this case. */
1081 if (bfd_get_flavour (abfd) != bfd_target_aout_flavour
1082 || (bfd_get_file_flags (abfd) & DYNAMIC) == 0
1083 || bfd_get_arch (abfd) == bfd_arch_unknown)
1086 dynsym_size = bfd_get_dynamic_symtab_upper_bound (abfd);
1087 if (dynsym_size < 0)
1090 dynsyms = (asymbol **) xmalloc (dynsym_size);
1091 back_to = make_cleanup (free, dynsyms);
1093 dynsym_count = bfd_canonicalize_dynamic_symtab (abfd, dynsyms);
1094 if (dynsym_count < 0)
1096 do_cleanups (back_to);
1100 /* Enter dynamic symbols into the minimal symbol table
1101 if this is a stripped executable. */
1102 if (bfd_get_symcount (abfd) <= 0)
1105 for (counter = 0; counter < dynsym_count; counter++, symptr++)
1107 asymbol *sym = *symptr;
1111 sec = bfd_get_section (sym);
1113 /* BFD symbols are section relative. */
1114 sym_value = sym->value + sec->vma;
1116 if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
1118 sym_value += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1121 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
1123 sym_value += ANOFFSET (section_offsets, SECT_OFF_DATA);
1126 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
1128 sym_value += ANOFFSET (section_offsets, SECT_OFF_BSS);
1134 if (sym->flags & BSF_GLOBAL)
1137 record_minimal_symbol ((char *) bfd_asymbol_name (sym), sym_value,
1142 /* Symbols from shared libraries have a dynamic relocation entry
1143 that points to the associated slot in the procedure linkage table.
1144 We make a mininal symbol table entry with type mst_solib_trampoline
1145 at the address in the procedure linkage table. */
1146 dynrel_size = bfd_get_dynamic_reloc_upper_bound (abfd);
1147 if (dynrel_size < 0)
1149 do_cleanups (back_to);
1153 dynrels = (arelent **) xmalloc (dynrel_size);
1154 make_cleanup (free, dynrels);
1156 dynrel_count = bfd_canonicalize_dynamic_reloc (abfd, dynrels, dynsyms);
1157 if (dynrel_count < 0)
1159 do_cleanups (back_to);
1163 for (counter = 0, relptr = dynrels;
1164 counter < dynrel_count;
1165 counter++, relptr++)
1167 arelent *rel = *relptr;
1169 rel->address + ANOFFSET (section_offsets, SECT_OFF_DATA);
1171 switch (bfd_get_arch (abfd))
1173 case bfd_arch_sparc:
1174 if (rel->howto->type != RELOC_JMP_SLOT)
1178 /* `16' is the type BFD produces for a jump table relocation. */
1179 if (rel->howto->type != 16)
1182 /* Adjust address in the jump table to point to
1183 the start of the bsr instruction. */
1190 name = (char *) bfd_asymbol_name (*rel->sym_ptr_ptr);
1191 prim_record_minimal_symbol (name, address, mst_solib_trampoline,
1195 do_cleanups (back_to);
1198 /* Given pointers to an a.out symbol table in core containing dbx
1199 style data, setup partial_symtab's describing each source file for
1200 which debugging information is available.
1201 SYMFILE_NAME is the name of the file we are reading from
1202 and SECTION_OFFSETS is the set of offsets for the various sections
1203 of the file (a set of zeros if the mainline program). */
1206 read_dbx_symtab (section_offsets, objfile, text_addr, text_size)
1207 struct section_offsets *section_offsets;
1208 struct objfile *objfile;
1209 CORE_ADDR text_addr;
1212 register struct external_nlist *bufp = 0; /* =0 avoids gcc -Wall glitch */
1213 struct internal_nlist nlist;
1215 register char *namestring;
1217 int past_first_source_file = 0;
1218 CORE_ADDR last_o_file_start = 0;
1219 CORE_ADDR last_function_start = 0;
1220 struct cleanup *back_to;
1222 int textlow_not_set;
1224 /* Current partial symtab */
1225 struct partial_symtab *pst;
1227 /* List of current psymtab's include files */
1228 char **psymtab_include_list;
1229 int includes_allocated;
1232 /* Index within current psymtab dependency list */
1233 struct partial_symtab **dependency_list;
1234 int dependencies_used, dependencies_allocated;
1236 /* FIXME. We probably want to change stringtab_global rather than add this
1237 while processing every symbol entry. FIXME. */
1238 file_string_table_offset = 0;
1239 next_file_string_table_offset = 0;
1241 stringtab_global = DBX_STRINGTAB (objfile);
1243 pst = (struct partial_symtab *) 0;
1245 includes_allocated = 30;
1247 psymtab_include_list = (char **) alloca (includes_allocated *
1250 dependencies_allocated = 30;
1251 dependencies_used = 0;
1253 (struct partial_symtab **) alloca (dependencies_allocated *
1254 sizeof (struct partial_symtab *));
1256 /* Init bincl list */
1257 init_bincl_list (20, objfile);
1258 back_to = make_cleanup ((make_cleanup_func) free_bincl_list, objfile);
1260 last_source_file = NULL;
1262 lowest_text_address = (CORE_ADDR)-1;
1264 symfile_bfd = objfile->obfd; /* For next_text_symbol */
1265 abfd = objfile->obfd;
1266 symbuf_end = symbuf_idx = 0;
1267 next_symbol_text_func = dbx_next_symbol_text;
1268 textlow_not_set = 1;
1269 has_line_numbers = 0;
1271 for (symnum = 0; symnum < DBX_SYMCOUNT (objfile); symnum++)
1273 /* Get the symbol for this run and pull out some info */
1274 QUIT; /* allow this to be interruptable */
1275 if (symbuf_idx == symbuf_end)
1277 bufp = &symbuf[symbuf_idx++];
1280 * Special case to speed up readin.
1282 if (bfd_h_get_8 (abfd, bufp->e_type) == N_SLINE)
1284 has_line_numbers = 1;
1288 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1289 OBJSTAT (objfile, n_stabs++);
1291 /* Ok. There is a lot of code duplicated in the rest of this
1292 switch statement (for efficiency reasons). Since I don't
1293 like duplicating code, I will do my penance here, and
1294 describe the code which is duplicated:
1296 *) The assignment to namestring.
1297 *) The call to strchr.
1298 *) The addition of a partial symbol the the two partial
1299 symbol lists. This last is a large section of code, so
1300 I've imbedded it in the following macro.
1303 /* Set namestring based on nlist. If the string table index is invalid,
1304 give a fake name, and print a single error message per symbol file read,
1305 rather than abort the symbol reading or flood the user with messages. */
1307 /*FIXME: Too many adds and indirections in here for the inner loop. */
1308 #define SET_NAMESTRING()\
1309 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1310 DBX_STRINGTAB_SIZE (objfile)) { \
1311 complain (&string_table_offset_complaint, symnum); \
1312 namestring = "<bad string table offset>"; \
1314 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1315 DBX_STRINGTAB (objfile)
1317 #define CUR_SYMBOL_TYPE nlist.n_type
1318 #define CUR_SYMBOL_VALUE nlist.n_value
1319 #define CUR_SYMBOL_STRX nlist.n_strx
1320 #define DBXREAD_ONLY
1321 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1322 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1323 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1324 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1326 #include "partial-stab.h"
1329 /* If there's stuff to be cleaned up, clean it up. */
1330 if (DBX_SYMCOUNT (objfile) > 0 /* We have some syms */
1331 /*FIXME, does this have a bug at start address 0? */
1332 && last_o_file_start
1333 && objfile -> ei.entry_point < nlist.n_value
1334 && objfile -> ei.entry_point >= last_o_file_start)
1336 objfile -> ei.entry_file_lowpc = last_o_file_start;
1337 objfile -> ei.entry_file_highpc = nlist.n_value;
1342 /* Don't set pst->texthigh lower than it already is. */
1343 CORE_ADDR text_end =
1344 (lowest_text_address == (CORE_ADDR)-1
1345 ? (text_addr + section_offsets->offsets[SECT_OFF_TEXT])
1346 : lowest_text_address)
1349 end_psymtab (pst, psymtab_include_list, includes_used,
1350 symnum * symbol_size,
1351 text_end > pst->texthigh ? text_end : pst->texthigh,
1352 dependency_list, dependencies_used, textlow_not_set);
1355 do_cleanups (back_to);
1358 /* Allocate and partially fill a partial symtab. It will be
1359 completely filled at the end of the symbol list.
1361 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1362 is the address relative to which its symbols are (incremental) or 0
1366 struct partial_symtab *
1367 start_psymtab (objfile, section_offsets,
1368 filename, textlow, ldsymoff, global_syms, static_syms)
1369 struct objfile *objfile;
1370 struct section_offsets *section_offsets;
1374 struct partial_symbol **global_syms;
1375 struct partial_symbol **static_syms;
1377 struct partial_symtab *result =
1378 start_psymtab_common(objfile, section_offsets,
1379 filename, textlow, global_syms, static_syms);
1381 result->read_symtab_private = (char *)
1382 obstack_alloc (&objfile -> psymbol_obstack, sizeof (struct symloc));
1383 LDSYMOFF(result) = ldsymoff;
1384 result->read_symtab = dbx_psymtab_to_symtab;
1385 SYMBOL_SIZE(result) = symbol_size;
1386 SYMBOL_OFFSET(result) = symbol_table_offset;
1387 STRING_OFFSET(result) = string_table_offset;
1388 FILE_STRING_OFFSET(result) = file_string_table_offset;
1390 /* If we're handling an ELF file, drag some section-relocation info
1391 for this source file out of the ELF symbol table, to compensate for
1392 Sun brain death. This replaces the section_offsets in this psymtab,
1394 elfstab_offset_sections (objfile, result);
1396 /* Deduce the source language from the filename for this psymtab. */
1397 psymtab_language = deduce_language_from_filename (filename);
1402 /* Close off the current usage of PST.
1403 Returns PST or NULL if the partial symtab was empty and thrown away.
1405 FIXME: List variables and peculiarities of same. */
1407 struct partial_symtab *
1408 end_psymtab (pst, include_list, num_includes, capping_symbol_offset,
1409 capping_text, dependency_list, number_dependencies, textlow_not_set)
1410 struct partial_symtab *pst;
1411 char **include_list;
1413 int capping_symbol_offset;
1414 CORE_ADDR capping_text;
1415 struct partial_symtab **dependency_list;
1416 int number_dependencies;
1417 int textlow_not_set;
1420 struct objfile *objfile = pst -> objfile;
1422 if (capping_symbol_offset != -1)
1423 LDSYMLEN(pst) = capping_symbol_offset - LDSYMOFF(pst);
1424 pst->texthigh = capping_text;
1426 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1427 /* Under Solaris, the N_SO symbols always have a value of 0,
1428 instead of the usual address of the .o file. Therefore,
1429 we have to do some tricks to fill in texthigh and textlow.
1430 The first trick is in partial-stab.h: if we see a static
1431 or global function, and the textlow for the current pst
1432 is not set (ie: textlow_not_set), then we use that function's
1433 address for the textlow of the pst. */
1435 /* Now, to fill in texthigh, we remember the last function seen
1436 in the .o file (also in partial-stab.h). Also, there's a hack in
1437 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1438 to here via the misc_info field. Therefore, we can fill in
1439 a reliable texthigh by taking the address plus size of the
1440 last function in the file. */
1442 if (pst->texthigh == 0 && last_function_name)
1446 struct minimal_symbol *minsym;
1448 p = strchr (last_function_name, ':');
1450 p = last_function_name;
1451 n = p - last_function_name;
1453 strncpy (p, last_function_name, n);
1456 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1459 /* Sun Fortran appends an underscore to the minimal symbol name,
1460 try again with an appended underscore if the minimal symbol
1464 minsym = lookup_minimal_symbol (p, pst->filename, objfile);
1468 pst->texthigh = SYMBOL_VALUE_ADDRESS (minsym) + MSYMBOL_SIZE (minsym);
1470 last_function_name = NULL;
1473 /* this test will be true if the last .o file is only data */
1474 if (textlow_not_set)
1475 pst->textlow = pst->texthigh;
1478 struct partial_symtab *p1;
1480 /* If we know our own starting text address, then walk through all other
1481 psymtabs for this objfile, and if any didn't know their ending text
1482 address, set it to our starting address. Take care to not set our
1483 own ending address to our starting address, nor to set addresses on
1484 `dependency' files that have both textlow and texthigh zero. */
1486 ALL_OBJFILE_PSYMTABS (objfile, p1)
1488 if (p1->texthigh == 0 && p1->textlow != 0 && p1 != pst)
1490 p1->texthigh = pst->textlow;
1491 /* if this file has only data, then make textlow match texthigh */
1492 if (p1->textlow == 0)
1493 p1->textlow = p1->texthigh;
1498 /* End of kludge for patching Solaris textlow and texthigh. */
1499 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1501 pst->n_global_syms =
1502 objfile->global_psymbols.next - (objfile->global_psymbols.list + pst->globals_offset);
1503 pst->n_static_syms =
1504 objfile->static_psymbols.next - (objfile->static_psymbols.list + pst->statics_offset);
1506 pst->number_of_dependencies = number_dependencies;
1507 if (number_dependencies)
1509 pst->dependencies = (struct partial_symtab **)
1510 obstack_alloc (&objfile->psymbol_obstack,
1511 number_dependencies * sizeof (struct partial_symtab *));
1512 memcpy (pst->dependencies, dependency_list,
1513 number_dependencies * sizeof (struct partial_symtab *));
1516 pst->dependencies = 0;
1518 for (i = 0; i < num_includes; i++)
1520 struct partial_symtab *subpst =
1521 allocate_psymtab (include_list[i], objfile);
1523 subpst->section_offsets = pst->section_offsets;
1524 subpst->read_symtab_private =
1525 (char *) obstack_alloc (&objfile->psymbol_obstack,
1526 sizeof (struct symloc));
1530 subpst->texthigh = 0;
1532 /* We could save slight bits of space by only making one of these,
1533 shared by the entire set of include files. FIXME-someday. */
1534 subpst->dependencies = (struct partial_symtab **)
1535 obstack_alloc (&objfile->psymbol_obstack,
1536 sizeof (struct partial_symtab *));
1537 subpst->dependencies[0] = pst;
1538 subpst->number_of_dependencies = 1;
1540 subpst->globals_offset =
1541 subpst->n_global_syms =
1542 subpst->statics_offset =
1543 subpst->n_static_syms = 0;
1547 subpst->read_symtab = pst->read_symtab;
1550 sort_pst_symbols (pst);
1552 /* If there is already a psymtab or symtab for a file of this name, remove it.
1553 (If there is a symtab, more drastic things also happen.)
1554 This happens in VxWorks. */
1555 free_named_symtabs (pst->filename);
1557 if (num_includes == 0
1558 && number_dependencies == 0
1559 && pst->n_global_syms == 0
1560 && pst->n_static_syms == 0
1561 && has_line_numbers == 0)
1563 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1564 it is on the obstack, but we can forget to chain it on the list. */
1565 /* Empty psymtabs happen as a result of header files which don't have
1566 any symbols in them. There can be a lot of them. But this check
1567 is wrong, in that a psymtab with N_SLINE entries but nothing else
1568 is not empty, but we don't realize that. Fixing that without slowing
1569 things down might be tricky. */
1571 discard_psymtab (pst);
1573 /* Indicate that psymtab was thrown away. */
1574 pst = (struct partial_symtab *)NULL;
1580 dbx_psymtab_to_symtab_1 (pst)
1581 struct partial_symtab *pst;
1583 struct cleanup *old_chain;
1591 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1596 /* Read in all partial symtabs on which this one is dependent */
1597 for (i = 0; i < pst->number_of_dependencies; i++)
1598 if (!pst->dependencies[i]->readin)
1600 /* Inform about additional files that need to be read in. */
1603 fputs_filtered (" ", gdb_stdout);
1605 fputs_filtered ("and ", gdb_stdout);
1607 printf_filtered ("%s...", pst->dependencies[i]->filename);
1608 wrap_here (""); /* Flush output */
1609 gdb_flush (gdb_stdout);
1611 dbx_psymtab_to_symtab_1 (pst->dependencies[i]);
1614 if (LDSYMLEN(pst)) /* Otherwise it's a dummy */
1616 /* Init stuff necessary for reading in symbols */
1619 old_chain = make_cleanup ((make_cleanup_func) really_free_pendings, 0);
1620 file_string_table_offset = FILE_STRING_OFFSET (pst);
1621 symbol_size = SYMBOL_SIZE (pst);
1623 /* Read in this file's symbols */
1624 bfd_seek (pst->objfile->obfd, SYMBOL_OFFSET (pst), SEEK_SET);
1625 read_ofile_symtab (pst);
1626 sort_symtab_syms (pst->symtab);
1628 do_cleanups (old_chain);
1634 /* Read in all of the symbols for a given psymtab for real.
1635 Be verbose about it if the user wants that. */
1638 dbx_psymtab_to_symtab (pst)
1639 struct partial_symtab *pst;
1648 fprintf_unfiltered (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1653 if (LDSYMLEN(pst) || pst->number_of_dependencies)
1655 /* Print the message now, before reading the string table,
1656 to avoid disconcerting pauses. */
1659 printf_filtered ("Reading in symbols for %s...", pst->filename);
1660 gdb_flush (gdb_stdout);
1663 sym_bfd = pst->objfile->obfd;
1665 next_symbol_text_func = dbx_next_symbol_text;
1667 dbx_psymtab_to_symtab_1 (pst);
1669 /* Match with global symbols. This only needs to be done once,
1670 after all of the symtabs and dependencies have been read in. */
1671 scan_file_globals (pst->objfile);
1673 /* Finish up the debug error message. */
1675 printf_filtered ("done.\n");
1679 /* Read in a defined section of a specific object file's symbols. */
1682 read_ofile_symtab (pst)
1683 struct partial_symtab *pst;
1685 register char *namestring;
1686 register struct external_nlist *bufp;
1687 struct internal_nlist nlist;
1689 unsigned max_symnum;
1691 struct objfile *objfile;
1692 int sym_offset; /* Offset to start of symbols to read */
1693 int sym_size; /* Size of symbols to read */
1694 CORE_ADDR text_offset; /* Start of text segment for symbols */
1695 int text_size; /* Size of text segment for symbols */
1696 struct section_offsets *section_offsets;
1698 objfile = pst->objfile;
1699 sym_offset = LDSYMOFF(pst);
1700 sym_size = LDSYMLEN(pst);
1701 text_offset = pst->textlow;
1702 text_size = pst->texthigh - pst->textlow;
1703 section_offsets = pst->section_offsets;
1705 current_objfile = objfile;
1706 subfile_stack = NULL;
1708 stringtab_global = DBX_STRINGTAB (objfile);
1709 last_source_file = NULL;
1711 abfd = objfile->obfd;
1712 symfile_bfd = objfile->obfd; /* Implicit param to next_text_symbol */
1713 symbuf_end = symbuf_idx = 0;
1715 /* It is necessary to actually read one symbol *before* the start
1716 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1717 occurs before the N_SO symbol.
1719 Detecting this in read_dbx_symtab
1720 would slow down initial readin, so we look for it here instead. */
1721 if (!processing_acc_compilation && sym_offset >= (int)symbol_size)
1723 bfd_seek (symfile_bfd, sym_offset - symbol_size, SEEK_CUR);
1725 bufp = &symbuf[symbuf_idx++];
1726 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1727 OBJSTAT (objfile, n_stabs++);
1731 processing_gcc_compilation = 0;
1732 if (nlist.n_type == N_TEXT)
1734 const char *tempstring = namestring;
1736 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1737 processing_gcc_compilation = 1;
1738 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1739 processing_gcc_compilation = 2;
1740 if (tempstring[0] == bfd_get_symbol_leading_char (symfile_bfd))
1742 if (STREQN (tempstring, "__gnu_compiled", 14))
1743 processing_gcc_compilation = 2;
1746 /* Try to select a C++ demangling based on the compilation unit
1749 if (processing_gcc_compilation)
1751 if (AUTO_DEMANGLING)
1753 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1759 /* The N_SO starting this symtab is the first symbol, so we
1760 better not check the symbol before it. I'm not this can
1761 happen, but it doesn't hurt to check for it. */
1762 bfd_seek (symfile_bfd, sym_offset, SEEK_CUR);
1763 processing_gcc_compilation = 0;
1766 if (symbuf_idx == symbuf_end)
1768 bufp = &symbuf[symbuf_idx];
1769 if (bfd_h_get_8 (abfd, bufp->e_type) != N_SO)
1770 error("First symbol in segment of executable not a source symbol");
1772 max_symnum = sym_size / symbol_size;
1775 symnum < max_symnum;
1778 QUIT; /* Allow this to be interruptable */
1779 if (symbuf_idx == symbuf_end)
1781 bufp = &symbuf[symbuf_idx++];
1782 INTERNALIZE_SYMBOL (nlist, bufp, abfd);
1783 OBJSTAT (objfile, n_stabs++);
1785 type = bfd_h_get_8 (abfd, bufp->e_type);
1789 if (type & N_STAB) {
1790 process_one_symbol (type, nlist.n_desc, nlist.n_value,
1791 namestring, section_offsets, objfile);
1793 /* We skip checking for a new .o or -l file; that should never
1794 happen in this routine. */
1795 else if (type == N_TEXT)
1797 /* I don't think this code will ever be executed, because
1798 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1799 the N_SO symbol which starts this source file.
1800 However, there is no reason not to accept
1801 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1803 if (STREQ (namestring, GCC_COMPILED_FLAG_SYMBOL))
1804 processing_gcc_compilation = 1;
1805 else if (STREQ (namestring, GCC2_COMPILED_FLAG_SYMBOL))
1806 processing_gcc_compilation = 2;
1808 if (AUTO_DEMANGLING)
1810 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
1813 else if (type & N_EXT || type == (unsigned char)N_TEXT
1814 || type == (unsigned char)N_NBTEXT
1816 /* Global symbol: see if we came across a dbx defintion for
1817 a corresponding symbol. If so, store the value. Remove
1818 syms from the chain when their values are stored, but
1819 search the whole chain, as there may be several syms from
1820 different files with the same name. */
1821 /* This is probably not true. Since the files will be read
1822 in one at a time, each reference to a global symbol will
1823 be satisfied in each file as it appears. So we skip this
1829 current_objfile = NULL;
1831 /* In a Solaris elf file, this variable, which comes from the
1832 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1833 which comes from pst->textlow is correct. */
1834 if (last_source_start_addr == 0)
1835 last_source_start_addr = text_offset;
1837 /* In reordered executables last_source_start_addr may not be the
1838 lower bound for this symtab, instead use text_offset which comes
1839 from pst->textlow which is correct. */
1840 if (last_source_start_addr > text_offset)
1841 last_source_start_addr = text_offset;
1843 pst->symtab = end_symtab (text_offset + text_size, objfile, SECT_OFF_TEXT);
1845 /* Process items which we had to "process_later" due to dependancies
1847 process_now (objfile);
1853 /* This handles a single symbol from the symbol-file, building symbols
1854 into a GDB symtab. It takes these arguments and an implicit argument.
1856 TYPE is the type field of the ".stab" symbol entry.
1857 DESC is the desc field of the ".stab" entry.
1858 VALU is the value field of the ".stab" entry.
1859 NAME is the symbol name, in our address space.
1860 SECTION_OFFSETS is a set of amounts by which the sections of this object
1861 file were relocated when it was loaded into memory.
1862 All symbols that refer
1863 to memory locations need to be offset by these amounts.
1864 OBJFILE is the object file from which we are reading symbols.
1865 It is used in end_symtab. */
1868 process_one_symbol (type, desc, valu, name, section_offsets, objfile)
1872 struct section_offsets *section_offsets;
1873 struct objfile *objfile;
1875 #ifdef SUN_FIXED_LBRAC_BUG
1876 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1877 to correct the address of N_LBRAC's. If it is not defined, then
1878 we never need to correct the addresses. */
1880 /* This records the last pc address we've seen. We depend on there being
1881 an SLINE or FUN or SO before the first LBRAC, since the variable does
1882 not get reset in between reads of different symbol files. */
1883 static CORE_ADDR last_pc_address;
1886 register struct context_stack *new;
1887 /* This remembers the address of the start of a function. It is used
1888 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1889 relative to the current function's start address. On systems
1890 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1891 used to relocate these symbol types rather than SECTION_OFFSETS. */
1892 static CORE_ADDR function_start_offset;
1894 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1895 file. Used to detect the SunPRO solaris compiler. */
1896 static int n_opt_found;
1898 /* The stab type used for the definition of the last function.
1899 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1900 static int function_stab_type = 0;
1902 if (!block_address_function_relative)
1903 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1904 function start address, so just use the text offset. */
1905 function_start_offset = ANOFFSET (section_offsets, SECT_OFF_TEXT);
1907 /* Something is wrong if we see real data before
1908 seeing a source file name. */
1910 if (last_source_file == NULL && type != (unsigned char)N_SO)
1912 /* Ignore any symbols which appear before an N_SO symbol.
1913 Currently no one puts symbols there, but we should deal
1914 gracefully with the case. A complain()t might be in order,
1915 but this should not be an error (). */
1924 if (*name == '\000')
1926 /* This N_FUN marks the end of a function. This closes off the
1928 within_function = 0;
1929 new = pop_context ();
1931 /* Make a block for the local symbols within. */
1932 finish_block (new->name, &local_symbols, new->old_blocks,
1933 new->start_addr, new->start_addr + valu,
1936 /* May be switching to an assembler file which may not be using
1937 block relative stabs, so reset the offset. */
1938 if (block_address_function_relative)
1939 function_start_offset = 0;
1944 /* Relocate for dynamic loading */
1945 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
1946 #ifdef SMASH_TEXT_ADDRESS
1947 SMASH_TEXT_ADDRESS (valu);
1949 goto define_a_symbol;
1952 /* This "symbol" just indicates the start of an inner lexical
1953 context within a function. */
1955 /* Ignore extra outermost context from SunPRO cc and acc. */
1956 if (n_opt_found && desc == 1)
1959 if (block_address_function_relative)
1960 /* Relocate for Sun ELF acc fn-relative syms. */
1961 valu += function_start_offset;
1963 /* On most machines, the block addresses are relative to the
1964 N_SO, the linker did not relocate them (sigh). */
1965 valu += last_source_start_addr;
1967 #ifdef SUN_FIXED_LBRAC_BUG
1968 if (!SUN_FIXED_LBRAC_BUG && valu < last_pc_address) {
1969 /* Patch current LBRAC pc value to match last handy pc value */
1970 complain (&lbrac_complaint);
1971 valu = last_pc_address;
1974 new = push_context (desc, valu);
1978 /* This "symbol" just indicates the end of an inner lexical
1979 context that was started with N_LBRAC. */
1981 /* Ignore extra outermost context from SunPRO cc and acc. */
1982 if (n_opt_found && desc == 1)
1985 if (block_address_function_relative)
1986 /* Relocate for Sun ELF acc fn-relative syms. */
1987 valu += function_start_offset;
1989 /* On most machines, the block addresses are relative to the
1990 N_SO, the linker did not relocate them (sigh). */
1991 valu += last_source_start_addr;
1993 new = pop_context();
1994 if (desc != new->depth)
1995 complain (&lbrac_mismatch_complaint, symnum);
1997 /* Some compilers put the variable decls inside of an
1998 LBRAC/RBRAC block. This macro should be nonzero if this
1999 is true. DESC is N_DESC from the N_RBRAC symbol.
2000 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2001 or the GCC2_COMPILED_SYMBOL. */
2002 #if !defined (VARIABLES_INSIDE_BLOCK)
2003 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2006 /* Can only use new->locals as local symbols here if we're in
2007 gcc or on a machine that puts them before the lbrack. */
2008 if (!VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
2009 local_symbols = new->locals;
2011 if (context_stack_depth
2012 > !VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
2014 /* This is not the outermost LBRAC...RBRAC pair in the function,
2015 its local symbols preceded it, and are the ones just recovered
2016 from the context stack. Define the block for them (but don't
2017 bother if the block contains no symbols. Should we complain
2018 on blocks without symbols? I can't think of any useful purpose
2020 if (local_symbols != NULL)
2022 /* Muzzle a compiler bug that makes end < start. (which
2023 compilers? Is this ever harmful?). */
2024 if (new->start_addr > valu)
2026 complain (&lbrac_rbrac_complaint);
2027 new->start_addr = valu;
2029 /* Make a block for the local symbols within. */
2030 finish_block (0, &local_symbols, new->old_blocks,
2031 new->start_addr, valu, objfile);
2036 /* This is the outermost LBRAC...RBRAC pair. There is no
2037 need to do anything; leave the symbols that preceded it
2038 to be attached to the function's own block. We need to
2039 indicate that we just moved outside of the function. */
2040 within_function = 0;
2043 if (VARIABLES_INSIDE_BLOCK(desc, processing_gcc_compilation))
2044 /* Now pop locals of block just finished. */
2045 local_symbols = new->locals;
2050 /* This kind of symbol indicates the start of an object file. */
2051 /* Relocate for dynamic loading */
2052 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2056 /* This type of symbol indicates the start of data
2057 for one source file.
2058 Finish the symbol table of the previous source file
2059 (if any) and start accumulating a new symbol table. */
2060 /* Relocate for dynamic loading */
2061 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2065 #ifdef SUN_FIXED_LBRAC_BUG
2066 last_pc_address = valu; /* Save for SunOS bug circumcision */
2069 #ifdef PCC_SOL_BROKEN
2070 /* pcc bug, occasionally puts out SO for SOL. */
2071 if (context_stack_depth > 0)
2073 start_subfile (name, NULL);
2077 if (last_source_file)
2079 /* Check if previous symbol was also an N_SO (with some
2080 sanity checks). If so, that one was actually the directory
2081 name, and the current one is the real file name.
2083 if (previous_stab_code == (unsigned char) N_SO)
2085 patch_subfile_names (current_subfile, name);
2086 break; /* Ignore repeated SOs */
2088 #ifdef THIS_CODE_IS_BROKEN
2090 * doing this causes the "subfiles" which are allocated for
2091 * header files to be freed twice, and otherwise corrupts
2092 * gdb's memory & causes it to crash-n-burn -- gallatin
2094 end_symtab (valu, objfile, SECT_OFF_TEXT);
2099 /* Null name means this just marks the end of text for this .o file.
2100 Don't start a new symtab in this case. */
2101 if (*name == '\000')
2104 if (block_address_function_relative)
2105 function_start_offset = 0;
2108 start_symtab (name, NULL, valu);
2109 record_debugformat ("stabs");
2113 /* This type of symbol indicates the start of data for
2114 a sub-source-file, one whose contents were copied or
2115 included in the compilation of the main source file
2116 (whose name was given in the N_SO symbol.) */
2117 /* Relocate for dynamic loading */
2118 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2119 start_subfile (name, current_subfile->dirname);
2124 add_new_header_file (name, valu);
2125 start_subfile (name, current_subfile->dirname);
2129 start_subfile (pop_subfile (), current_subfile->dirname);
2133 add_old_header_file (name, valu);
2137 /* This type of "symbol" really just records
2138 one line-number -- core-address correspondence.
2139 Enter it in the line list for this symbol table. */
2141 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2142 valu += function_start_offset;
2144 #ifdef SUN_FIXED_LBRAC_BUG
2145 last_pc_address = valu; /* Save for SunOS bug circumcision */
2147 record_line (current_subfile, desc, valu);
2151 common_block_start (name, objfile);
2155 common_block_end (objfile);
2158 /* The following symbol types need to have the appropriate offset added
2159 to their value; then we process symbol definitions in the name. */
2161 case N_STSYM: /* Static symbol in data seg */
2162 case N_LCSYM: /* Static symbol in BSS seg */
2163 case N_ROSYM: /* Static symbol in Read-only data seg */
2164 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2165 Solaris2's stabs-in-elf makes *most* symbols relative
2166 but leaves a few absolute (at least for Solaris 2.1 and version
2167 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2168 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2169 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2170 This leaves us no choice but to search for the 'S' or 'V'...
2171 (or pass the whole section_offsets stuff down ONE MORE function
2172 call level, which we really don't want to do). */
2176 /* .o files and NLMs have non-zero text seg offsets, but don't need
2177 their static syms offset in this fashion. XXX - This is really a
2178 crock that should be fixed in the solib handling code so that I
2179 don't have to work around it here. */
2181 if (!symfile_relocatable)
2183 p = strchr (name, ':');
2184 if (p != 0 && p[1] == 'S')
2186 /* The linker relocated it. We don't want to add an
2187 elfstab_offset_sections-type offset, but we *do* want
2188 to add whatever solib.c passed to symbol_file_add as
2189 addr (this is known to affect SunOS4, and I suspect ELF
2190 too). Since elfstab_offset_sections currently does not
2191 muck with the text offset (there is no Ttext.text
2192 symbol), we can get addr from the text offset. If
2193 elfstab_offset_sections ever starts dealing with the
2194 text offset, and we still need to do this, we need to
2195 invent a SECT_OFF_ADDR_KLUDGE or something. */
2196 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2197 goto define_a_symbol;
2200 /* Since it's not the kludge case, re-dispatch to the right handler. */
2202 case N_STSYM: goto case_N_STSYM;
2203 case N_LCSYM: goto case_N_LCSYM;
2204 case N_ROSYM: goto case_N_ROSYM;
2209 case_N_STSYM: /* Static symbol in data seg */
2210 case N_DSLINE: /* Source line number, data seg */
2211 valu += ANOFFSET (section_offsets, SECT_OFF_DATA);
2212 goto define_a_symbol;
2214 case_N_LCSYM: /* Static symbol in BSS seg */
2215 case N_BSLINE: /* Source line number, bss seg */
2216 /* N_BROWS: overlaps with N_BSLINE */
2217 valu += ANOFFSET (section_offsets, SECT_OFF_BSS);
2218 goto define_a_symbol;
2220 case_N_ROSYM: /* Static symbol in Read-only data seg */
2221 valu += ANOFFSET (section_offsets, SECT_OFF_RODATA);
2222 goto define_a_symbol;
2224 case N_ENTRY: /* Alternate entry point */
2225 /* Relocate for dynamic loading */
2226 valu += ANOFFSET (section_offsets, SECT_OFF_TEXT);
2227 goto define_a_symbol;
2229 /* The following symbol types we don't know how to process. Handle
2230 them in a "default" way, but complain to people who care. */
2232 case N_CATCH: /* Exception handler catcher */
2233 case N_EHDECL: /* Exception handler name */
2234 case N_PC: /* Global symbol in Pascal */
2235 case N_M2C: /* Modula-2 compilation unit */
2236 /* N_MOD2: overlaps with N_EHDECL */
2237 case N_SCOPE: /* Modula-2 scope information */
2238 case N_ECOML: /* End common (local name) */
2239 case N_NBTEXT: /* Gould Non-Base-Register symbols??? */
2244 complain (&unknown_symtype_complaint, local_hex_string (type));
2247 /* The following symbol types don't need the address field relocated,
2248 since it is either unused, or is absolute. */
2250 case N_GSYM: /* Global variable */
2251 case N_NSYMS: /* Number of symbols (ultrix) */
2252 case N_NOMAP: /* No map? (ultrix) */
2253 case N_RSYM: /* Register variable */
2254 case N_DEFD: /* Modula-2 GNU module dependency */
2255 case N_SSYM: /* Struct or union element */
2256 case N_LSYM: /* Local symbol in stack */
2257 case N_PSYM: /* Parameter variable */
2258 case N_LENG: /* Length of preceding symbol type */
2262 char *colon_pos = strchr (name, ':');
2263 if (colon_pos == NULL)
2266 deftype = colon_pos[1];
2272 function_stab_type = type;
2274 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2275 /* Deal with the SunPRO 3.0 compiler which omits the address
2276 from N_FUN symbols. */
2278 && valu == ANOFFSET (section_offsets, SECT_OFF_TEXT))
2280 struct minimal_symbol *msym;
2284 p = strchr (name, ':');
2289 strncpy (p, name, n);
2292 msym = lookup_minimal_symbol (p, last_source_file,
2296 /* Sun Fortran appends an underscore to the minimal
2297 symbol name, try again with an appended underscore
2298 if the minimal symbol was not found. */
2301 msym = lookup_minimal_symbol (p, last_source_file,
2305 valu = SYMBOL_VALUE_ADDRESS (msym);
2309 #ifdef SUN_FIXED_LBRAC_BUG
2310 /* The Sun acc compiler, under SunOS4, puts out
2311 functions with N_GSYM or N_STSYM. The problem is
2312 that the address of the symbol is no good (for N_GSYM
2313 it doesn't even attept an address; for N_STSYM it
2314 puts out an address but then it gets relocated
2315 relative to the data segment, not the text segment).
2316 Currently we can't fix this up later as we do for
2317 some types of symbol in scan_file_globals.
2318 Fortunately we do have a way of finding the address -
2319 we know that the value in last_pc_address is either
2320 the one we want (if we're dealing with the first
2321 function in an object file), or somewhere in the
2322 previous function. This means that we can use the
2323 minimal symbol table to get the address. */
2325 /* Starting with release 3.0, the Sun acc compiler,
2326 under SunOS4, puts out functions with N_FUN and a value
2327 of zero. This gets relocated to the start of the text
2328 segment of the module, which is no good either.
2329 Under SunOS4 we can deal with this as N_SLINE and N_SO
2330 entries contain valid absolute addresses.
2331 Release 3.0 acc also puts out N_OPT entries, which makes
2332 it possible to discern acc from cc or gcc. */
2334 if (type == N_GSYM || type == N_STSYM
2336 && n_opt_found && !block_address_function_relative))
2338 struct minimal_symbol *m;
2339 int l = colon_pos - name;
2341 m = lookup_minimal_symbol_by_pc (last_pc_address);
2342 if (m && STREQN (SYMBOL_NAME (m), name, l)
2343 && SYMBOL_NAME (m) [l] == '\0')
2344 /* last_pc_address was in this function */
2345 valu = SYMBOL_VALUE (m);
2346 else if (m && SYMBOL_NAME (m+1)
2347 && STREQN (SYMBOL_NAME (m+1), name, l)
2348 && SYMBOL_NAME (m+1) [l] == '\0')
2349 /* last_pc_address was in last function */
2350 valu = SYMBOL_VALUE (m+1);
2352 /* Not found - use last_pc_address (for finish_block) */
2353 valu = last_pc_address;
2356 last_pc_address = valu; /* Save for SunOS bug circumcision */
2359 if (block_address_function_relative)
2360 /* For Solaris 2.0 compilers, the block addresses and
2361 N_SLINE's are relative to the start of the
2362 function. On normal systems, and when using gcc on
2363 Solaris 2.0, these addresses are just absolute, or
2364 relative to the N_SO, depending on
2365 BLOCK_ADDRESS_ABSOLUTE. */
2366 function_start_offset = valu;
2368 within_function = 1;
2369 if (context_stack_depth > 0)
2371 new = pop_context ();
2372 /* Make a block for the local symbols within. */
2373 finish_block (new->name, &local_symbols, new->old_blocks,
2374 new->start_addr, valu, objfile);
2376 /* Stack must be empty now. */
2377 if (context_stack_depth != 0)
2378 complain (&lbrac_unmatched_complaint, symnum);
2380 new = push_context (0, valu);
2381 new->name = define_symbol (valu, name, desc, type, objfile);
2385 define_symbol (valu, name, desc, type, objfile);
2391 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2392 for a bunch of other flags, too. Someday we may parse their
2393 flags; for now we ignore theirs and hope they'll ignore ours. */
2394 case N_OPT: /* Solaris 2: Compiler options */
2397 if (STREQ (name, GCC2_COMPILED_FLAG_SYMBOL))
2399 processing_gcc_compilation = 2;
2400 #if 1 /* Works, but is experimental. -fnf */
2401 if (AUTO_DEMANGLING)
2403 set_demangling_style (GNU_DEMANGLING_STYLE_STRING);
2412 /* The following symbol types can be ignored. */
2413 case N_OBJ: /* Solaris 2: Object file dir and name */
2414 /* N_UNDF: Solaris 2: file separator mark */
2415 /* N_UNDF: -- we will never encounter it, since we only process one
2416 file's symbols at once. */
2417 case N_ENDM: /* Solaris 2: End of module */
2418 case N_MAIN: /* Name of main routine. */
2419 #if 0 /* XXX remove when binutils 2.9.2 is imported */
2420 case N_ALIAS: /* SunPro F77: alias name, ignore for now. */
2425 /* '#' is a GNU C extension to allow one symbol to refer to another
2428 Generally this is used so that an alias can refer to its main
2432 /* Initialize symbol reference names and determine if this is
2433 a definition. If symbol reference is being defined, go
2434 ahead and add it. Otherwise, just return sym. */
2439 /* If this stab defines a new reference ID that is not on the
2440 reference list, then put it on the reference list.
2442 We go ahead and advance NAME past the reference, even though
2443 it is not strictly necessary at this time. */
2444 refnum = symbol_reference_defined (&s);
2446 if (!ref_search (refnum))
2447 ref_add (refnum, 0, name, valu);
2452 previous_stab_code = type;
2455 /* FIXME: The only difference between this and elfstab_build_psymtabs
2456 is the call to install_minimal_symbols for elf, and the support for
2457 split sections. If the differences are really that small, the code
2458 should be shared. */
2460 /* Scan and build partial symbols for an coff symbol file.
2461 The coff file has already been processed to get its minimal symbols.
2463 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2466 OBJFILE is the object file we are reading symbols from.
2467 ADDR is the address relative to which the symbols are (e.g.
2468 the base address of the text segment).
2469 MAINLINE is true if we are reading the main symbol
2470 table (as opposed to a shared lib or dynamically loaded file).
2471 TEXTADDR is the address of the text section.
2472 TEXTSIZE is the size of the text section.
2473 STABSECTS is the list of .stab sections in OBJFILE.
2474 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2475 .stabstr section exists.
2477 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2478 adjusted for coff details. */
2481 coffstab_build_psymtabs (objfile, section_offsets, mainline,
2482 textaddr, textsize, stabsects,
2483 stabstroffset, stabstrsize)
2484 struct objfile *objfile;
2485 struct section_offsets *section_offsets;
2488 unsigned int textsize;
2489 struct stab_section_list *stabsects;
2490 file_ptr stabstroffset;
2491 unsigned int stabstrsize;
2494 bfd *sym_bfd = objfile->obfd;
2495 char *name = bfd_get_filename (sym_bfd);
2496 struct dbx_symfile_info *info;
2497 unsigned int stabsize;
2499 /* There is already a dbx_symfile_info allocated by our caller.
2500 It might even contain some info from the coff symtab to help us. */
2501 info = objfile->sym_stab_info;
2503 DBX_TEXT_ADDR (objfile) = textaddr;
2504 DBX_TEXT_SIZE (objfile) = textsize;
2506 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2507 DBX_SYMBOL_SIZE (objfile) = COFF_STABS_SYMBOL_SIZE;
2508 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2510 if (stabstrsize > bfd_get_size (sym_bfd))
2511 error ("ridiculous string table size: %d bytes", stabstrsize);
2512 DBX_STRINGTAB (objfile) = (char *)
2513 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2514 OBJSTAT (objfile, sz_strtab += stabstrsize+1);
2516 /* Now read in the string table in one big gulp. */
2518 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2520 perror_with_name (name);
2521 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2522 if (val != stabstrsize)
2523 perror_with_name (name);
2525 stabsread_new_init ();
2526 buildsym_new_init ();
2527 free_header_files ();
2528 init_header_files ();
2530 processing_acc_compilation = 1;
2532 /* In a coff file, we've already installed the minimal symbols that came
2533 from the coff (non-stab) symbol table, so always act like an
2534 incremental load here. */
2535 if (stabsects->next == NULL)
2537 stabsize = bfd_section_size (sym_bfd, stabsects->section);
2538 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2539 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2543 struct stab_section_list *stabsect;
2545 DBX_SYMCOUNT (objfile) = 0;
2546 for (stabsect = stabsects; stabsect != NULL; stabsect = stabsect->next)
2548 stabsize = bfd_section_size (sym_bfd, stabsect->section);
2549 DBX_SYMCOUNT (objfile) += stabsize / DBX_SYMBOL_SIZE (objfile);
2552 DBX_SYMTAB_OFFSET (objfile) = stabsects->section->filepos;
2554 symbuf_sections = stabsects->next;
2555 symbuf_left = bfd_section_size (sym_bfd, stabsects->section);
2559 dbx_symfile_read (objfile, section_offsets, 0);
2562 /* Scan and build partial symbols for an ELF symbol file.
2563 This ELF file has already been processed to get its minimal symbols,
2564 and any DWARF symbols that were in it.
2566 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2569 OBJFILE is the object file we are reading symbols from.
2570 ADDR is the address relative to which the symbols are (e.g.
2571 the base address of the text segment).
2572 MAINLINE is true if we are reading the main symbol
2573 table (as opposed to a shared lib or dynamically loaded file).
2574 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2576 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2577 .stabstr section exists.
2579 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2580 adjusted for elf details. */
2583 elfstab_build_psymtabs (objfile, section_offsets, mainline,
2584 staboffset, stabsize,
2585 stabstroffset, stabstrsize)
2586 struct objfile *objfile;
2587 struct section_offsets *section_offsets;
2589 file_ptr staboffset;
2590 unsigned int stabsize;
2591 file_ptr stabstroffset;
2592 unsigned int stabstrsize;
2595 bfd *sym_bfd = objfile->obfd;
2596 char *name = bfd_get_filename (sym_bfd);
2597 struct dbx_symfile_info *info;
2598 asection *text_sect;
2600 /* There is already a dbx_symfile_info allocated by our caller.
2601 It might even contain some info from the ELF symtab to help us. */
2602 info = objfile->sym_stab_info;
2604 text_sect = bfd_get_section_by_name (sym_bfd, ".text");
2606 error ("Can't find .text section in symbol file");
2607 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
2608 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
2610 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2611 DBX_SYMBOL_SIZE (objfile) = ELF_STABS_SYMBOL_SIZE;
2612 DBX_SYMCOUNT (objfile) = stabsize / DBX_SYMBOL_SIZE (objfile);
2613 DBX_STRINGTAB_SIZE (objfile) = stabstrsize;
2614 DBX_SYMTAB_OFFSET (objfile) = staboffset;
2616 if (stabstrsize > bfd_get_size (sym_bfd))
2617 error ("ridiculous string table size: %d bytes", stabstrsize);
2618 DBX_STRINGTAB (objfile) = (char *)
2619 obstack_alloc (&objfile->psymbol_obstack, stabstrsize+1);
2620 OBJSTAT (objfile, sz_strtab += stabstrsize+1);
2622 /* Now read in the string table in one big gulp. */
2624 val = bfd_seek (sym_bfd, stabstroffset, SEEK_SET);
2626 perror_with_name (name);
2627 val = bfd_read (DBX_STRINGTAB (objfile), stabstrsize, 1, sym_bfd);
2628 if (val != stabstrsize)
2629 perror_with_name (name);
2631 stabsread_new_init ();
2632 buildsym_new_init ();
2633 free_header_files ();
2634 init_header_files ();
2635 install_minimal_symbols (objfile);
2637 processing_acc_compilation = 1;
2639 /* In an elf file, we've already installed the minimal symbols that came
2640 from the elf (non-stab) symbol table, so always act like an
2641 incremental load here. */
2642 dbx_symfile_read (objfile, section_offsets, 0);
2645 /* Scan and build partial symbols for a file with special sections for stabs
2646 and stabstrings. The file has already been processed to get its minimal
2647 symbols, and any other symbols that might be necessary to resolve GSYMs.
2649 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2652 OBJFILE is the object file we are reading symbols from.
2653 ADDR is the address relative to which the symbols are (e.g. the base address
2654 of the text segment).
2655 MAINLINE is true if we are reading the main symbol table (as opposed to a
2656 shared lib or dynamically loaded file).
2657 STAB_NAME is the name of the section that contains the stabs.
2658 STABSTR_NAME is the name of the section that contains the stab strings.
2660 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2663 stabsect_build_psymtabs (objfile, section_offsets, mainline, stab_name,
2664 stabstr_name, text_name)
2665 struct objfile *objfile;
2666 struct section_offsets *section_offsets;
2673 bfd *sym_bfd = objfile->obfd;
2674 char *name = bfd_get_filename (sym_bfd);
2676 asection *stabstrsect;
2677 asection *text_sect;
2679 stabsect = bfd_get_section_by_name (sym_bfd, stab_name);
2680 stabstrsect = bfd_get_section_by_name (sym_bfd, stabstr_name);
2686 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2687 stab_name, stabstr_name);
2689 objfile->sym_stab_info = (struct dbx_symfile_info *)
2690 xmalloc (sizeof (struct dbx_symfile_info));
2691 memset (objfile->sym_stab_info, 0, sizeof (struct dbx_symfile_info));
2693 text_sect = bfd_get_section_by_name (sym_bfd, text_name);
2695 error ("Can't find %s section in symbol file", text_name);
2696 DBX_TEXT_ADDR (objfile) = bfd_section_vma (sym_bfd, text_sect);
2697 DBX_TEXT_SIZE (objfile) = bfd_section_size (sym_bfd, text_sect);
2699 DBX_SYMBOL_SIZE (objfile) = sizeof (struct external_nlist);
2700 DBX_SYMCOUNT (objfile) = bfd_section_size (sym_bfd, stabsect)
2701 / DBX_SYMBOL_SIZE (objfile);
2702 DBX_STRINGTAB_SIZE (objfile) = bfd_section_size (sym_bfd, stabstrsect);
2703 DBX_SYMTAB_OFFSET (objfile) = stabsect->filepos; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2705 if (DBX_STRINGTAB_SIZE (objfile) > bfd_get_size (sym_bfd))
2706 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile));
2707 DBX_STRINGTAB (objfile) = (char *)
2708 obstack_alloc (&objfile->psymbol_obstack, DBX_STRINGTAB_SIZE (objfile) + 1);
2709 OBJSTAT (objfile, sz_strtab += DBX_STRINGTAB_SIZE (objfile) + 1);
2711 /* Now read in the string table in one big gulp. */
2713 val = bfd_get_section_contents (sym_bfd, /* bfd */
2714 stabstrsect, /* bfd section */
2715 DBX_STRINGTAB (objfile), /* input buffer */
2716 0, /* offset into section */
2717 DBX_STRINGTAB_SIZE (objfile)); /* amount to read */
2720 perror_with_name (name);
2722 stabsread_new_init ();
2723 buildsym_new_init ();
2724 free_header_files ();
2725 init_header_files ();
2726 install_minimal_symbols (objfile);
2728 /* Now, do an incremental load */
2730 processing_acc_compilation = 1;
2731 dbx_symfile_read (objfile, section_offsets, 0);
2734 static struct sym_fns aout_sym_fns =
2736 bfd_target_aout_flavour,
2737 dbx_new_init, /* sym_new_init: init anything gbl to entire symtab */
2738 dbx_symfile_init, /* sym_init: read initial info, setup for sym_read() */
2739 dbx_symfile_read, /* sym_read: read a symbol file into symtab */
2740 dbx_symfile_finish, /* sym_finish: finished with file, cleanup */
2741 default_symfile_offsets,
2742 /* sym_offsets: parse user's offsets to internal form */
2743 NULL /* next: pointer to next struct sym_fns */
2747 _initialize_dbxread ()
2749 add_symtab_fns(&aout_sym_fns);