1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 1998
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This module provides three functions: dbx_symfile_init,
23 which initializes to read a symbol file; dbx_new_init, which
24 discards existing cached information when all symbols are being
25 discarded; and dbx_symfile_read, which reads a symbol table
28 dbx_symfile_read only does the minimum work necessary for letting the
29 user "name" things symbolically; it does not read the entire symtab.
30 Instead, it reads the external and static symbols and puts them in partial
31 symbol tables. When more extensive information is requested of a
32 file, the corresponding partial symbol table is mutated into a full
33 fledged symbol table by going back and reading the symbols
34 for real. dbx_psymtab_to_symtab() is the function that does this */
37 #include "gdb_string.h"
39 #if defined(USG) || defined(__CYGNUSCLIB__)
40 #include <sys/types.h>
48 #include "breakpoint.h"
51 #include "gdbcore.h" /* for bfd stuff */
52 #include "libaout.h" /* FIXME Secret internal BFD stuff for a.out */
56 #include "stabsread.h"
57 #include "gdb-stabs.h"
59 #include "language.h" /* Needed inside partial-stab.h */
60 #include "complaints.h"
62 #include "aout/aout64.h"
63 #include "aout/stab_gnu.h" /* We always use GNU stabs, not native, now */
66 /* This macro returns the size field of a minimal symbol, which is normally
67 stored in the "info" field. The macro can be overridden for specific
68 targets (e.g. MIPS16) that use the info field for other purposes. */
70 #define MSYMBOL_SIZE(msym) ((long) MSYMBOL_INFO (msym))
74 /* We put a pointer to this structure in the read_symtab_private field
80 /* Offset within the file symbol table of first local symbol for this
85 /* Length (in bytes) of the section of the symbol table devoted to
86 this file's symbols (actually, the section bracketed may contain
87 more than just this file's symbols). If ldsymlen is 0, the only
88 reason for this thing's existence is the dependency list. Nothing
89 else will happen when it is read in. */
93 /* The size of each symbol in the symbol file (in external form). */
97 /* Further information needed to locate the symbols if they are in
102 int file_string_offset
;
105 #define LDSYMOFF(p) (((struct symloc *)((p)->read_symtab_private))->ldsymoff)
106 #define LDSYMLEN(p) (((struct symloc *)((p)->read_symtab_private))->ldsymlen)
107 #define SYMLOC(p) ((struct symloc *)((p)->read_symtab_private))
108 #define SYMBOL_SIZE(p) (SYMLOC(p)->symbol_size)
109 #define SYMBOL_OFFSET(p) (SYMLOC(p)->symbol_offset)
110 #define STRING_OFFSET(p) (SYMLOC(p)->string_offset)
111 #define FILE_STRING_OFFSET(p) (SYMLOC(p)->file_string_offset)
114 /* Remember what we deduced to be the source language of this psymtab. */
116 static enum language psymtab_language
= language_unknown
;
118 /* Nonzero means give verbose info on gdb action. From main.c. */
120 extern int info_verbose
;
122 /* The BFD for this file -- implicit parameter to next_symbol_text. */
124 static bfd
*symfile_bfd
;
126 /* The size of each symbol in the symbol file (in external form).
127 This is set by dbx_symfile_read when building psymtabs, and by
128 dbx_psymtab_to_symtab when building symtabs. */
130 static unsigned symbol_size
;
132 /* This is the offset of the symbol table in the executable file. */
134 static unsigned symbol_table_offset
;
136 /* This is the offset of the string table in the executable file. */
138 static unsigned string_table_offset
;
140 /* For elf+stab executables, the n_strx field is not a simple index
141 into the string table. Instead, each .o file has a base offset in
142 the string table, and the associated symbols contain offsets from
143 this base. The following two variables contain the base offset for
144 the current and next .o files. */
146 static unsigned int file_string_table_offset
;
147 static unsigned int next_file_string_table_offset
;
149 /* .o and NLM files contain unrelocated addresses which are based at
150 0. When non-zero, this flag disables some of the special cases for
151 Solaris elf+stab text addresses at location 0. */
153 static int symfile_relocatable
= 0;
155 /* If this is nonzero, N_LBRAC, N_RBRAC, and N_SLINE entries are
156 relative to the function start address. */
158 static int block_address_function_relative
= 0;
160 /* The lowest text address we have yet encountered. This is needed
161 because in an a.out file, there is no header field which tells us
162 what address the program is actually going to be loaded at, so we
163 need to make guesses based on the symbols (which *are* relocated to
164 reflect the address it will be loaded at). */
166 static CORE_ADDR lowest_text_address
;
168 /* Non-zero if there is any line number info in the objfile. Prevents
169 end_psymtab from discarding an otherwise empty psymtab. */
171 static int has_line_numbers
;
173 /* Complaints about the symbols we have encountered. */
175 struct complaint lbrac_complaint
=
176 {"bad block start address patched", 0, 0};
178 struct complaint string_table_offset_complaint
=
179 {"bad string table offset in symbol %d", 0, 0};
181 struct complaint unknown_symtype_complaint
=
182 {"unknown symbol type %s", 0, 0};
184 struct complaint unknown_symchar_complaint
=
185 {"unknown symbol descriptor `%c'", 0, 0};
187 struct complaint lbrac_rbrac_complaint
=
188 {"block start larger than block end", 0, 0};
190 struct complaint lbrac_unmatched_complaint
=
191 {"unmatched N_LBRAC before symtab pos %d", 0, 0};
193 struct complaint lbrac_mismatch_complaint
=
194 {"N_LBRAC/N_RBRAC symbol mismatch at symtab pos %d", 0, 0};
196 struct complaint repeated_header_complaint
=
197 {"\"repeated\" header file %s not previously seen, at symtab pos %d", 0, 0};
199 struct complaint unclaimed_bincl_complaint
=
200 {"N_BINCL %s not in entries for any file, at symtab pos %d", 0, 0};
202 /* find_text_range --- find start and end of loadable code sections
204 The find_text_range function finds the shortest address range that
205 encloses all sections containing executable code, and stores it in
206 objfile's text_addr and text_size members.
208 dbx_symfile_read will use this to finish off the partial symbol
209 table, in some cases. */
212 find_text_range (bfd
* sym_bfd
, struct objfile
*objfile
)
216 CORE_ADDR start
, end
;
218 for (sec
= sym_bfd
->sections
; sec
; sec
= sec
->next
)
219 if (bfd_get_section_flags (sym_bfd
, sec
) & SEC_CODE
)
221 CORE_ADDR sec_start
= bfd_section_vma (sym_bfd
, sec
);
222 CORE_ADDR sec_end
= sec_start
+ bfd_section_size (sym_bfd
, sec
);
226 if (sec_start
< start
)
241 error ("Can't find any code sections in symbol file");
243 DBX_TEXT_ADDR (objfile
) = start
;
244 DBX_TEXT_SIZE (objfile
) = end
- start
;
249 /* During initial symbol readin, we need to have a structure to keep
250 track of which psymtabs have which bincls in them. This structure
251 is used during readin to setup the list of dependencies within each
252 partial symbol table. */
254 struct header_file_location
256 char *name
; /* Name of header file */
257 int instance
; /* See above */
258 struct partial_symtab
*pst
; /* Partial symtab that has the
259 BINCL/EINCL defs for this file */
262 /* The actual list and controling variables */
263 static struct header_file_location
*bincl_list
, *next_bincl
;
264 static int bincls_allocated
;
266 /* Local function prototypes */
268 extern void _initialize_dbxread
PARAMS ((void));
271 process_now
PARAMS ((struct objfile
*));
274 free_header_files
PARAMS ((void));
277 init_header_files
PARAMS ((void));
280 read_ofile_symtab
PARAMS ((struct partial_symtab
*));
283 dbx_psymtab_to_symtab
PARAMS ((struct partial_symtab
*));
286 dbx_psymtab_to_symtab_1
PARAMS ((struct partial_symtab
*));
289 read_dbx_dynamic_symtab
PARAMS ((struct section_offsets
*,
290 struct objfile
* objfile
));
293 read_dbx_symtab
PARAMS ((struct section_offsets
*, struct objfile
*,
297 free_bincl_list
PARAMS ((struct objfile
*));
299 static struct partial_symtab
*
300 find_corresponding_bincl_psymtab
PARAMS ((char *, int));
303 add_bincl_to_list
PARAMS ((struct partial_symtab
*, char *, int));
306 init_bincl_list
PARAMS ((int, struct objfile
*));
309 dbx_next_symbol_text
PARAMS ((struct objfile
*));
312 fill_symbuf
PARAMS ((bfd
*));
315 dbx_symfile_init
PARAMS ((struct objfile
*));
318 dbx_new_init
PARAMS ((struct objfile
*));
321 dbx_symfile_read
PARAMS ((struct objfile
*, struct section_offsets
*, int));
324 dbx_symfile_finish
PARAMS ((struct objfile
*));
327 record_minimal_symbol
PARAMS ((char *, CORE_ADDR
, int, struct objfile
*));
330 add_new_header_file
PARAMS ((char *, int));
333 add_old_header_file
PARAMS ((char *, int));
336 add_this_object_header_file
PARAMS ((int));
338 /* Free up old header file tables */
343 if (this_object_header_files
)
345 free ((PTR
) this_object_header_files
);
346 this_object_header_files
= NULL
;
348 n_allocated_this_object_header_files
= 0;
351 /* Allocate new header file tables */
356 n_allocated_this_object_header_files
= 10;
357 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
360 /* Add header file number I for this object file
361 at the next successive FILENUM. */
364 add_this_object_header_file (i
)
367 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
369 n_allocated_this_object_header_files
*= 2;
370 this_object_header_files
371 = (int *) xrealloc ((char *) this_object_header_files
,
372 n_allocated_this_object_header_files
* sizeof (int));
375 this_object_header_files
[n_this_object_header_files
++] = i
;
378 /* Add to this file an "old" header file, one already seen in
379 a previous object file. NAME is the header file's name.
380 INSTANCE is its instance code, to select among multiple
381 symbol tables for the same header file. */
384 add_old_header_file (name
, instance
)
388 register struct header_file
*p
= HEADER_FILES (current_objfile
);
391 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
392 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
394 add_this_object_header_file (i
);
397 complain (&repeated_header_complaint
, name
, symnum
);
400 /* Add to this file a "new" header file: definitions for its types follow.
401 NAME is the header file's name.
402 Most often this happens only once for each distinct header file,
403 but not necessarily. If it happens more than once, INSTANCE has
404 a different value each time, and references to the header file
405 use INSTANCE values to select among them.
407 dbx output contains "begin" and "end" markers for each new header file,
408 but at this level we just need to know which files there have been;
409 so we record the file when its "begin" is seen and ignore the "end". */
412 add_new_header_file (name
, instance
)
417 register struct header_file
*hfile
;
419 /* Make sure there is room for one more header file. */
421 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
423 if (N_HEADER_FILES (current_objfile
) == i
)
427 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
428 HEADER_FILES (current_objfile
) = (struct header_file
*)
429 xmalloc (10 * sizeof (struct header_file
));
434 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
435 HEADER_FILES (current_objfile
) = (struct header_file
*)
436 xrealloc ((char *) HEADER_FILES (current_objfile
),
437 (i
* sizeof (struct header_file
)));
441 /* Create an entry for this header file. */
443 i
= N_HEADER_FILES (current_objfile
)++;
444 hfile
= HEADER_FILES (current_objfile
) + i
;
445 hfile
->name
= savestring (name
, strlen (name
));
446 hfile
->instance
= instance
;
449 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
450 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
452 add_this_object_header_file (i
);
456 static struct type
**
457 explicit_lookup_type (real_filenum
, index
)
458 int real_filenum
, index
;
460 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
462 if (index
>= f
->length
)
465 f
->vector
= (struct type
**)
466 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
467 memset (&f
->vector
[f
->length
/ 2],
468 '\0', f
->length
* sizeof (struct type
*) / 2);
470 return &f
->vector
[index
];
475 record_minimal_symbol (name
, address
, type
, objfile
)
479 struct objfile
*objfile
;
481 enum minimal_symbol_type ms_type
;
483 asection
*bfd_section
;
489 section
= SECT_OFF_TEXT
;
490 bfd_section
= DBX_TEXT_SECTION (objfile
);
494 section
= SECT_OFF_DATA
;
495 bfd_section
= DBX_DATA_SECTION (objfile
);
499 section
= SECT_OFF_BSS
;
500 bfd_section
= DBX_BSS_SECTION (objfile
);
510 section
= SECT_OFF_DATA
;
511 bfd_section
= DBX_DATA_SECTION (objfile
);
514 /* I don't think this type actually exists; since a N_SETV is the result
515 of going over many .o files, it doesn't make sense to have one
517 ms_type
= mst_file_data
;
518 section
= SECT_OFF_DATA
;
519 bfd_section
= DBX_DATA_SECTION (objfile
);
526 ms_type
= mst_file_text
;
527 section
= SECT_OFF_TEXT
;
528 bfd_section
= DBX_TEXT_SECTION (objfile
);
531 ms_type
= mst_file_data
;
533 /* Check for __DYNAMIC, which is used by Sun shared libraries.
534 Record it as global even if it's local, not global, so
535 lookup_minimal_symbol can find it. We don't check symbol_leading_char
536 because for SunOS4 it always is '_'. */
537 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
540 /* Same with virtual function tables, both global and static. */
542 char *tempstring
= name
;
543 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
545 if (VTBL_PREFIX_P ((tempstring
)))
548 section
= SECT_OFF_DATA
;
549 bfd_section
= DBX_DATA_SECTION (objfile
);
552 ms_type
= mst_file_bss
;
553 section
= SECT_OFF_BSS
;
554 bfd_section
= DBX_BSS_SECTION (objfile
);
557 ms_type
= mst_unknown
;
563 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
564 && address
< lowest_text_address
)
565 lowest_text_address
= address
;
567 prim_record_minimal_symbol_and_info
568 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
571 /* Scan and build partial symbols for a symbol file.
572 We have been initialized by a call to dbx_symfile_init, which
573 put all the relevant info into a "struct dbx_symfile_info",
574 hung off the objfile structure.
576 SECTION_OFFSETS contains offsets relative to which the symbols in the
577 various sections are (depending where the sections were actually loaded).
578 MAINLINE is true if we are reading the main symbol
579 table (as opposed to a shared lib or dynamically loaded file). */
582 dbx_symfile_read (objfile
, section_offsets
, mainline
)
583 struct objfile
*objfile
;
584 struct section_offsets
*section_offsets
;
585 int mainline
; /* FIXME comments above */
589 struct cleanup
*back_to
;
591 val
= strlen (objfile
->name
);
593 sym_bfd
= objfile
->obfd
;
595 /* .o and .nlm files are relocatables with text, data and bss segs based at
596 0. This flag disables special (Solaris stabs-in-elf only) fixups for
597 symbols with a value of 0. */
599 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
601 /* This is true for Solaris (and all other systems which put stabs
602 in sections, hopefully, since it would be silly to do things
603 differently from Solaris), and false for SunOS4 and other a.out
605 block_address_function_relative
=
606 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
607 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
608 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
609 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
610 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
612 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
614 perror_with_name (objfile
->name
);
616 /* If we are reinitializing, or if we have never loaded syms yet, init */
618 || objfile
->global_psymbols
.size
== 0
619 || objfile
->static_psymbols
.size
== 0)
620 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
622 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
623 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
625 free_pending_blocks ();
626 back_to
= make_cleanup ((make_cleanup_func
) really_free_pendings
, 0);
628 init_minimal_symbol_collection ();
629 make_cleanup ((make_cleanup_func
) discard_minimal_symbols
, 0);
631 /* Now that the symbol table data of the executable file are all in core,
632 process them and define symbols accordingly. */
634 read_dbx_symtab (section_offsets
, objfile
,
635 DBX_TEXT_ADDR (objfile
),
636 DBX_TEXT_SIZE (objfile
));
638 /* Add the dynamic symbols. */
640 read_dbx_dynamic_symtab (section_offsets
, objfile
);
642 /* Install any minimal symbols that have been collected as the current
643 minimal symbols for this objfile. */
645 install_minimal_symbols (objfile
);
647 do_cleanups (back_to
);
650 /* Initialize anything that needs initializing when a completely new
651 symbol file is specified (not just adding some symbols from another
652 file, e.g. a shared library). */
655 dbx_new_init (ignore
)
656 struct objfile
*ignore
;
658 stabsread_new_init ();
659 buildsym_new_init ();
660 init_header_files ();
664 /* dbx_symfile_init ()
665 is the dbx-specific initialization routine for reading symbols.
666 It is passed a struct objfile which contains, among other things,
667 the BFD for the file whose symbols are being read, and a slot for a pointer
668 to "private data" which we fill with goodies.
670 We read the string table into malloc'd space and stash a pointer to it.
672 Since BFD doesn't know how to read debug symbols in a format-independent
673 way (and may never do so...), we have to do it ourselves. We will never
674 be called unless this is an a.out (or very similar) file.
675 FIXME, there should be a cleaner peephole into the BFD environment here. */
677 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
680 dbx_symfile_init (objfile
)
681 struct objfile
*objfile
;
684 bfd
*sym_bfd
= objfile
->obfd
;
685 char *name
= bfd_get_filename (sym_bfd
);
687 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
689 /* Allocate struct to keep track of the symfile */
690 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
691 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
692 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
694 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
695 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
696 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
698 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
699 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
700 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
702 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
704 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
706 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
708 error ("Can't find .text section in symbol file");
709 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
710 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
712 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
713 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
714 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
716 /* Read the string table and stash it away in the psymbol_obstack. It is
717 only needed as long as we need to expand psymbols into full symbols,
718 so when we blow away the psymbol the string table goes away as well.
719 Note that gdb used to use the results of attempting to malloc the
720 string table, based on the size it read, as a form of sanity check
721 for botched byte swapping, on the theory that a byte swapped string
722 table size would be so totally bogus that the malloc would fail. Now
723 that we put in on the psymbol_obstack, we can't do this since gdb gets
724 a fatal error (out of virtual memory) if the size is bogus. We can
725 however at least check to see if the size is less than the size of
726 the size field itself, or larger than the size of the entire file.
727 Note that all valid string tables have a size greater than zero, since
728 the bytes used to hold the size are included in the count. */
730 if (STRING_TABLE_OFFSET
== 0)
732 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
733 will never be zero, even when there is no string table. This
734 would appear to be a bug in bfd. */
735 DBX_STRINGTAB_SIZE (objfile
) = 0;
736 DBX_STRINGTAB (objfile
) = NULL
;
740 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
742 perror_with_name (name
);
744 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
745 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
748 perror_with_name (name
);
752 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
753 EOF if there is no string table, and attempting to read the size
754 from EOF will read zero bytes. */
755 DBX_STRINGTAB_SIZE (objfile
) = 0;
756 DBX_STRINGTAB (objfile
) = NULL
;
760 /* Read some data that would appear to be the string table size.
761 If there really is a string table, then it is probably the right
762 size. Byteswap if necessary and validate the size. Note that
763 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
764 random data that happened to be at STRING_TABLE_OFFSET, because
765 bfd can't tell us there is no string table, the sanity checks may
766 or may not catch this. */
767 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
769 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
770 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
771 error ("ridiculous string table size (%d bytes).",
772 DBX_STRINGTAB_SIZE (objfile
));
774 DBX_STRINGTAB (objfile
) =
775 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
776 DBX_STRINGTAB_SIZE (objfile
));
777 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
779 /* Now read in the string table in one big gulp. */
781 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
783 perror_with_name (name
);
784 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
786 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
787 perror_with_name (name
);
792 /* Perform any local cleanups required when we are done with a particular
793 objfile. I.E, we are in the process of discarding all symbol information
794 for an objfile, freeing up all memory held for it, and unlinking the
795 objfile struct from the global list of known objfiles. */
798 dbx_symfile_finish (objfile
)
799 struct objfile
*objfile
;
801 if (objfile
->sym_stab_info
!= NULL
)
803 if (HEADER_FILES (objfile
) != NULL
)
805 register int i
= N_HEADER_FILES (objfile
);
806 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
810 free (hfiles
[i
].name
);
811 free (hfiles
[i
].vector
);
815 mfree (objfile
->md
, objfile
->sym_stab_info
);
817 free_header_files ();
821 /* Buffer for reading the symbol table entries. */
822 static struct external_nlist symbuf
[4096];
823 static int symbuf_idx
;
824 static int symbuf_end
;
826 /* cont_elem is used for continuing information in cfront.
827 It saves information about which types need to be fixed up and
828 completed after all the stabs are read. */
831 /* sym and stabsstring for continuing information in cfront */
834 /* state dependancies (statics that must be preserved) */
838 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
839 /* other state dependancies include:
840 (assumption is that these will not change since process_now FIXME!!)
847 static struct cont_elem
*cont_list
= 0;
848 static int cont_limit
= 0;
849 static int cont_count
= 0;
851 /* Arrange for function F to be called with arguments SYM and P later
852 in the stabs reading process. */
854 process_later (sym
, p
, f
)
857 int (*f
) PARAMS ((struct objfile
*, struct symbol
*, char *));
860 /* Allocate more space for the deferred list. */
861 if (cont_count
>= cont_limit
- 1)
863 cont_limit
+= 32; /* chunk size */
866 = (struct cont_elem
*) xrealloc (cont_list
,
868 * sizeof (struct cont_elem
)));
870 error ("Virtual memory exhausted\n");
873 /* Save state variables so we can process these stabs later. */
874 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
875 cont_list
[cont_count
].sym_end
= symbuf_end
;
876 cont_list
[cont_count
].symnum
= symnum
;
877 cont_list
[cont_count
].sym
= sym
;
878 cont_list
[cont_count
].stabs
= p
;
879 cont_list
[cont_count
].func
= f
;
883 /* Call deferred funtions in CONT_LIST. */
886 process_now (objfile
)
887 struct objfile
*objfile
;
896 int (*func
) PARAMS ((struct objfile
*, struct symbol
*, char *));
898 /* Save the state of our caller, we'll want to restore it before
900 save_symbuf_idx
= symbuf_idx
;
901 save_symbuf_end
= symbuf_end
;
902 save_symnum
= symnum
;
904 /* Iterate over all the deferred stabs. */
905 for (i
= 0; i
< cont_count
; i
++)
907 /* Restore the state for this deferred stab. */
908 symbuf_idx
= cont_list
[i
].sym_idx
;
909 symbuf_end
= cont_list
[i
].sym_end
;
910 symnum
= cont_list
[i
].symnum
;
911 sym
= cont_list
[i
].sym
;
912 stabs
= cont_list
[i
].stabs
;
913 func
= cont_list
[i
].func
;
915 /* Call the function to handle this deferrd stab. */
916 err
= (*func
) (objfile
, sym
, stabs
);
918 error ("Internal error: unable to resolve stab.\n");
921 /* Restore our caller's state. */
922 symbuf_idx
= save_symbuf_idx
;
923 symbuf_end
= save_symbuf_end
;
924 symnum
= save_symnum
;
929 /* Name of last function encountered. Used in Solaris to approximate
930 object file boundaries. */
931 static char *last_function_name
;
933 /* The address in memory of the string table of the object file we are
934 reading (which might not be the "main" object file, but might be a
935 shared library or some other dynamically loaded thing). This is
936 set by read_dbx_symtab when building psymtabs, and by
937 read_ofile_symtab when building symtabs, and is used only by
938 next_symbol_text. FIXME: If that is true, we don't need it when
939 building psymtabs, right? */
940 static char *stringtab_global
;
942 /* These variables are used to control fill_symbuf when the stabs
943 symbols are not contiguous (as may be the case when a COFF file is
944 linked using --split-by-reloc). */
945 static struct stab_section_list
*symbuf_sections
;
946 static unsigned int symbuf_left
;
947 static unsigned int symbuf_read
;
949 /* Refill the symbol table input buffer
950 and set the variables that control fetching entries from it.
951 Reports an error if no data available.
952 This function can read past the end of the symbol table
953 (into the string table) but this does no harm. */
956 fill_symbuf (sym_bfd
)
962 if (symbuf_sections
== NULL
)
963 count
= sizeof (symbuf
);
966 if (symbuf_left
<= 0)
968 file_ptr filepos
= symbuf_sections
->section
->filepos
;
969 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
970 perror_with_name (bfd_get_filename (sym_bfd
));
971 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
972 symbol_table_offset
= filepos
- symbuf_read
;
973 symbuf_sections
= symbuf_sections
->next
;
977 if (count
> sizeof (symbuf
))
978 count
= sizeof (symbuf
);
981 nbytes
= bfd_read ((PTR
) symbuf
, count
, 1, sym_bfd
);
983 perror_with_name (bfd_get_filename (sym_bfd
));
984 else if (nbytes
== 0)
985 error ("Premature end of file reading symbol table");
986 symbuf_end
= nbytes
/ symbol_size
;
988 symbuf_left
-= nbytes
;
989 symbuf_read
+= nbytes
;
992 #define SWAP_SYMBOL(symp, abfd) \
994 (symp)->n_strx = bfd_h_get_32(abfd, \
995 (unsigned char *)&(symp)->n_strx); \
996 (symp)->n_desc = bfd_h_get_16 (abfd, \
997 (unsigned char *)&(symp)->n_desc); \
998 (symp)->n_value = bfd_h_get_32 (abfd, \
999 (unsigned char *)&(symp)->n_value); \
1002 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
1004 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
1005 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
1006 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
1007 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
1010 /* Invariant: The symbol pointed to by symbuf_idx is the first one
1011 that hasn't been swapped. Swap the symbol at the same time
1012 that symbuf_idx is incremented. */
1014 /* dbx allows the text of a symbol name to be continued into the
1015 next symbol name! When such a continuation is encountered
1016 (a \ at the end of the text of a name)
1017 call this function to get the continuation. */
1020 dbx_next_symbol_text (objfile
)
1021 struct objfile
*objfile
;
1023 struct internal_nlist nlist
;
1025 if (symbuf_idx
== symbuf_end
)
1026 fill_symbuf (symfile_bfd
);
1029 INTERNALIZE_SYMBOL (nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
1030 OBJSTAT (objfile
, n_stabs
++);
1034 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
1037 /* Initialize the list of bincls to contain none and have some
1041 init_bincl_list (number
, objfile
)
1043 struct objfile
*objfile
;
1045 bincls_allocated
= number
;
1046 next_bincl
= bincl_list
= (struct header_file_location
*)
1047 xmmalloc (objfile
->md
, bincls_allocated
* sizeof (struct header_file_location
));
1050 /* Add a bincl to the list. */
1053 add_bincl_to_list (pst
, name
, instance
)
1054 struct partial_symtab
*pst
;
1058 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1060 int offset
= next_bincl
- bincl_list
;
1061 bincls_allocated
*= 2;
1062 bincl_list
= (struct header_file_location
*)
1063 xmrealloc (pst
->objfile
->md
, (char *) bincl_list
,
1064 bincls_allocated
* sizeof (struct header_file_location
));
1065 next_bincl
= bincl_list
+ offset
;
1067 next_bincl
->pst
= pst
;
1068 next_bincl
->instance
= instance
;
1069 next_bincl
++->name
= name
;
1072 /* Given a name, value pair, find the corresponding
1073 bincl in the list. Return the partial symtab associated
1074 with that header_file_location. */
1076 static struct partial_symtab
*
1077 find_corresponding_bincl_psymtab (name
, instance
)
1081 struct header_file_location
*bincl
;
1083 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1084 if (bincl
->instance
== instance
1085 && STREQ (name
, bincl
->name
))
1088 complain (&repeated_header_complaint
, name
, symnum
);
1089 return (struct partial_symtab
*) 0;
1092 /* Free the storage allocated for the bincl list. */
1095 free_bincl_list (objfile
)
1096 struct objfile
*objfile
;
1098 mfree (objfile
->md
, (PTR
) bincl_list
);
1099 bincls_allocated
= 0;
1102 /* Scan a SunOs dynamic symbol table for symbols of interest and
1103 add them to the minimal symbol table. */
1106 read_dbx_dynamic_symtab (section_offsets
, objfile
)
1107 struct section_offsets
*section_offsets
;
1108 struct objfile
*objfile
;
1110 bfd
*abfd
= objfile
->obfd
;
1111 struct cleanup
*back_to
;
1121 CORE_ADDR sym_value
;
1124 /* Check that the symbol file has dynamic symbols that we know about.
1125 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1126 on a sun4 host (and vice versa) and bfd is not configured
1127 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1128 so we ignore the dynamic symbols in this case. */
1129 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1130 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1131 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1134 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1135 if (dynsym_size
< 0)
1138 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1139 back_to
= make_cleanup (free
, dynsyms
);
1141 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1142 if (dynsym_count
< 0)
1144 do_cleanups (back_to
);
1148 /* Enter dynamic symbols into the minimal symbol table
1149 if this is a stripped executable. */
1150 if (bfd_get_symcount (abfd
) <= 0)
1153 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1155 asymbol
*sym
= *symptr
;
1159 sec
= bfd_get_section (sym
);
1161 /* BFD symbols are section relative. */
1162 sym_value
= sym
->value
+ sec
->vma
;
1164 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1166 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1169 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1171 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1174 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1176 sym_value
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
1182 if (sym
->flags
& BSF_GLOBAL
)
1185 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1190 /* Symbols from shared libraries have a dynamic relocation entry
1191 that points to the associated slot in the procedure linkage table.
1192 We make a mininal symbol table entry with type mst_solib_trampoline
1193 at the address in the procedure linkage table. */
1194 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1195 if (dynrel_size
< 0)
1197 do_cleanups (back_to
);
1201 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1202 make_cleanup (free
, dynrels
);
1204 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1205 if (dynrel_count
< 0)
1207 do_cleanups (back_to
);
1211 for (counter
= 0, relptr
= dynrels
;
1212 counter
< dynrel_count
;
1213 counter
++, relptr
++)
1215 arelent
*rel
= *relptr
;
1217 rel
->address
+ ANOFFSET (section_offsets
, SECT_OFF_DATA
);
1219 switch (bfd_get_arch (abfd
))
1221 case bfd_arch_sparc
:
1222 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1226 /* `16' is the type BFD produces for a jump table relocation. */
1227 if (rel
->howto
->type
!= 16)
1230 /* Adjust address in the jump table to point to
1231 the start of the bsr instruction. */
1238 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1239 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1243 do_cleanups (back_to
);
1246 /* Given pointers to an a.out symbol table in core containing dbx
1247 style data, setup partial_symtab's describing each source file for
1248 which debugging information is available.
1249 SYMFILE_NAME is the name of the file we are reading from
1250 and SECTION_OFFSETS is the set of offsets for the various sections
1251 of the file (a set of zeros if the mainline program). */
1254 read_dbx_symtab (section_offsets
, objfile
, text_addr
, text_size
)
1255 struct section_offsets
*section_offsets
;
1256 struct objfile
*objfile
;
1257 CORE_ADDR text_addr
;
1260 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1261 struct internal_nlist nlist
;
1263 register char *namestring
;
1265 int past_first_source_file
= 0;
1266 CORE_ADDR last_o_file_start
= 0;
1267 CORE_ADDR last_function_start
= 0;
1268 struct cleanup
*back_to
;
1270 int textlow_not_set
;
1272 /* Current partial symtab */
1273 struct partial_symtab
*pst
;
1275 /* List of current psymtab's include files */
1276 char **psymtab_include_list
;
1277 int includes_allocated
;
1280 /* Index within current psymtab dependency list */
1281 struct partial_symtab
**dependency_list
;
1282 int dependencies_used
, dependencies_allocated
;
1284 /* FIXME. We probably want to change stringtab_global rather than add this
1285 while processing every symbol entry. FIXME. */
1286 file_string_table_offset
= 0;
1287 next_file_string_table_offset
= 0;
1289 stringtab_global
= DBX_STRINGTAB (objfile
);
1291 pst
= (struct partial_symtab
*) 0;
1293 includes_allocated
= 30;
1295 psymtab_include_list
= (char **) alloca (includes_allocated
*
1298 dependencies_allocated
= 30;
1299 dependencies_used
= 0;
1301 (struct partial_symtab
**) alloca (dependencies_allocated
*
1302 sizeof (struct partial_symtab
*));
1304 /* Init bincl list */
1305 init_bincl_list (20, objfile
);
1306 back_to
= make_cleanup ((make_cleanup_func
) free_bincl_list
, objfile
);
1308 last_source_file
= NULL
;
1310 lowest_text_address
= (CORE_ADDR
) - 1;
1312 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1313 abfd
= objfile
->obfd
;
1314 symbuf_end
= symbuf_idx
= 0;
1315 next_symbol_text_func
= dbx_next_symbol_text
;
1316 textlow_not_set
= 1;
1317 has_line_numbers
= 0;
1319 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1321 /* Get the symbol for this run and pull out some info */
1322 QUIT
; /* allow this to be interruptable */
1323 if (symbuf_idx
== symbuf_end
)
1325 bufp
= &symbuf
[symbuf_idx
++];
1328 * Special case to speed up readin.
1330 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1332 has_line_numbers
= 1;
1336 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1337 OBJSTAT (objfile
, n_stabs
++);
1339 /* Ok. There is a lot of code duplicated in the rest of this
1340 switch statement (for efficiency reasons). Since I don't
1341 like duplicating code, I will do my penance here, and
1342 describe the code which is duplicated:
1344 *) The assignment to namestring.
1345 *) The call to strchr.
1346 *) The addition of a partial symbol the the two partial
1347 symbol lists. This last is a large section of code, so
1348 I've imbedded it in the following macro.
1351 /* Set namestring based on nlist. If the string table index is invalid,
1352 give a fake name, and print a single error message per symbol file read,
1353 rather than abort the symbol reading or flood the user with messages. */
1355 /*FIXME: Too many adds and indirections in here for the inner loop. */
1356 #define SET_NAMESTRING()\
1357 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1358 DBX_STRINGTAB_SIZE (objfile)) { \
1359 complain (&string_table_offset_complaint, symnum); \
1360 namestring = "<bad string table offset>"; \
1362 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1363 DBX_STRINGTAB (objfile)
1365 #define CUR_SYMBOL_TYPE nlist.n_type
1366 #define CUR_SYMBOL_VALUE nlist.n_value
1367 #define CUR_SYMBOL_STRX nlist.n_strx
1368 #define DBXREAD_ONLY
1369 #define START_PSYMTAB(ofile,secoff,fname,low,symoff,global_syms,static_syms)\
1370 start_psymtab(ofile, secoff, fname, low, symoff, global_syms, static_syms)
1371 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1372 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1374 #include "partial-stab.h"
1377 /* If there's stuff to be cleaned up, clean it up. */
1378 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1379 /*FIXME, does this have a bug at start address 0? */
1380 && last_o_file_start
1381 && objfile
->ei
.entry_point
< nlist
.n_value
1382 && objfile
->ei
.entry_point
>= last_o_file_start
)
1384 objfile
->ei
.entry_file_lowpc
= last_o_file_start
;
1385 objfile
->ei
.entry_file_highpc
= nlist
.n_value
;
1390 /* Don't set pst->texthigh lower than it already is. */
1391 CORE_ADDR text_end
=
1392 (lowest_text_address
== (CORE_ADDR
) - 1
1393 ? (text_addr
+ section_offsets
->offsets
[SECT_OFF_TEXT
])
1394 : lowest_text_address
)
1397 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1398 symnum
* symbol_size
,
1399 text_end
> pst
->texthigh
? text_end
: pst
->texthigh
,
1400 dependency_list
, dependencies_used
, textlow_not_set
);
1403 do_cleanups (back_to
);
1406 /* Allocate and partially fill a partial symtab. It will be
1407 completely filled at the end of the symbol list.
1409 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1410 is the address relative to which its symbols are (incremental) or 0
1414 struct partial_symtab
*
1415 start_psymtab (objfile
, section_offsets
,
1416 filename
, textlow
, ldsymoff
, global_syms
, static_syms
)
1417 struct objfile
*objfile
;
1418 struct section_offsets
*section_offsets
;
1422 struct partial_symbol
**global_syms
;
1423 struct partial_symbol
**static_syms
;
1425 struct partial_symtab
*result
=
1426 start_psymtab_common (objfile
, section_offsets
,
1427 filename
, textlow
, global_syms
, static_syms
);
1429 result
->read_symtab_private
= (char *)
1430 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1431 LDSYMOFF (result
) = ldsymoff
;
1432 result
->read_symtab
= dbx_psymtab_to_symtab
;
1433 SYMBOL_SIZE (result
) = symbol_size
;
1434 SYMBOL_OFFSET (result
) = symbol_table_offset
;
1435 STRING_OFFSET (result
) = string_table_offset
;
1436 FILE_STRING_OFFSET (result
) = file_string_table_offset
;
1438 /* If we're handling an ELF file, drag some section-relocation info
1439 for this source file out of the ELF symbol table, to compensate for
1440 Sun brain death. This replaces the section_offsets in this psymtab,
1442 elfstab_offset_sections (objfile
, result
);
1444 /* Deduce the source language from the filename for this psymtab. */
1445 psymtab_language
= deduce_language_from_filename (filename
);
1450 /* Close off the current usage of PST.
1451 Returns PST or NULL if the partial symtab was empty and thrown away.
1453 FIXME: List variables and peculiarities of same. */
1455 struct partial_symtab
*
1456 end_psymtab (pst
, include_list
, num_includes
, capping_symbol_offset
,
1457 capping_text
, dependency_list
, number_dependencies
, textlow_not_set
)
1458 struct partial_symtab
*pst
;
1459 char **include_list
;
1461 int capping_symbol_offset
;
1462 CORE_ADDR capping_text
;
1463 struct partial_symtab
**dependency_list
;
1464 int number_dependencies
;
1465 int textlow_not_set
;
1468 struct objfile
*objfile
= pst
->objfile
;
1470 if (capping_symbol_offset
!= -1)
1471 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
1472 pst
->texthigh
= capping_text
;
1474 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1475 /* Under Solaris, the N_SO symbols always have a value of 0,
1476 instead of the usual address of the .o file. Therefore,
1477 we have to do some tricks to fill in texthigh and textlow.
1478 The first trick is in partial-stab.h: if we see a static
1479 or global function, and the textlow for the current pst
1480 is not set (ie: textlow_not_set), then we use that function's
1481 address for the textlow of the pst. */
1483 /* Now, to fill in texthigh, we remember the last function seen
1484 in the .o file (also in partial-stab.h). Also, there's a hack in
1485 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1486 to here via the misc_info field. Therefore, we can fill in
1487 a reliable texthigh by taking the address plus size of the
1488 last function in the file. */
1490 if (pst
->texthigh
== 0 && last_function_name
)
1494 struct minimal_symbol
*minsym
;
1496 p
= strchr (last_function_name
, ':');
1498 p
= last_function_name
;
1499 n
= p
- last_function_name
;
1501 strncpy (p
, last_function_name
, n
);
1504 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1507 /* Sun Fortran appends an underscore to the minimal symbol name,
1508 try again with an appended underscore if the minimal symbol
1512 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1516 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1518 last_function_name
= NULL
;
1521 /* this test will be true if the last .o file is only data */
1522 if (textlow_not_set
)
1523 pst
->textlow
= pst
->texthigh
;
1526 struct partial_symtab
*p1
;
1528 /* If we know our own starting text address, then walk through all other
1529 psymtabs for this objfile, and if any didn't know their ending text
1530 address, set it to our starting address. Take care to not set our
1531 own ending address to our starting address, nor to set addresses on
1532 `dependency' files that have both textlow and texthigh zero. */
1534 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1536 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1538 p1
->texthigh
= pst
->textlow
;
1539 /* if this file has only data, then make textlow match texthigh */
1540 if (p1
->textlow
== 0)
1541 p1
->textlow
= p1
->texthigh
;
1546 /* End of kludge for patching Solaris textlow and texthigh. */
1547 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1549 pst
->n_global_syms
=
1550 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1551 pst
->n_static_syms
=
1552 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1554 pst
->number_of_dependencies
= number_dependencies
;
1555 if (number_dependencies
)
1557 pst
->dependencies
= (struct partial_symtab
**)
1558 obstack_alloc (&objfile
->psymbol_obstack
,
1559 number_dependencies
* sizeof (struct partial_symtab
*));
1560 memcpy (pst
->dependencies
, dependency_list
,
1561 number_dependencies
* sizeof (struct partial_symtab
*));
1564 pst
->dependencies
= 0;
1566 for (i
= 0; i
< num_includes
; i
++)
1568 struct partial_symtab
*subpst
=
1569 allocate_psymtab (include_list
[i
], objfile
);
1571 subpst
->section_offsets
= pst
->section_offsets
;
1572 subpst
->read_symtab_private
=
1573 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1574 sizeof (struct symloc
));
1578 subpst
->texthigh
= 0;
1580 /* We could save slight bits of space by only making one of these,
1581 shared by the entire set of include files. FIXME-someday. */
1582 subpst
->dependencies
= (struct partial_symtab
**)
1583 obstack_alloc (&objfile
->psymbol_obstack
,
1584 sizeof (struct partial_symtab
*));
1585 subpst
->dependencies
[0] = pst
;
1586 subpst
->number_of_dependencies
= 1;
1588 subpst
->globals_offset
=
1589 subpst
->n_global_syms
=
1590 subpst
->statics_offset
=
1591 subpst
->n_static_syms
= 0;
1595 subpst
->read_symtab
= pst
->read_symtab
;
1598 sort_pst_symbols (pst
);
1600 /* If there is already a psymtab or symtab for a file of this name, remove it.
1601 (If there is a symtab, more drastic things also happen.)
1602 This happens in VxWorks. */
1603 free_named_symtabs (pst
->filename
);
1605 if (num_includes
== 0
1606 && number_dependencies
== 0
1607 && pst
->n_global_syms
== 0
1608 && pst
->n_static_syms
== 0
1609 && has_line_numbers
== 0)
1611 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1612 it is on the obstack, but we can forget to chain it on the list. */
1613 /* Empty psymtabs happen as a result of header files which don't have
1614 any symbols in them. There can be a lot of them. But this check
1615 is wrong, in that a psymtab with N_SLINE entries but nothing else
1616 is not empty, but we don't realize that. Fixing that without slowing
1617 things down might be tricky. */
1619 discard_psymtab (pst
);
1621 /* Indicate that psymtab was thrown away. */
1622 pst
= (struct partial_symtab
*) NULL
;
1628 dbx_psymtab_to_symtab_1 (pst
)
1629 struct partial_symtab
*pst
;
1631 struct cleanup
*old_chain
;
1639 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1644 /* Read in all partial symtabs on which this one is dependent */
1645 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1646 if (!pst
->dependencies
[i
]->readin
)
1648 /* Inform about additional files that need to be read in. */
1651 fputs_filtered (" ", gdb_stdout
);
1653 fputs_filtered ("and ", gdb_stdout
);
1655 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1656 wrap_here (""); /* Flush output */
1657 gdb_flush (gdb_stdout
);
1659 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1662 if (LDSYMLEN (pst
)) /* Otherwise it's a dummy */
1664 /* Init stuff necessary for reading in symbols */
1667 old_chain
= make_cleanup ((make_cleanup_func
) really_free_pendings
, 0);
1668 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1669 symbol_size
= SYMBOL_SIZE (pst
);
1671 /* Read in this file's symbols */
1672 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1673 read_ofile_symtab (pst
);
1674 sort_symtab_syms (pst
->symtab
);
1676 do_cleanups (old_chain
);
1682 /* Read in all of the symbols for a given psymtab for real.
1683 Be verbose about it if the user wants that. */
1686 dbx_psymtab_to_symtab (pst
)
1687 struct partial_symtab
*pst
;
1696 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1701 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
1703 /* Print the message now, before reading the string table,
1704 to avoid disconcerting pauses. */
1707 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1708 gdb_flush (gdb_stdout
);
1711 sym_bfd
= pst
->objfile
->obfd
;
1713 next_symbol_text_func
= dbx_next_symbol_text
;
1715 dbx_psymtab_to_symtab_1 (pst
);
1717 /* Match with global symbols. This only needs to be done once,
1718 after all of the symtabs and dependencies have been read in. */
1719 scan_file_globals (pst
->objfile
);
1721 /* Finish up the debug error message. */
1723 printf_filtered ("done.\n");
1727 /* Read in a defined section of a specific object file's symbols. */
1730 read_ofile_symtab (pst
)
1731 struct partial_symtab
*pst
;
1733 register char *namestring
;
1734 register struct external_nlist
*bufp
;
1735 struct internal_nlist nlist
;
1737 unsigned max_symnum
;
1739 struct objfile
*objfile
;
1740 int sym_offset
; /* Offset to start of symbols to read */
1741 int sym_size
; /* Size of symbols to read */
1742 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1743 int text_size
; /* Size of text segment for symbols */
1744 struct section_offsets
*section_offsets
;
1746 objfile
= pst
->objfile
;
1747 sym_offset
= LDSYMOFF (pst
);
1748 sym_size
= LDSYMLEN (pst
);
1749 text_offset
= pst
->textlow
;
1750 text_size
= pst
->texthigh
- pst
->textlow
;
1751 section_offsets
= pst
->section_offsets
;
1753 current_objfile
= objfile
;
1754 subfile_stack
= NULL
;
1756 stringtab_global
= DBX_STRINGTAB (objfile
);
1757 last_source_file
= NULL
;
1759 abfd
= objfile
->obfd
;
1760 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1761 symbuf_end
= symbuf_idx
= 0;
1763 /* It is necessary to actually read one symbol *before* the start
1764 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1765 occurs before the N_SO symbol.
1767 Detecting this in read_dbx_symtab
1768 would slow down initial readin, so we look for it here instead. */
1769 if (!processing_acc_compilation
&& sym_offset
>= (int) symbol_size
)
1771 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1773 bufp
= &symbuf
[symbuf_idx
++];
1774 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1775 OBJSTAT (objfile
, n_stabs
++);
1779 processing_gcc_compilation
= 0;
1780 if (nlist
.n_type
== N_TEXT
)
1782 const char *tempstring
= namestring
;
1784 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1785 processing_gcc_compilation
= 1;
1786 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1787 processing_gcc_compilation
= 2;
1788 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1790 if (STREQN (tempstring
, "__gnu_compiled", 14))
1791 processing_gcc_compilation
= 2;
1794 /* Try to select a C++ demangling based on the compilation unit
1797 if (processing_gcc_compilation
)
1799 if (AUTO_DEMANGLING
)
1801 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1807 /* The N_SO starting this symtab is the first symbol, so we
1808 better not check the symbol before it. I'm not this can
1809 happen, but it doesn't hurt to check for it. */
1810 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1811 processing_gcc_compilation
= 0;
1814 if (symbuf_idx
== symbuf_end
)
1816 bufp
= &symbuf
[symbuf_idx
];
1817 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1818 error ("First symbol in segment of executable not a source symbol");
1820 max_symnum
= sym_size
/ symbol_size
;
1823 symnum
< max_symnum
;
1826 QUIT
; /* Allow this to be interruptable */
1827 if (symbuf_idx
== symbuf_end
)
1829 bufp
= &symbuf
[symbuf_idx
++];
1830 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1831 OBJSTAT (objfile
, n_stabs
++);
1833 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1839 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1840 namestring
, section_offsets
, objfile
);
1842 /* We skip checking for a new .o or -l file; that should never
1843 happen in this routine. */
1844 else if (type
== N_TEXT
)
1846 /* I don't think this code will ever be executed, because
1847 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1848 the N_SO symbol which starts this source file.
1849 However, there is no reason not to accept
1850 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1852 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1853 processing_gcc_compilation
= 1;
1854 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1855 processing_gcc_compilation
= 2;
1857 if (AUTO_DEMANGLING
)
1859 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1862 else if (type
& N_EXT
|| type
== (unsigned char) N_TEXT
1863 || type
== (unsigned char) N_NBTEXT
1866 /* Global symbol: see if we came across a dbx defintion for
1867 a corresponding symbol. If so, store the value. Remove
1868 syms from the chain when their values are stored, but
1869 search the whole chain, as there may be several syms from
1870 different files with the same name. */
1871 /* This is probably not true. Since the files will be read
1872 in one at a time, each reference to a global symbol will
1873 be satisfied in each file as it appears. So we skip this
1879 current_objfile
= NULL
;
1881 /* In a Solaris elf file, this variable, which comes from the
1882 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1883 which comes from pst->textlow is correct. */
1884 if (last_source_start_addr
== 0)
1885 last_source_start_addr
= text_offset
;
1887 /* In reordered executables last_source_start_addr may not be the
1888 lower bound for this symtab, instead use text_offset which comes
1889 from pst->textlow which is correct. */
1890 if (last_source_start_addr
> text_offset
)
1891 last_source_start_addr
= text_offset
;
1893 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT
);
1895 /* Process items which we had to "process_later" due to dependancies
1897 process_now (objfile
);
1903 /* This handles a single symbol from the symbol-file, building symbols
1904 into a GDB symtab. It takes these arguments and an implicit argument.
1906 TYPE is the type field of the ".stab" symbol entry.
1907 DESC is the desc field of the ".stab" entry.
1908 VALU is the value field of the ".stab" entry.
1909 NAME is the symbol name, in our address space.
1910 SECTION_OFFSETS is a set of amounts by which the sections of this object
1911 file were relocated when it was loaded into memory.
1912 All symbols that refer
1913 to memory locations need to be offset by these amounts.
1914 OBJFILE is the object file from which we are reading symbols.
1915 It is used in end_symtab. */
1918 process_one_symbol (type
, desc
, valu
, name
, section_offsets
, objfile
)
1922 struct section_offsets
*section_offsets
;
1923 struct objfile
*objfile
;
1925 #ifdef SUN_FIXED_LBRAC_BUG
1926 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1927 to correct the address of N_LBRAC's. If it is not defined, then
1928 we never need to correct the addresses. */
1930 /* This records the last pc address we've seen. We depend on there being
1931 an SLINE or FUN or SO before the first LBRAC, since the variable does
1932 not get reset in between reads of different symbol files. */
1933 static CORE_ADDR last_pc_address
;
1936 register struct context_stack
*new;
1937 /* This remembers the address of the start of a function. It is used
1938 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1939 relative to the current function's start address. On systems
1940 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1941 used to relocate these symbol types rather than SECTION_OFFSETS. */
1942 static CORE_ADDR function_start_offset
;
1944 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1945 file. Used to detect the SunPRO solaris compiler. */
1946 static int n_opt_found
;
1948 /* The stab type used for the definition of the last function.
1949 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1950 static int function_stab_type
= 0;
1952 if (!block_address_function_relative
)
1953 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1954 function start address, so just use the text offset. */
1955 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1957 /* Something is wrong if we see real data before
1958 seeing a source file name. */
1960 if (last_source_file
== NULL
&& type
!= (unsigned char) N_SO
)
1962 /* Ignore any symbols which appear before an N_SO symbol.
1963 Currently no one puts symbols there, but we should deal
1964 gracefully with the case. A complain()t might be in order,
1965 but this should not be an error (). */
1974 if (*name
== '\000')
1976 /* This N_FUN marks the end of a function. This closes off the
1978 within_function
= 0;
1979 new = pop_context ();
1981 /* Make a block for the local symbols within. */
1982 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1983 new->start_addr
, new->start_addr
+ valu
,
1986 /* May be switching to an assembler file which may not be using
1987 block relative stabs, so reset the offset. */
1988 if (block_address_function_relative
)
1989 function_start_offset
= 0;
1994 /* Relocate for dynamic loading */
1995 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
1996 #ifdef SMASH_TEXT_ADDRESS
1997 SMASH_TEXT_ADDRESS (valu
);
1999 goto define_a_symbol
;
2002 /* This "symbol" just indicates the start of an inner lexical
2003 context within a function. */
2005 /* Ignore extra outermost context from SunPRO cc and acc. */
2006 if (n_opt_found
&& desc
== 1)
2009 if (block_address_function_relative
)
2010 /* Relocate for Sun ELF acc fn-relative syms. */
2011 valu
+= function_start_offset
;
2013 /* On most machines, the block addresses are relative to the
2014 N_SO, the linker did not relocate them (sigh). */
2015 valu
+= last_source_start_addr
;
2017 #ifdef SUN_FIXED_LBRAC_BUG
2018 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
)
2020 /* Patch current LBRAC pc value to match last handy pc value */
2021 complain (&lbrac_complaint
);
2022 valu
= last_pc_address
;
2025 new = push_context (desc
, valu
);
2029 /* This "symbol" just indicates the end of an inner lexical
2030 context that was started with N_LBRAC. */
2032 /* Ignore extra outermost context from SunPRO cc and acc. */
2033 if (n_opt_found
&& desc
== 1)
2036 if (block_address_function_relative
)
2037 /* Relocate for Sun ELF acc fn-relative syms. */
2038 valu
+= function_start_offset
;
2040 /* On most machines, the block addresses are relative to the
2041 N_SO, the linker did not relocate them (sigh). */
2042 valu
+= last_source_start_addr
;
2044 new = pop_context ();
2045 if (desc
!= new->depth
)
2046 complain (&lbrac_mismatch_complaint
, symnum
);
2048 /* Some compilers put the variable decls inside of an
2049 LBRAC/RBRAC block. This macro should be nonzero if this
2050 is true. DESC is N_DESC from the N_RBRAC symbol.
2051 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
2052 or the GCC2_COMPILED_SYMBOL. */
2053 #if !defined (VARIABLES_INSIDE_BLOCK)
2054 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2057 /* Can only use new->locals as local symbols here if we're in
2058 gcc or on a machine that puts them before the lbrack. */
2059 if (!VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2060 local_symbols
= new->locals
;
2062 if (context_stack_depth
2063 > !VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2065 /* This is not the outermost LBRAC...RBRAC pair in the function,
2066 its local symbols preceded it, and are the ones just recovered
2067 from the context stack. Define the block for them (but don't
2068 bother if the block contains no symbols. Should we complain
2069 on blocks without symbols? I can't think of any useful purpose
2071 if (local_symbols
!= NULL
)
2073 /* Muzzle a compiler bug that makes end < start. (which
2074 compilers? Is this ever harmful?). */
2075 if (new->start_addr
> valu
)
2077 complain (&lbrac_rbrac_complaint
);
2078 new->start_addr
= valu
;
2080 /* Make a block for the local symbols within. */
2081 finish_block (0, &local_symbols
, new->old_blocks
,
2082 new->start_addr
, valu
, objfile
);
2087 /* This is the outermost LBRAC...RBRAC pair. There is no
2088 need to do anything; leave the symbols that preceded it
2089 to be attached to the function's own block. We need to
2090 indicate that we just moved outside of the function. */
2091 within_function
= 0;
2094 if (VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2095 /* Now pop locals of block just finished. */
2096 local_symbols
= new->locals
;
2101 /* This kind of symbol indicates the start of an object file. */
2102 /* Relocate for dynamic loading */
2103 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2107 /* This type of symbol indicates the start of data
2108 for one source file.
2109 Finish the symbol table of the previous source file
2110 (if any) and start accumulating a new symbol table. */
2111 /* Relocate for dynamic loading */
2112 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2116 #ifdef SUN_FIXED_LBRAC_BUG
2117 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2120 #ifdef PCC_SOL_BROKEN
2121 /* pcc bug, occasionally puts out SO for SOL. */
2122 if (context_stack_depth
> 0)
2124 start_subfile (name
, NULL
);
2128 if (last_source_file
)
2130 /* Check if previous symbol was also an N_SO (with some
2131 sanity checks). If so, that one was actually the directory
2132 name, and the current one is the real file name.
2134 if (previous_stab_code
== (unsigned char) N_SO
)
2136 patch_subfile_names (current_subfile
, name
);
2137 break; /* Ignore repeated SOs */
2139 end_symtab (valu
, objfile
, SECT_OFF_TEXT
);
2143 /* Null name means this just marks the end of text for this .o file.
2144 Don't start a new symtab in this case. */
2145 if (*name
== '\000')
2148 if (block_address_function_relative
)
2149 function_start_offset
= 0;
2152 start_symtab (name
, NULL
, valu
);
2153 record_debugformat ("stabs");
2157 /* This type of symbol indicates the start of data for
2158 a sub-source-file, one whose contents were copied or
2159 included in the compilation of the main source file
2160 (whose name was given in the N_SO symbol.) */
2161 /* Relocate for dynamic loading */
2162 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2163 start_subfile (name
, current_subfile
->dirname
);
2168 add_new_header_file (name
, valu
);
2169 start_subfile (name
, current_subfile
->dirname
);
2173 start_subfile (pop_subfile (), current_subfile
->dirname
);
2177 add_old_header_file (name
, valu
);
2181 /* This type of "symbol" really just records
2182 one line-number -- core-address correspondence.
2183 Enter it in the line list for this symbol table. */
2185 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2186 valu
+= function_start_offset
;
2188 #ifdef SUN_FIXED_LBRAC_BUG
2189 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2191 record_line (current_subfile
, desc
, valu
);
2195 common_block_start (name
, objfile
);
2199 common_block_end (objfile
);
2202 /* The following symbol types need to have the appropriate offset added
2203 to their value; then we process symbol definitions in the name. */
2205 case N_STSYM
: /* Static symbol in data seg */
2206 case N_LCSYM
: /* Static symbol in BSS seg */
2207 case N_ROSYM
: /* Static symbol in Read-only data seg */
2208 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2209 Solaris2's stabs-in-elf makes *most* symbols relative
2210 but leaves a few absolute (at least for Solaris 2.1 and version
2211 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2212 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2213 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2214 This leaves us no choice but to search for the 'S' or 'V'...
2215 (or pass the whole section_offsets stuff down ONE MORE function
2216 call level, which we really don't want to do). */
2220 /* .o files and NLMs have non-zero text seg offsets, but don't need
2221 their static syms offset in this fashion. XXX - This is really a
2222 crock that should be fixed in the solib handling code so that I
2223 don't have to work around it here. */
2225 if (!symfile_relocatable
)
2227 p
= strchr (name
, ':');
2228 if (p
!= 0 && p
[1] == 'S')
2230 /* The linker relocated it. We don't want to add an
2231 elfstab_offset_sections-type offset, but we *do* want
2232 to add whatever solib.c passed to symbol_file_add as
2233 addr (this is known to affect SunOS4, and I suspect ELF
2234 too). Since elfstab_offset_sections currently does not
2235 muck with the text offset (there is no Ttext.text
2236 symbol), we can get addr from the text offset. If
2237 elfstab_offset_sections ever starts dealing with the
2238 text offset, and we still need to do this, we need to
2239 invent a SECT_OFF_ADDR_KLUDGE or something. */
2240 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2241 goto define_a_symbol
;
2244 /* Since it's not the kludge case, re-dispatch to the right handler. */
2258 case_N_STSYM
: /* Static symbol in data seg */
2259 case N_DSLINE
: /* Source line number, data seg */
2260 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA
);
2261 goto define_a_symbol
;
2263 case_N_LCSYM
: /* Static symbol in BSS seg */
2264 case N_BSLINE
: /* Source line number, bss seg */
2265 /* N_BROWS: overlaps with N_BSLINE */
2266 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS
);
2267 goto define_a_symbol
;
2269 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2270 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA
);
2271 goto define_a_symbol
;
2273 case N_ENTRY
: /* Alternate entry point */
2274 /* Relocate for dynamic loading */
2275 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT
);
2276 goto define_a_symbol
;
2278 /* The following symbol types we don't know how to process. Handle
2279 them in a "default" way, but complain to people who care. */
2281 case N_CATCH
: /* Exception handler catcher */
2282 case N_EHDECL
: /* Exception handler name */
2283 case N_PC
: /* Global symbol in Pascal */
2284 case N_M2C
: /* Modula-2 compilation unit */
2285 /* N_MOD2: overlaps with N_EHDECL */
2286 case N_SCOPE
: /* Modula-2 scope information */
2287 case N_ECOML
: /* End common (local name) */
2288 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2293 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2296 /* The following symbol types don't need the address field relocated,
2297 since it is either unused, or is absolute. */
2299 case N_GSYM
: /* Global variable */
2300 case N_NSYMS
: /* Number of symbols (ultrix) */
2301 case N_NOMAP
: /* No map? (ultrix) */
2302 case N_RSYM
: /* Register variable */
2303 case N_DEFD
: /* Modula-2 GNU module dependency */
2304 case N_SSYM
: /* Struct or union element */
2305 case N_LSYM
: /* Local symbol in stack */
2306 case N_PSYM
: /* Parameter variable */
2307 case N_LENG
: /* Length of preceding symbol type */
2311 char *colon_pos
= strchr (name
, ':');
2312 if (colon_pos
== NULL
)
2315 deftype
= colon_pos
[1];
2321 function_stab_type
= type
;
2323 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2324 /* Deal with the SunPRO 3.0 compiler which omits the address
2325 from N_FUN symbols. */
2327 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT
))
2329 struct minimal_symbol
*msym
;
2333 p
= strchr (name
, ':');
2338 strncpy (p
, name
, n
);
2341 msym
= lookup_minimal_symbol (p
, last_source_file
,
2345 /* Sun Fortran appends an underscore to the minimal
2346 symbol name, try again with an appended underscore
2347 if the minimal symbol was not found. */
2350 msym
= lookup_minimal_symbol (p
, last_source_file
,
2354 valu
= SYMBOL_VALUE_ADDRESS (msym
);
2358 #ifdef SUN_FIXED_LBRAC_BUG
2359 /* The Sun acc compiler, under SunOS4, puts out
2360 functions with N_GSYM or N_STSYM. The problem is
2361 that the address of the symbol is no good (for N_GSYM
2362 it doesn't even attept an address; for N_STSYM it
2363 puts out an address but then it gets relocated
2364 relative to the data segment, not the text segment).
2365 Currently we can't fix this up later as we do for
2366 some types of symbol in scan_file_globals.
2367 Fortunately we do have a way of finding the address -
2368 we know that the value in last_pc_address is either
2369 the one we want (if we're dealing with the first
2370 function in an object file), or somewhere in the
2371 previous function. This means that we can use the
2372 minimal symbol table to get the address. */
2374 /* Starting with release 3.0, the Sun acc compiler,
2375 under SunOS4, puts out functions with N_FUN and a value
2376 of zero. This gets relocated to the start of the text
2377 segment of the module, which is no good either.
2378 Under SunOS4 we can deal with this as N_SLINE and N_SO
2379 entries contain valid absolute addresses.
2380 Release 3.0 acc also puts out N_OPT entries, which makes
2381 it possible to discern acc from cc or gcc. */
2383 if (type
== N_GSYM
|| type
== N_STSYM
2385 && n_opt_found
&& !block_address_function_relative
))
2387 struct minimal_symbol
*m
;
2388 int l
= colon_pos
- name
;
2390 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2391 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2392 && SYMBOL_NAME (m
)[l
] == '\0')
2393 /* last_pc_address was in this function */
2394 valu
= SYMBOL_VALUE (m
);
2395 else if (m
&& SYMBOL_NAME (m
+ 1)
2396 && STREQN (SYMBOL_NAME (m
+ 1), name
, l
)
2397 && SYMBOL_NAME (m
+ 1)[l
] == '\0')
2398 /* last_pc_address was in last function */
2399 valu
= SYMBOL_VALUE (m
+ 1);
2401 /* Not found - use last_pc_address (for finish_block) */
2402 valu
= last_pc_address
;
2405 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2408 if (block_address_function_relative
)
2409 /* For Solaris 2.0 compilers, the block addresses and
2410 N_SLINE's are relative to the start of the
2411 function. On normal systems, and when using gcc on
2412 Solaris 2.0, these addresses are just absolute, or
2413 relative to the N_SO, depending on
2414 BLOCK_ADDRESS_ABSOLUTE. */
2415 function_start_offset
= valu
;
2417 within_function
= 1;
2418 if (context_stack_depth
> 0)
2420 new = pop_context ();
2421 /* Make a block for the local symbols within. */
2422 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2423 new->start_addr
, valu
, objfile
);
2425 /* Stack must be empty now. */
2426 if (context_stack_depth
!= 0)
2427 complain (&lbrac_unmatched_complaint
, symnum
);
2429 new = push_context (0, valu
);
2430 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2434 define_symbol (valu
, name
, desc
, type
, objfile
);
2440 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2441 for a bunch of other flags, too. Someday we may parse their
2442 flags; for now we ignore theirs and hope they'll ignore ours. */
2443 case N_OPT
: /* Solaris 2: Compiler options */
2446 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2448 processing_gcc_compilation
= 2;
2449 #if 1 /* Works, but is experimental. -fnf */
2450 if (AUTO_DEMANGLING
)
2452 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2461 /* The following symbol types can be ignored. */
2462 case N_OBJ
: /* Solaris 2: Object file dir and name */
2463 /* N_UNDF: Solaris 2: file separator mark */
2464 /* N_UNDF: -- we will never encounter it, since we only process one
2465 file's symbols at once. */
2466 case N_ENDM
: /* Solaris 2: End of module */
2467 case N_MAIN
: /* Name of main routine. */
2468 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2472 /* '#' is a GNU C extension to allow one symbol to refer to another
2475 Generally this is used so that an alias can refer to its main
2479 /* Initialize symbol reference names and determine if this is
2480 a definition. If symbol reference is being defined, go
2481 ahead and add it. Otherwise, just return sym. */
2486 /* If this stab defines a new reference ID that is not on the
2487 reference list, then put it on the reference list.
2489 We go ahead and advance NAME past the reference, even though
2490 it is not strictly necessary at this time. */
2491 refnum
= symbol_reference_defined (&s
);
2493 if (!ref_search (refnum
))
2494 ref_add (refnum
, 0, name
, valu
);
2499 previous_stab_code
= type
;
2502 /* FIXME: The only difference between this and elfstab_build_psymtabs
2503 is the call to install_minimal_symbols for elf, and the support for
2504 split sections. If the differences are really that small, the code
2505 should be shared. */
2507 /* Scan and build partial symbols for an coff symbol file.
2508 The coff file has already been processed to get its minimal symbols.
2510 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2513 OBJFILE is the object file we are reading symbols from.
2514 ADDR is the address relative to which the symbols are (e.g.
2515 the base address of the text segment).
2516 MAINLINE is true if we are reading the main symbol
2517 table (as opposed to a shared lib or dynamically loaded file).
2518 TEXTADDR is the address of the text section.
2519 TEXTSIZE is the size of the text section.
2520 STABSECTS is the list of .stab sections in OBJFILE.
2521 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2522 .stabstr section exists.
2524 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2525 adjusted for coff details. */
2528 coffstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2529 textaddr
, textsize
, stabsects
,
2530 stabstroffset
, stabstrsize
)
2531 struct objfile
*objfile
;
2532 struct section_offsets
*section_offsets
;
2535 unsigned int textsize
;
2536 struct stab_section_list
*stabsects
;
2537 file_ptr stabstroffset
;
2538 unsigned int stabstrsize
;
2541 bfd
*sym_bfd
= objfile
->obfd
;
2542 char *name
= bfd_get_filename (sym_bfd
);
2543 struct dbx_symfile_info
*info
;
2544 unsigned int stabsize
;
2546 /* There is already a dbx_symfile_info allocated by our caller.
2547 It might even contain some info from the coff symtab to help us. */
2548 info
= objfile
->sym_stab_info
;
2550 DBX_TEXT_ADDR (objfile
) = textaddr
;
2551 DBX_TEXT_SIZE (objfile
) = textsize
;
2553 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2554 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2555 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2557 if (stabstrsize
> bfd_get_size (sym_bfd
))
2558 error ("ridiculous string table size: %d bytes", stabstrsize
);
2559 DBX_STRINGTAB (objfile
) = (char *)
2560 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2561 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2563 /* Now read in the string table in one big gulp. */
2565 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2567 perror_with_name (name
);
2568 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2569 if (val
!= stabstrsize
)
2570 perror_with_name (name
);
2572 stabsread_new_init ();
2573 buildsym_new_init ();
2574 free_header_files ();
2575 init_header_files ();
2577 processing_acc_compilation
= 1;
2579 /* In a coff file, we've already installed the minimal symbols that came
2580 from the coff (non-stab) symbol table, so always act like an
2581 incremental load here. */
2582 if (stabsects
->next
== NULL
)
2584 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2585 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2586 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2590 struct stab_section_list
*stabsect
;
2592 DBX_SYMCOUNT (objfile
) = 0;
2593 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2595 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2596 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2599 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2601 symbuf_sections
= stabsects
->next
;
2602 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2606 dbx_symfile_read (objfile
, section_offsets
, 0);
2609 /* Scan and build partial symbols for an ELF symbol file.
2610 This ELF file has already been processed to get its minimal symbols,
2611 and any DWARF symbols that were in it.
2613 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2616 OBJFILE is the object file we are reading symbols from.
2617 ADDR is the address relative to which the symbols are (e.g.
2618 the base address of the text segment).
2619 MAINLINE is true if we are reading the main symbol
2620 table (as opposed to a shared lib or dynamically loaded file).
2621 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2623 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2624 .stabstr section exists.
2626 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2627 adjusted for elf details. */
2630 elfstab_build_psymtabs (objfile
, section_offsets
, mainline
,
2631 staboffset
, stabsize
,
2632 stabstroffset
, stabstrsize
)
2633 struct objfile
*objfile
;
2634 struct section_offsets
*section_offsets
;
2636 file_ptr staboffset
;
2637 unsigned int stabsize
;
2638 file_ptr stabstroffset
;
2639 unsigned int stabstrsize
;
2642 bfd
*sym_bfd
= objfile
->obfd
;
2643 char *name
= bfd_get_filename (sym_bfd
);
2644 struct dbx_symfile_info
*info
;
2645 asection
*text_sect
;
2647 /* There is already a dbx_symfile_info allocated by our caller.
2648 It might even contain some info from the ELF symtab to help us. */
2649 info
= objfile
->sym_stab_info
;
2651 /* Find the first and last text address. dbx_symfile_read seems to
2653 find_text_range (sym_bfd
, objfile
);
2655 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2656 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2657 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2658 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2659 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2661 if (stabstrsize
> bfd_get_size (sym_bfd
))
2662 error ("ridiculous string table size: %d bytes", stabstrsize
);
2663 DBX_STRINGTAB (objfile
) = (char *)
2664 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2665 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2667 /* Now read in the string table in one big gulp. */
2669 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2671 perror_with_name (name
);
2672 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2673 if (val
!= stabstrsize
)
2674 perror_with_name (name
);
2676 stabsread_new_init ();
2677 buildsym_new_init ();
2678 free_header_files ();
2679 init_header_files ();
2680 install_minimal_symbols (objfile
);
2682 processing_acc_compilation
= 1;
2684 /* In an elf file, we've already installed the minimal symbols that came
2685 from the elf (non-stab) symbol table, so always act like an
2686 incremental load here. */
2687 dbx_symfile_read (objfile
, section_offsets
, 0);
2690 /* Scan and build partial symbols for a file with special sections for stabs
2691 and stabstrings. The file has already been processed to get its minimal
2692 symbols, and any other symbols that might be necessary to resolve GSYMs.
2694 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2697 OBJFILE is the object file we are reading symbols from.
2698 ADDR is the address relative to which the symbols are (e.g. the base address
2699 of the text segment).
2700 MAINLINE is true if we are reading the main symbol table (as opposed to a
2701 shared lib or dynamically loaded file).
2702 STAB_NAME is the name of the section that contains the stabs.
2703 STABSTR_NAME is the name of the section that contains the stab strings.
2705 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2708 stabsect_build_psymtabs (objfile
, section_offsets
, mainline
, stab_name
,
2709 stabstr_name
, text_name
)
2710 struct objfile
*objfile
;
2711 struct section_offsets
*section_offsets
;
2718 bfd
*sym_bfd
= objfile
->obfd
;
2719 char *name
= bfd_get_filename (sym_bfd
);
2721 asection
*stabstrsect
;
2722 asection
*text_sect
;
2724 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2725 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2731 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2732 stab_name
, stabstr_name
);
2734 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
2735 xmalloc (sizeof (struct dbx_symfile_info
));
2736 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2738 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2740 error ("Can't find %s section in symbol file", text_name
);
2741 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2742 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2744 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2745 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2746 / DBX_SYMBOL_SIZE (objfile
);
2747 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2748 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2750 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2751 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2752 DBX_STRINGTAB (objfile
) = (char *)
2753 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2754 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2756 /* Now read in the string table in one big gulp. */
2758 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2759 stabstrsect
, /* bfd section */
2760 DBX_STRINGTAB (objfile
), /* input buffer */
2761 0, /* offset into section */
2762 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2765 perror_with_name (name
);
2767 stabsread_new_init ();
2768 buildsym_new_init ();
2769 free_header_files ();
2770 init_header_files ();
2771 install_minimal_symbols (objfile
);
2773 /* Now, do an incremental load */
2775 processing_acc_compilation
= 1;
2776 dbx_symfile_read (objfile
, section_offsets
, 0);
2779 static struct sym_fns aout_sym_fns
=
2781 bfd_target_aout_flavour
,
2782 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2783 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2784 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2785 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2786 default_symfile_offsets
,
2787 /* sym_offsets: parse user's offsets to internal form */
2788 NULL
/* next: pointer to next struct sym_fns */
2792 _initialize_dbxread ()
2794 add_symtab_fns (&aout_sym_fns
);