1 /* Read dbx symbol tables and convert to internal format, for GDB.
2 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
3 1996, 1997, 1998, 1999, 2000, 2001
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This module provides three functions: dbx_symfile_init,
24 which initializes to read a symbol file; dbx_new_init, which
25 discards existing cached information when all symbols are being
26 discarded; and dbx_symfile_read, which reads a symbol table
29 dbx_symfile_read only does the minimum work necessary for letting the
30 user "name" things symbolically; it does not read the entire symtab.
31 Instead, it reads the external and static symbols and puts them in partial
32 symbol tables. When more extensive information is requested of a
33 file, the corresponding partial symbol table is mutated into a full
34 fledged symbol table by going back and reading the symbols
35 for real. dbx_psymtab_to_symtab() is the function that does this */
38 #include "gdb_string.h"
40 #if defined(USG) || defined(__CYGNUSCLIB__)
41 #include <sys/types.h>
48 #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"
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
)
219 for (sec
= sym_bfd
->sections
; sec
; sec
= sec
->next
)
220 if (bfd_get_section_flags (sym_bfd
, sec
) & SEC_CODE
)
222 CORE_ADDR sec_start
= bfd_section_vma (sym_bfd
, sec
);
223 CORE_ADDR sec_end
= sec_start
+ bfd_section_size (sym_bfd
, sec
);
227 if (sec_start
< start
)
242 error ("Can't find any code sections in symbol file");
244 DBX_TEXT_ADDR (objfile
) = start
;
245 DBX_TEXT_SIZE (objfile
) = end
- start
;
250 /* During initial symbol readin, we need to have a structure to keep
251 track of which psymtabs have which bincls in them. This structure
252 is used during readin to setup the list of dependencies within each
253 partial symbol table. */
255 struct header_file_location
257 char *name
; /* Name of header file */
258 int instance
; /* See above */
259 struct partial_symtab
*pst
; /* Partial symtab that has the
260 BINCL/EINCL defs for this file */
263 /* The actual list and controling variables */
264 static struct header_file_location
*bincl_list
, *next_bincl
;
265 static int bincls_allocated
;
267 /* Local function prototypes */
269 extern void _initialize_dbxread (void);
271 static void process_now (struct objfile
*);
273 static void free_header_files (void);
275 static void init_header_files (void);
277 static void read_ofile_symtab (struct partial_symtab
*);
279 static void dbx_psymtab_to_symtab (struct partial_symtab
*);
281 static void dbx_psymtab_to_symtab_1 (struct partial_symtab
*);
283 static void read_dbx_dynamic_symtab (struct objfile
*objfile
);
285 static void read_dbx_symtab (struct objfile
*);
287 static void free_bincl_list (struct objfile
*);
289 static struct partial_symtab
*find_corresponding_bincl_psymtab (char *, int);
291 static void add_bincl_to_list (struct partial_symtab
*, char *, int);
293 static void init_bincl_list (int, struct objfile
*);
295 static char *dbx_next_symbol_text (struct objfile
*);
297 static void fill_symbuf (bfd
*);
299 static void dbx_symfile_init (struct objfile
*);
301 static void dbx_new_init (struct objfile
*);
303 static void dbx_symfile_read (struct objfile
*, int);
305 static void dbx_symfile_finish (struct objfile
*);
307 static void record_minimal_symbol (char *, CORE_ADDR
, int, struct objfile
*);
309 static void add_new_header_file (char *, int);
311 static void add_old_header_file (char *, int);
313 static void add_this_object_header_file (int);
315 static struct partial_symtab
*start_psymtab (struct objfile
*, char *,
317 struct partial_symbol
**,
318 struct partial_symbol
**);
320 /* Free up old header file tables */
323 free_header_files (void)
325 if (this_object_header_files
)
327 xfree (this_object_header_files
);
328 this_object_header_files
= NULL
;
330 n_allocated_this_object_header_files
= 0;
333 /* Allocate new header file tables */
336 init_header_files (void)
338 n_allocated_this_object_header_files
= 10;
339 this_object_header_files
= (int *) xmalloc (10 * sizeof (int));
342 /* Add header file number I for this object file
343 at the next successive FILENUM. */
346 add_this_object_header_file (int i
)
348 if (n_this_object_header_files
== n_allocated_this_object_header_files
)
350 n_allocated_this_object_header_files
*= 2;
351 this_object_header_files
352 = (int *) xrealloc ((char *) this_object_header_files
,
353 n_allocated_this_object_header_files
* sizeof (int));
356 this_object_header_files
[n_this_object_header_files
++] = i
;
359 /* Add to this file an "old" header file, one already seen in
360 a previous object file. NAME is the header file's name.
361 INSTANCE is its instance code, to select among multiple
362 symbol tables for the same header file. */
365 add_old_header_file (char *name
, int instance
)
367 register struct header_file
*p
= HEADER_FILES (current_objfile
);
370 for (i
= 0; i
< N_HEADER_FILES (current_objfile
); i
++)
371 if (STREQ (p
[i
].name
, name
) && instance
== p
[i
].instance
)
373 add_this_object_header_file (i
);
376 complain (&repeated_header_complaint
, name
, symnum
);
379 /* Add to this file a "new" header file: definitions for its types follow.
380 NAME is the header file's name.
381 Most often this happens only once for each distinct header file,
382 but not necessarily. If it happens more than once, INSTANCE has
383 a different value each time, and references to the header file
384 use INSTANCE values to select among them.
386 dbx output contains "begin" and "end" markers for each new header file,
387 but at this level we just need to know which files there have been;
388 so we record the file when its "begin" is seen and ignore the "end". */
391 add_new_header_file (char *name
, int instance
)
394 register struct header_file
*hfile
;
396 /* Make sure there is room for one more header file. */
398 i
= N_ALLOCATED_HEADER_FILES (current_objfile
);
400 if (N_HEADER_FILES (current_objfile
) == i
)
404 N_ALLOCATED_HEADER_FILES (current_objfile
) = 10;
405 HEADER_FILES (current_objfile
) = (struct header_file
*)
406 xmalloc (10 * sizeof (struct header_file
));
411 N_ALLOCATED_HEADER_FILES (current_objfile
) = i
;
412 HEADER_FILES (current_objfile
) = (struct header_file
*)
413 xrealloc ((char *) HEADER_FILES (current_objfile
),
414 (i
* sizeof (struct header_file
)));
418 /* Create an entry for this header file. */
420 i
= N_HEADER_FILES (current_objfile
)++;
421 hfile
= HEADER_FILES (current_objfile
) + i
;
422 hfile
->name
= savestring (name
, strlen (name
));
423 hfile
->instance
= instance
;
426 = (struct type
**) xmalloc (10 * sizeof (struct type
*));
427 memset (hfile
->vector
, 0, 10 * sizeof (struct type
*));
429 add_this_object_header_file (i
);
433 static struct type
**
434 explicit_lookup_type (int real_filenum
, int index
)
436 register struct header_file
*f
= &HEADER_FILES (current_objfile
)[real_filenum
];
438 if (index
>= f
->length
)
441 f
->vector
= (struct type
**)
442 xrealloc (f
->vector
, f
->length
* sizeof (struct type
*));
443 memset (&f
->vector
[f
->length
/ 2],
444 '\0', f
->length
* sizeof (struct type
*) / 2);
446 return &f
->vector
[index
];
451 record_minimal_symbol (char *name
, CORE_ADDR address
, int type
,
452 struct objfile
*objfile
)
454 enum minimal_symbol_type ms_type
;
456 asection
*bfd_section
;
462 section
= SECT_OFF_TEXT (objfile
);
463 bfd_section
= DBX_TEXT_SECTION (objfile
);
467 section
= SECT_OFF_DATA (objfile
);
468 bfd_section
= DBX_DATA_SECTION (objfile
);
472 section
= SECT_OFF_BSS (objfile
);
473 bfd_section
= DBX_BSS_SECTION (objfile
);
483 section
= SECT_OFF_DATA (objfile
);
484 bfd_section
= DBX_DATA_SECTION (objfile
);
487 /* I don't think this type actually exists; since a N_SETV is the result
488 of going over many .o files, it doesn't make sense to have one
490 ms_type
= mst_file_data
;
491 section
= SECT_OFF_DATA (objfile
);
492 bfd_section
= DBX_DATA_SECTION (objfile
);
499 ms_type
= mst_file_text
;
500 section
= SECT_OFF_TEXT (objfile
);
501 bfd_section
= DBX_TEXT_SECTION (objfile
);
504 ms_type
= mst_file_data
;
506 /* Check for __DYNAMIC, which is used by Sun shared libraries.
507 Record it as global even if it's local, not global, so
508 lookup_minimal_symbol can find it. We don't check symbol_leading_char
509 because for SunOS4 it always is '_'. */
510 if (name
[8] == 'C' && STREQ ("__DYNAMIC", name
))
513 /* Same with virtual function tables, both global and static. */
515 char *tempstring
= name
;
516 if (tempstring
[0] == bfd_get_symbol_leading_char (objfile
->obfd
))
518 if (is_vtable_name (tempstring
))
521 section
= SECT_OFF_DATA (objfile
);
522 bfd_section
= DBX_DATA_SECTION (objfile
);
525 ms_type
= mst_file_bss
;
526 section
= SECT_OFF_BSS (objfile
);
527 bfd_section
= DBX_BSS_SECTION (objfile
);
530 ms_type
= mst_unknown
;
536 if ((ms_type
== mst_file_text
|| ms_type
== mst_text
)
537 && address
< lowest_text_address
)
538 lowest_text_address
= address
;
540 prim_record_minimal_symbol_and_info
541 (name
, address
, ms_type
, NULL
, section
, bfd_section
, objfile
);
544 /* Scan and build partial symbols for a symbol file.
545 We have been initialized by a call to dbx_symfile_init, which
546 put all the relevant info into a "struct dbx_symfile_info",
547 hung off the objfile structure.
549 MAINLINE is true if we are reading the main symbol
550 table (as opposed to a shared lib or dynamically loaded file). */
553 dbx_symfile_read (struct objfile
*objfile
, int mainline
)
557 struct cleanup
*back_to
;
559 sym_bfd
= objfile
->obfd
;
561 /* .o and .nlm files are relocatables with text, data and bss segs based at
562 0. This flag disables special (Solaris stabs-in-elf only) fixups for
563 symbols with a value of 0. */
565 symfile_relocatable
= bfd_get_file_flags (sym_bfd
) & HAS_RELOC
;
567 /* This is true for Solaris (and all other systems which put stabs
568 in sections, hopefully, since it would be silly to do things
569 differently from Solaris), and false for SunOS4 and other a.out
571 block_address_function_relative
=
572 ((0 == strncmp (bfd_get_target (sym_bfd
), "elf", 3))
573 || (0 == strncmp (bfd_get_target (sym_bfd
), "som", 3))
574 || (0 == strncmp (bfd_get_target (sym_bfd
), "coff", 4))
575 || (0 == strncmp (bfd_get_target (sym_bfd
), "pe", 2))
576 || (0 == strncmp (bfd_get_target (sym_bfd
), "epoc-pe", 7))
577 || (0 == strncmp (bfd_get_target (sym_bfd
), "nlm", 3)));
579 val
= bfd_seek (sym_bfd
, DBX_SYMTAB_OFFSET (objfile
), SEEK_SET
);
581 perror_with_name (objfile
->name
);
583 /* If we are reinitializing, or if we have never loaded syms yet, init */
585 || objfile
->global_psymbols
.size
== 0
586 || objfile
->static_psymbols
.size
== 0)
587 init_psymbol_list (objfile
, DBX_SYMCOUNT (objfile
));
589 symbol_size
= DBX_SYMBOL_SIZE (objfile
);
590 symbol_table_offset
= DBX_SYMTAB_OFFSET (objfile
);
592 free_pending_blocks ();
593 back_to
= make_cleanup (really_free_pendings
, 0);
595 init_minimal_symbol_collection ();
596 make_cleanup_discard_minimal_symbols ();
598 /* Read stabs data from executable file and define symbols. */
600 read_dbx_symtab (objfile
);
602 /* Add the dynamic symbols. */
604 read_dbx_dynamic_symtab (objfile
);
606 /* Install any minimal symbols that have been collected as the current
607 minimal symbols for this objfile. */
609 install_minimal_symbols (objfile
);
611 do_cleanups (back_to
);
614 /* Initialize anything that needs initializing when a completely new
615 symbol file is specified (not just adding some symbols from another
616 file, e.g. a shared library). */
619 dbx_new_init (struct objfile
*ignore
)
621 stabsread_new_init ();
622 buildsym_new_init ();
623 init_header_files ();
627 /* dbx_symfile_init ()
628 is the dbx-specific initialization routine for reading symbols.
629 It is passed a struct objfile which contains, among other things,
630 the BFD for the file whose symbols are being read, and a slot for a pointer
631 to "private data" which we fill with goodies.
633 We read the string table into malloc'd space and stash a pointer to it.
635 Since BFD doesn't know how to read debug symbols in a format-independent
636 way (and may never do so...), we have to do it ourselves. We will never
637 be called unless this is an a.out (or very similar) file.
638 FIXME, there should be a cleaner peephole into the BFD environment here. */
640 #define DBX_STRINGTAB_SIZE_SIZE sizeof(long) /* FIXME */
643 dbx_symfile_init (struct objfile
*objfile
)
646 bfd
*sym_bfd
= objfile
->obfd
;
647 char *name
= bfd_get_filename (sym_bfd
);
649 unsigned char size_temp
[DBX_STRINGTAB_SIZE_SIZE
];
651 /* Allocate struct to keep track of the symfile */
652 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
653 xmmalloc (objfile
->md
, sizeof (struct dbx_symfile_info
));
654 memset ((PTR
) objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
656 DBX_TEXT_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".text");
657 DBX_DATA_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".data");
658 DBX_BSS_SECTION (objfile
) = bfd_get_section_by_name (sym_bfd
, ".bss");
660 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
661 #define STRING_TABLE_OFFSET (sym_bfd->origin + obj_str_filepos (sym_bfd))
662 #define SYMBOL_TABLE_OFFSET (sym_bfd->origin + obj_sym_filepos (sym_bfd))
664 /* FIXME POKING INSIDE BFD DATA STRUCTURES */
666 DBX_SYMFILE_INFO (objfile
)->stab_section_info
= NULL
;
668 text_sect
= bfd_get_section_by_name (sym_bfd
, ".text");
670 error ("Can't find .text section in symbol file");
671 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
672 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
674 DBX_SYMBOL_SIZE (objfile
) = obj_symbol_entry_size (sym_bfd
);
675 DBX_SYMCOUNT (objfile
) = bfd_get_symcount (sym_bfd
);
676 DBX_SYMTAB_OFFSET (objfile
) = SYMBOL_TABLE_OFFSET
;
678 /* Read the string table and stash it away in the psymbol_obstack. It is
679 only needed as long as we need to expand psymbols into full symbols,
680 so when we blow away the psymbol the string table goes away as well.
681 Note that gdb used to use the results of attempting to malloc the
682 string table, based on the size it read, as a form of sanity check
683 for botched byte swapping, on the theory that a byte swapped string
684 table size would be so totally bogus that the malloc would fail. Now
685 that we put in on the psymbol_obstack, we can't do this since gdb gets
686 a fatal error (out of virtual memory) if the size is bogus. We can
687 however at least check to see if the size is less than the size of
688 the size field itself, or larger than the size of the entire file.
689 Note that all valid string tables have a size greater than zero, since
690 the bytes used to hold the size are included in the count. */
692 if (STRING_TABLE_OFFSET
== 0)
694 /* It appears that with the existing bfd code, STRING_TABLE_OFFSET
695 will never be zero, even when there is no string table. This
696 would appear to be a bug in bfd. */
697 DBX_STRINGTAB_SIZE (objfile
) = 0;
698 DBX_STRINGTAB (objfile
) = NULL
;
702 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
704 perror_with_name (name
);
706 memset ((PTR
) size_temp
, 0, sizeof (size_temp
));
707 val
= bfd_read ((PTR
) size_temp
, sizeof (size_temp
), 1, sym_bfd
);
710 perror_with_name (name
);
714 /* With the existing bfd code, STRING_TABLE_OFFSET will be set to
715 EOF if there is no string table, and attempting to read the size
716 from EOF will read zero bytes. */
717 DBX_STRINGTAB_SIZE (objfile
) = 0;
718 DBX_STRINGTAB (objfile
) = NULL
;
722 /* Read some data that would appear to be the string table size.
723 If there really is a string table, then it is probably the right
724 size. Byteswap if necessary and validate the size. Note that
725 the minimum is DBX_STRINGTAB_SIZE_SIZE. If we just read some
726 random data that happened to be at STRING_TABLE_OFFSET, because
727 bfd can't tell us there is no string table, the sanity checks may
728 or may not catch this. */
729 DBX_STRINGTAB_SIZE (objfile
) = bfd_h_get_32 (sym_bfd
, size_temp
);
731 if (DBX_STRINGTAB_SIZE (objfile
) < sizeof (size_temp
)
732 || DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
733 error ("ridiculous string table size (%d bytes).",
734 DBX_STRINGTAB_SIZE (objfile
));
736 DBX_STRINGTAB (objfile
) =
737 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
738 DBX_STRINGTAB_SIZE (objfile
));
739 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
));
741 /* Now read in the string table in one big gulp. */
743 val
= bfd_seek (sym_bfd
, STRING_TABLE_OFFSET
, SEEK_SET
);
745 perror_with_name (name
);
746 val
= bfd_read (DBX_STRINGTAB (objfile
), DBX_STRINGTAB_SIZE (objfile
), 1,
748 if (val
!= DBX_STRINGTAB_SIZE (objfile
))
749 perror_with_name (name
);
754 /* Perform any local cleanups required when we are done with a particular
755 objfile. I.E, we are in the process of discarding all symbol information
756 for an objfile, freeing up all memory held for it, and unlinking the
757 objfile struct from the global list of known objfiles. */
760 dbx_symfile_finish (struct objfile
*objfile
)
762 if (objfile
->sym_stab_info
!= NULL
)
764 if (HEADER_FILES (objfile
) != NULL
)
766 register int i
= N_HEADER_FILES (objfile
);
767 register struct header_file
*hfiles
= HEADER_FILES (objfile
);
771 xfree (hfiles
[i
].name
);
772 xfree (hfiles
[i
].vector
);
776 mfree (objfile
->md
, objfile
->sym_stab_info
);
778 free_header_files ();
782 /* Buffer for reading the symbol table entries. */
783 static struct external_nlist symbuf
[4096];
784 static int symbuf_idx
;
785 static int symbuf_end
;
787 /* cont_elem is used for continuing information in cfront.
788 It saves information about which types need to be fixed up and
789 completed after all the stabs are read. */
792 /* sym and stabstring for continuing information in cfront */
795 /* state dependencies (statics that must be preserved) */
799 int (*func
) (struct objfile
*, struct symbol
*, char *);
800 /* other state dependencies include:
801 (assumption is that these will not change since process_now FIXME!!)
808 static struct cont_elem
*cont_list
= 0;
809 static int cont_limit
= 0;
810 static int cont_count
= 0;
812 /* Arrange for function F to be called with arguments SYM and P later
813 in the stabs reading process. */
815 process_later (struct symbol
*sym
, char *p
,
816 int (*f
) (struct objfile
*, struct symbol
*, char *))
819 /* Allocate more space for the deferred list. */
820 if (cont_count
>= cont_limit
- 1)
822 cont_limit
+= 32; /* chunk size */
825 = (struct cont_elem
*) xrealloc (cont_list
,
827 * sizeof (struct cont_elem
)));
829 error ("Virtual memory exhausted\n");
832 /* Save state variables so we can process these stabs later. */
833 cont_list
[cont_count
].sym_idx
= symbuf_idx
;
834 cont_list
[cont_count
].sym_end
= symbuf_end
;
835 cont_list
[cont_count
].symnum
= symnum
;
836 cont_list
[cont_count
].sym
= sym
;
837 cont_list
[cont_count
].stabs
= p
;
838 cont_list
[cont_count
].func
= f
;
842 /* Call deferred funtions in CONT_LIST. */
845 process_now (struct objfile
*objfile
)
854 int (*func
) (struct objfile
*, struct symbol
*, char *);
856 /* Save the state of our caller, we'll want to restore it before
858 save_symbuf_idx
= symbuf_idx
;
859 save_symbuf_end
= symbuf_end
;
860 save_symnum
= symnum
;
862 /* Iterate over all the deferred stabs. */
863 for (i
= 0; i
< cont_count
; i
++)
865 /* Restore the state for this deferred stab. */
866 symbuf_idx
= cont_list
[i
].sym_idx
;
867 symbuf_end
= cont_list
[i
].sym_end
;
868 symnum
= cont_list
[i
].symnum
;
869 sym
= cont_list
[i
].sym
;
870 stabs
= cont_list
[i
].stabs
;
871 func
= cont_list
[i
].func
;
873 /* Call the function to handle this deferrd stab. */
874 err
= (*func
) (objfile
, sym
, stabs
);
876 error ("Internal error: unable to resolve stab.\n");
879 /* Restore our caller's state. */
880 symbuf_idx
= save_symbuf_idx
;
881 symbuf_end
= save_symbuf_end
;
882 symnum
= save_symnum
;
887 /* Name of last function encountered. Used in Solaris to approximate
888 object file boundaries. */
889 static char *last_function_name
;
891 /* The address in memory of the string table of the object file we are
892 reading (which might not be the "main" object file, but might be a
893 shared library or some other dynamically loaded thing). This is
894 set by read_dbx_symtab when building psymtabs, and by
895 read_ofile_symtab when building symtabs, and is used only by
896 next_symbol_text. FIXME: If that is true, we don't need it when
897 building psymtabs, right? */
898 static char *stringtab_global
;
900 /* These variables are used to control fill_symbuf when the stabs
901 symbols are not contiguous (as may be the case when a COFF file is
902 linked using --split-by-reloc). */
903 static struct stab_section_list
*symbuf_sections
;
904 static unsigned int symbuf_left
;
905 static unsigned int symbuf_read
;
907 /* Refill the symbol table input buffer
908 and set the variables that control fetching entries from it.
909 Reports an error if no data available.
910 This function can read past the end of the symbol table
911 (into the string table) but this does no harm. */
914 fill_symbuf (bfd
*sym_bfd
)
919 if (symbuf_sections
== NULL
)
920 count
= sizeof (symbuf
);
923 if (symbuf_left
<= 0)
925 file_ptr filepos
= symbuf_sections
->section
->filepos
;
926 if (bfd_seek (sym_bfd
, filepos
, SEEK_SET
) != 0)
927 perror_with_name (bfd_get_filename (sym_bfd
));
928 symbuf_left
= bfd_section_size (sym_bfd
, symbuf_sections
->section
);
929 symbol_table_offset
= filepos
- symbuf_read
;
930 symbuf_sections
= symbuf_sections
->next
;
934 if (count
> sizeof (symbuf
))
935 count
= sizeof (symbuf
);
938 nbytes
= bfd_read ((PTR
) symbuf
, count
, 1, sym_bfd
);
940 perror_with_name (bfd_get_filename (sym_bfd
));
941 else if (nbytes
== 0)
942 error ("Premature end of file reading symbol table");
943 symbuf_end
= nbytes
/ symbol_size
;
945 symbuf_left
-= nbytes
;
946 symbuf_read
+= nbytes
;
949 #define INTERNALIZE_SYMBOL(intern, extern, abfd) \
951 (intern).n_type = bfd_h_get_8 (abfd, (extern)->e_type); \
952 (intern).n_strx = bfd_h_get_32 (abfd, (extern)->e_strx); \
953 (intern).n_desc = bfd_h_get_16 (abfd, (extern)->e_desc); \
954 if (bfd_get_sign_extend_vma (abfd)) \
955 (intern).n_value = bfd_h_get_signed_32 (abfd, (extern)->e_value); \
957 (intern).n_value = bfd_h_get_32 (abfd, (extern)->e_value); \
960 /* Invariant: The symbol pointed to by symbuf_idx is the first one
961 that hasn't been swapped. Swap the symbol at the same time
962 that symbuf_idx is incremented. */
964 /* dbx allows the text of a symbol name to be continued into the
965 next symbol name! When such a continuation is encountered
966 (a \ at the end of the text of a name)
967 call this function to get the continuation. */
970 dbx_next_symbol_text (struct objfile
*objfile
)
972 struct internal_nlist nlist
;
974 if (symbuf_idx
== symbuf_end
)
975 fill_symbuf (symfile_bfd
);
978 INTERNALIZE_SYMBOL (nlist
, &symbuf
[symbuf_idx
], symfile_bfd
);
979 OBJSTAT (objfile
, n_stabs
++);
983 return nlist
.n_strx
+ stringtab_global
+ file_string_table_offset
;
986 /* Initialize the list of bincls to contain none and have some
990 init_bincl_list (int number
, struct objfile
*objfile
)
992 bincls_allocated
= number
;
993 next_bincl
= bincl_list
= (struct header_file_location
*)
994 xmmalloc (objfile
->md
, bincls_allocated
* sizeof (struct header_file_location
));
997 /* Add a bincl to the list. */
1000 add_bincl_to_list (struct partial_symtab
*pst
, char *name
, int instance
)
1002 if (next_bincl
>= bincl_list
+ bincls_allocated
)
1004 int offset
= next_bincl
- bincl_list
;
1005 bincls_allocated
*= 2;
1006 bincl_list
= (struct header_file_location
*)
1007 xmrealloc (pst
->objfile
->md
, (char *) bincl_list
,
1008 bincls_allocated
* sizeof (struct header_file_location
));
1009 next_bincl
= bincl_list
+ offset
;
1011 next_bincl
->pst
= pst
;
1012 next_bincl
->instance
= instance
;
1013 next_bincl
++->name
= name
;
1016 /* Given a name, value pair, find the corresponding
1017 bincl in the list. Return the partial symtab associated
1018 with that header_file_location. */
1020 static struct partial_symtab
*
1021 find_corresponding_bincl_psymtab (char *name
, int instance
)
1023 struct header_file_location
*bincl
;
1025 for (bincl
= bincl_list
; bincl
< next_bincl
; bincl
++)
1026 if (bincl
->instance
== instance
1027 && STREQ (name
, bincl
->name
))
1030 complain (&repeated_header_complaint
, name
, symnum
);
1031 return (struct partial_symtab
*) 0;
1034 /* Free the storage allocated for the bincl list. */
1037 free_bincl_list (struct objfile
*objfile
)
1039 mfree (objfile
->md
, (PTR
) bincl_list
);
1040 bincls_allocated
= 0;
1044 do_free_bincl_list_cleanup (void *objfile
)
1046 free_bincl_list (objfile
);
1049 static struct cleanup
*
1050 make_cleanup_free_bincl_list (struct objfile
*objfile
)
1052 return make_cleanup (do_free_bincl_list_cleanup
, objfile
);
1055 /* Scan a SunOs dynamic symbol table for symbols of interest and
1056 add them to the minimal symbol table. */
1059 read_dbx_dynamic_symtab (struct objfile
*objfile
)
1061 bfd
*abfd
= objfile
->obfd
;
1062 struct cleanup
*back_to
;
1072 CORE_ADDR sym_value
;
1075 /* Check that the symbol file has dynamic symbols that we know about.
1076 bfd_arch_unknown can happen if we are reading a sun3 symbol file
1077 on a sun4 host (and vice versa) and bfd is not configured
1078 --with-target=all. This would trigger an assertion in bfd/sunos.c,
1079 so we ignore the dynamic symbols in this case. */
1080 if (bfd_get_flavour (abfd
) != bfd_target_aout_flavour
1081 || (bfd_get_file_flags (abfd
) & DYNAMIC
) == 0
1082 || bfd_get_arch (abfd
) == bfd_arch_unknown
)
1085 dynsym_size
= bfd_get_dynamic_symtab_upper_bound (abfd
);
1086 if (dynsym_size
< 0)
1089 dynsyms
= (asymbol
**) xmalloc (dynsym_size
);
1090 back_to
= make_cleanup (xfree
, dynsyms
);
1092 dynsym_count
= bfd_canonicalize_dynamic_symtab (abfd
, dynsyms
);
1093 if (dynsym_count
< 0)
1095 do_cleanups (back_to
);
1099 /* Enter dynamic symbols into the minimal symbol table
1100 if this is a stripped executable. */
1101 if (bfd_get_symcount (abfd
) <= 0)
1104 for (counter
= 0; counter
< dynsym_count
; counter
++, symptr
++)
1106 asymbol
*sym
= *symptr
;
1110 sec
= bfd_get_section (sym
);
1112 /* BFD symbols are section relative. */
1113 sym_value
= sym
->value
+ sec
->vma
;
1115 if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1117 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
));
1120 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1122 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
1125 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1127 sym_value
+= ANOFFSET (objfile
->section_offsets
, SECT_OFF_BSS (objfile
));
1133 if (sym
->flags
& BSF_GLOBAL
)
1136 record_minimal_symbol ((char *) bfd_asymbol_name (sym
), sym_value
,
1141 /* Symbols from shared libraries have a dynamic relocation entry
1142 that points to the associated slot in the procedure linkage table.
1143 We make a mininal symbol table entry with type mst_solib_trampoline
1144 at the address in the procedure linkage table. */
1145 dynrel_size
= bfd_get_dynamic_reloc_upper_bound (abfd
);
1146 if (dynrel_size
< 0)
1148 do_cleanups (back_to
);
1152 dynrels
= (arelent
**) xmalloc (dynrel_size
);
1153 make_cleanup (xfree
, dynrels
);
1155 dynrel_count
= bfd_canonicalize_dynamic_reloc (abfd
, dynrels
, dynsyms
);
1156 if (dynrel_count
< 0)
1158 do_cleanups (back_to
);
1162 for (counter
= 0, relptr
= dynrels
;
1163 counter
< dynrel_count
;
1164 counter
++, relptr
++)
1166 arelent
*rel
= *relptr
;
1168 rel
->address
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_DATA (objfile
));
1170 switch (bfd_get_arch (abfd
))
1172 case bfd_arch_sparc
:
1173 if (rel
->howto
->type
!= RELOC_JMP_SLOT
)
1177 /* `16' is the type BFD produces for a jump table relocation. */
1178 if (rel
->howto
->type
!= 16)
1181 /* Adjust address in the jump table to point to
1182 the start of the bsr instruction. */
1189 name
= (char *) bfd_asymbol_name (*rel
->sym_ptr_ptr
);
1190 prim_record_minimal_symbol (name
, address
, mst_solib_trampoline
,
1194 do_cleanups (back_to
);
1197 /* Setup partial_symtab's describing each source file for which
1198 debugging information is available. */
1201 read_dbx_symtab (struct objfile
*objfile
)
1203 register struct external_nlist
*bufp
= 0; /* =0 avoids gcc -Wall glitch */
1204 struct internal_nlist nlist
;
1205 CORE_ADDR text_addr
;
1208 register char *namestring
;
1210 int past_first_source_file
= 0;
1211 CORE_ADDR last_o_file_start
= 0;
1212 CORE_ADDR last_function_start
= 0;
1213 struct cleanup
*back_to
;
1215 int textlow_not_set
;
1217 /* Current partial symtab */
1218 struct partial_symtab
*pst
;
1220 /* List of current psymtab's include files */
1221 char **psymtab_include_list
;
1222 int includes_allocated
;
1225 /* Index within current psymtab dependency list */
1226 struct partial_symtab
**dependency_list
;
1227 int dependencies_used
, dependencies_allocated
;
1229 text_addr
= DBX_TEXT_ADDR (objfile
);
1230 text_size
= DBX_TEXT_SIZE (objfile
);
1232 /* FIXME. We probably want to change stringtab_global rather than add this
1233 while processing every symbol entry. FIXME. */
1234 file_string_table_offset
= 0;
1235 next_file_string_table_offset
= 0;
1237 stringtab_global
= DBX_STRINGTAB (objfile
);
1239 pst
= (struct partial_symtab
*) 0;
1241 includes_allocated
= 30;
1243 psymtab_include_list
= (char **) alloca (includes_allocated
*
1246 dependencies_allocated
= 30;
1247 dependencies_used
= 0;
1249 (struct partial_symtab
**) alloca (dependencies_allocated
*
1250 sizeof (struct partial_symtab
*));
1252 /* Init bincl list */
1253 init_bincl_list (20, objfile
);
1254 back_to
= make_cleanup_free_bincl_list (objfile
);
1256 last_source_file
= NULL
;
1258 lowest_text_address
= (CORE_ADDR
) -1;
1260 symfile_bfd
= objfile
->obfd
; /* For next_text_symbol */
1261 abfd
= objfile
->obfd
;
1262 symbuf_end
= symbuf_idx
= 0;
1263 next_symbol_text_func
= dbx_next_symbol_text
;
1264 textlow_not_set
= 1;
1265 has_line_numbers
= 0;
1267 for (symnum
= 0; symnum
< DBX_SYMCOUNT (objfile
); symnum
++)
1269 /* Get the symbol for this run and pull out some info */
1270 QUIT
; /* allow this to be interruptable */
1271 if (symbuf_idx
== symbuf_end
)
1273 bufp
= &symbuf
[symbuf_idx
++];
1276 * Special case to speed up readin.
1278 if (bfd_h_get_8 (abfd
, bufp
->e_type
) == N_SLINE
)
1280 has_line_numbers
= 1;
1284 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1285 OBJSTAT (objfile
, n_stabs
++);
1287 /* Ok. There is a lot of code duplicated in the rest of this
1288 switch statement (for efficiency reasons). Since I don't
1289 like duplicating code, I will do my penance here, and
1290 describe the code which is duplicated:
1292 *) The assignment to namestring.
1293 *) The call to strchr.
1294 *) The addition of a partial symbol the the two partial
1295 symbol lists. This last is a large section of code, so
1296 I've imbedded it in the following macro.
1299 /* Set namestring based on nlist. If the string table index is invalid,
1300 give a fake name, and print a single error message per symbol file read,
1301 rather than abort the symbol reading or flood the user with messages. */
1303 /*FIXME: Too many adds and indirections in here for the inner loop. */
1304 #define SET_NAMESTRING()\
1305 if (((unsigned)CUR_SYMBOL_STRX + file_string_table_offset) >= \
1306 DBX_STRINGTAB_SIZE (objfile)) { \
1307 complain (&string_table_offset_complaint, symnum); \
1308 namestring = "<bad string table offset>"; \
1310 namestring = CUR_SYMBOL_STRX + file_string_table_offset + \
1311 DBX_STRINGTAB (objfile)
1313 #define CUR_SYMBOL_TYPE nlist.n_type
1314 #define CUR_SYMBOL_VALUE nlist.n_value
1315 #define CUR_SYMBOL_STRX nlist.n_strx
1316 #define DBXREAD_ONLY
1317 #define START_PSYMTAB(ofile,fname,low,symoff,global_syms,static_syms)\
1318 start_psymtab(ofile, fname, low, symoff, global_syms, static_syms)
1319 #define END_PSYMTAB(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)\
1320 end_psymtab(pst,ilist,ninc,c_off,c_text,dep_list,n_deps,textlow_not_set)
1322 #include "partial-stab.h"
1325 /* If there's stuff to be cleaned up, clean it up. */
1326 if (DBX_SYMCOUNT (objfile
) > 0 /* We have some syms */
1327 /*FIXME, does this have a bug at start address 0? */
1328 && last_o_file_start
1329 && objfile
->ei
.entry_point
< nlist
.n_value
1330 && objfile
->ei
.entry_point
>= last_o_file_start
)
1332 objfile
->ei
.entry_file_lowpc
= last_o_file_start
;
1333 objfile
->ei
.entry_file_highpc
= nlist
.n_value
;
1338 /* Don't set pst->texthigh lower than it already is. */
1339 CORE_ADDR text_end
=
1340 (lowest_text_address
== (CORE_ADDR
) -1
1341 ? (text_addr
+ ANOFFSET (objfile
->section_offsets
, SECT_OFF_TEXT (objfile
)))
1342 : lowest_text_address
)
1345 end_psymtab (pst
, psymtab_include_list
, includes_used
,
1346 symnum
* symbol_size
,
1347 text_end
> pst
->texthigh
? text_end
: pst
->texthigh
,
1348 dependency_list
, dependencies_used
, textlow_not_set
);
1351 do_cleanups (back_to
);
1354 /* Allocate and partially fill a partial symtab. It will be
1355 completely filled at the end of the symbol list.
1357 SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
1358 is the address relative to which its symbols are (incremental) or 0
1362 static struct partial_symtab
*
1363 start_psymtab (struct objfile
*objfile
, char *filename
, CORE_ADDR textlow
,
1364 int ldsymoff
, struct partial_symbol
**global_syms
,
1365 struct partial_symbol
**static_syms
)
1367 struct partial_symtab
*result
=
1368 start_psymtab_common (objfile
, objfile
->section_offsets
,
1369 filename
, textlow
, global_syms
, static_syms
);
1371 result
->read_symtab_private
= (char *)
1372 obstack_alloc (&objfile
->psymbol_obstack
, sizeof (struct symloc
));
1373 LDSYMOFF (result
) = ldsymoff
;
1374 result
->read_symtab
= dbx_psymtab_to_symtab
;
1375 SYMBOL_SIZE (result
) = symbol_size
;
1376 SYMBOL_OFFSET (result
) = symbol_table_offset
;
1377 STRING_OFFSET (result
) = string_table_offset
;
1378 FILE_STRING_OFFSET (result
) = file_string_table_offset
;
1380 /* If we're handling an ELF file, drag some section-relocation info
1381 for this source file out of the ELF symbol table, to compensate for
1382 Sun brain death. This replaces the section_offsets in this psymtab,
1384 elfstab_offset_sections (objfile
, result
);
1386 /* Deduce the source language from the filename for this psymtab. */
1387 psymtab_language
= deduce_language_from_filename (filename
);
1392 /* Close off the current usage of PST.
1393 Returns PST or NULL if the partial symtab was empty and thrown away.
1395 FIXME: List variables and peculiarities of same. */
1397 struct partial_symtab
*
1398 end_psymtab (struct partial_symtab
*pst
, char **include_list
, int num_includes
,
1399 int capping_symbol_offset
, CORE_ADDR capping_text
,
1400 struct partial_symtab
**dependency_list
, int number_dependencies
,
1401 int textlow_not_set
)
1404 struct objfile
*objfile
= pst
->objfile
;
1406 if (capping_symbol_offset
!= -1)
1407 LDSYMLEN (pst
) = capping_symbol_offset
- LDSYMOFF (pst
);
1408 pst
->texthigh
= capping_text
;
1410 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
1411 /* Under Solaris, the N_SO symbols always have a value of 0,
1412 instead of the usual address of the .o file. Therefore,
1413 we have to do some tricks to fill in texthigh and textlow.
1414 The first trick is in partial-stab.h: if we see a static
1415 or global function, and the textlow for the current pst
1416 is not set (ie: textlow_not_set), then we use that function's
1417 address for the textlow of the pst. */
1419 /* Now, to fill in texthigh, we remember the last function seen
1420 in the .o file (also in partial-stab.h). Also, there's a hack in
1421 bfd/elf.c and gdb/elfread.c to pass the ELF st_size field
1422 to here via the misc_info field. Therefore, we can fill in
1423 a reliable texthigh by taking the address plus size of the
1424 last function in the file. */
1426 if (pst
->texthigh
== 0 && last_function_name
)
1430 struct minimal_symbol
*minsym
;
1432 p
= strchr (last_function_name
, ':');
1434 p
= last_function_name
;
1435 n
= p
- last_function_name
;
1437 strncpy (p
, last_function_name
, n
);
1440 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1443 /* Sun Fortran appends an underscore to the minimal symbol name,
1444 try again with an appended underscore if the minimal symbol
1448 minsym
= lookup_minimal_symbol (p
, pst
->filename
, objfile
);
1452 pst
->texthigh
= SYMBOL_VALUE_ADDRESS (minsym
) + MSYMBOL_SIZE (minsym
);
1454 last_function_name
= NULL
;
1457 /* this test will be true if the last .o file is only data */
1458 if (textlow_not_set
)
1459 pst
->textlow
= pst
->texthigh
;
1462 struct partial_symtab
*p1
;
1464 /* If we know our own starting text address, then walk through all other
1465 psymtabs for this objfile, and if any didn't know their ending text
1466 address, set it to our starting address. Take care to not set our
1467 own ending address to our starting address, nor to set addresses on
1468 `dependency' files that have both textlow and texthigh zero. */
1470 ALL_OBJFILE_PSYMTABS (objfile
, p1
)
1472 if (p1
->texthigh
== 0 && p1
->textlow
!= 0 && p1
!= pst
)
1474 p1
->texthigh
= pst
->textlow
;
1475 /* if this file has only data, then make textlow match texthigh */
1476 if (p1
->textlow
== 0)
1477 p1
->textlow
= p1
->texthigh
;
1482 /* End of kludge for patching Solaris textlow and texthigh. */
1483 #endif /* SOFUN_ADDRESS_MAYBE_MISSING. */
1485 pst
->n_global_syms
=
1486 objfile
->global_psymbols
.next
- (objfile
->global_psymbols
.list
+ pst
->globals_offset
);
1487 pst
->n_static_syms
=
1488 objfile
->static_psymbols
.next
- (objfile
->static_psymbols
.list
+ pst
->statics_offset
);
1490 pst
->number_of_dependencies
= number_dependencies
;
1491 if (number_dependencies
)
1493 pst
->dependencies
= (struct partial_symtab
**)
1494 obstack_alloc (&objfile
->psymbol_obstack
,
1495 number_dependencies
* sizeof (struct partial_symtab
*));
1496 memcpy (pst
->dependencies
, dependency_list
,
1497 number_dependencies
* sizeof (struct partial_symtab
*));
1500 pst
->dependencies
= 0;
1502 for (i
= 0; i
< num_includes
; i
++)
1504 struct partial_symtab
*subpst
=
1505 allocate_psymtab (include_list
[i
], objfile
);
1507 /* Copy the sesction_offsets array from the main psymtab. */
1508 subpst
->section_offsets
= pst
->section_offsets
;
1509 subpst
->read_symtab_private
=
1510 (char *) obstack_alloc (&objfile
->psymbol_obstack
,
1511 sizeof (struct symloc
));
1515 subpst
->texthigh
= 0;
1517 /* We could save slight bits of space by only making one of these,
1518 shared by the entire set of include files. FIXME-someday. */
1519 subpst
->dependencies
= (struct partial_symtab
**)
1520 obstack_alloc (&objfile
->psymbol_obstack
,
1521 sizeof (struct partial_symtab
*));
1522 subpst
->dependencies
[0] = pst
;
1523 subpst
->number_of_dependencies
= 1;
1525 subpst
->globals_offset
=
1526 subpst
->n_global_syms
=
1527 subpst
->statics_offset
=
1528 subpst
->n_static_syms
= 0;
1532 subpst
->read_symtab
= pst
->read_symtab
;
1535 sort_pst_symbols (pst
);
1537 /* If there is already a psymtab or symtab for a file of this name, remove it.
1538 (If there is a symtab, more drastic things also happen.)
1539 This happens in VxWorks. */
1540 free_named_symtabs (pst
->filename
);
1542 if (num_includes
== 0
1543 && number_dependencies
== 0
1544 && pst
->n_global_syms
== 0
1545 && pst
->n_static_syms
== 0
1546 && has_line_numbers
== 0)
1548 /* Throw away this psymtab, it's empty. We can't deallocate it, since
1549 it is on the obstack, but we can forget to chain it on the list. */
1550 /* Empty psymtabs happen as a result of header files which don't have
1551 any symbols in them. There can be a lot of them. But this check
1552 is wrong, in that a psymtab with N_SLINE entries but nothing else
1553 is not empty, but we don't realize that. Fixing that without slowing
1554 things down might be tricky. */
1556 discard_psymtab (pst
);
1558 /* Indicate that psymtab was thrown away. */
1559 pst
= (struct partial_symtab
*) NULL
;
1565 dbx_psymtab_to_symtab_1 (struct partial_symtab
*pst
)
1567 struct cleanup
*old_chain
;
1575 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1580 /* Read in all partial symtabs on which this one is dependent */
1581 for (i
= 0; i
< pst
->number_of_dependencies
; i
++)
1582 if (!pst
->dependencies
[i
]->readin
)
1584 /* Inform about additional files that need to be read in. */
1587 fputs_filtered (" ", gdb_stdout
);
1589 fputs_filtered ("and ", gdb_stdout
);
1591 printf_filtered ("%s...", pst
->dependencies
[i
]->filename
);
1592 wrap_here (""); /* Flush output */
1593 gdb_flush (gdb_stdout
);
1595 dbx_psymtab_to_symtab_1 (pst
->dependencies
[i
]);
1598 if (LDSYMLEN (pst
)) /* Otherwise it's a dummy */
1600 /* Init stuff necessary for reading in symbols */
1603 old_chain
= make_cleanup (really_free_pendings
, 0);
1604 file_string_table_offset
= FILE_STRING_OFFSET (pst
);
1605 symbol_size
= SYMBOL_SIZE (pst
);
1607 /* Read in this file's symbols */
1608 bfd_seek (pst
->objfile
->obfd
, SYMBOL_OFFSET (pst
), SEEK_SET
);
1609 read_ofile_symtab (pst
);
1610 sort_symtab_syms (pst
->symtab
);
1612 do_cleanups (old_chain
);
1618 /* Read in all of the symbols for a given psymtab for real.
1619 Be verbose about it if the user wants that. */
1622 dbx_psymtab_to_symtab (struct partial_symtab
*pst
)
1631 fprintf_unfiltered (gdb_stderr
, "Psymtab for %s already read in. Shouldn't happen.\n",
1636 if (LDSYMLEN (pst
) || pst
->number_of_dependencies
)
1638 /* Print the message now, before reading the string table,
1639 to avoid disconcerting pauses. */
1642 printf_filtered ("Reading in symbols for %s...", pst
->filename
);
1643 gdb_flush (gdb_stdout
);
1646 sym_bfd
= pst
->objfile
->obfd
;
1648 next_symbol_text_func
= dbx_next_symbol_text
;
1650 dbx_psymtab_to_symtab_1 (pst
);
1652 /* Match with global symbols. This only needs to be done once,
1653 after all of the symtabs and dependencies have been read in. */
1654 scan_file_globals (pst
->objfile
);
1656 /* Finish up the debug error message. */
1658 printf_filtered ("done.\n");
1662 /* Read in a defined section of a specific object file's symbols. */
1665 read_ofile_symtab (struct partial_symtab
*pst
)
1667 register char *namestring
;
1668 register struct external_nlist
*bufp
;
1669 struct internal_nlist nlist
;
1671 unsigned max_symnum
;
1673 struct objfile
*objfile
;
1674 int sym_offset
; /* Offset to start of symbols to read */
1675 int sym_size
; /* Size of symbols to read */
1676 CORE_ADDR text_offset
; /* Start of text segment for symbols */
1677 int text_size
; /* Size of text segment for symbols */
1678 struct section_offsets
*section_offsets
;
1680 objfile
= pst
->objfile
;
1681 sym_offset
= LDSYMOFF (pst
);
1682 sym_size
= LDSYMLEN (pst
);
1683 text_offset
= pst
->textlow
;
1684 text_size
= pst
->texthigh
- pst
->textlow
;
1685 /* This cannot be simply objfile->section_offsets because of
1686 elfstab_offset_sections() which initializes the psymtab section
1687 offsets information in a special way, and that is different from
1688 objfile->section_offsets. */
1689 section_offsets
= pst
->section_offsets
;
1691 current_objfile
= objfile
;
1692 subfile_stack
= NULL
;
1694 stringtab_global
= DBX_STRINGTAB (objfile
);
1695 last_source_file
= NULL
;
1697 abfd
= objfile
->obfd
;
1698 symfile_bfd
= objfile
->obfd
; /* Implicit param to next_text_symbol */
1699 symbuf_end
= symbuf_idx
= 0;
1701 /* It is necessary to actually read one symbol *before* the start
1702 of this symtab's symbols, because the GCC_COMPILED_FLAG_SYMBOL
1703 occurs before the N_SO symbol.
1705 Detecting this in read_dbx_symtab
1706 would slow down initial readin, so we look for it here instead. */
1707 if (!processing_acc_compilation
&& sym_offset
>= (int) symbol_size
)
1709 bfd_seek (symfile_bfd
, sym_offset
- symbol_size
, SEEK_CUR
);
1711 bufp
= &symbuf
[symbuf_idx
++];
1712 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1713 OBJSTAT (objfile
, n_stabs
++);
1717 processing_gcc_compilation
= 0;
1718 if (nlist
.n_type
== N_TEXT
)
1720 const char *tempstring
= namestring
;
1722 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1723 processing_gcc_compilation
= 1;
1724 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1725 processing_gcc_compilation
= 2;
1726 if (tempstring
[0] == bfd_get_symbol_leading_char (symfile_bfd
))
1728 if (STREQN (tempstring
, "__gnu_compiled", 14))
1729 processing_gcc_compilation
= 2;
1732 /* Try to select a C++ demangling based on the compilation unit
1736 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1737 know whether it will use the old style or v3 mangling. */
1738 if (processing_gcc_compilation
)
1740 if (AUTO_DEMANGLING
)
1742 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1749 /* The N_SO starting this symtab is the first symbol, so we
1750 better not check the symbol before it. I'm not this can
1751 happen, but it doesn't hurt to check for it. */
1752 bfd_seek (symfile_bfd
, sym_offset
, SEEK_CUR
);
1753 processing_gcc_compilation
= 0;
1756 if (symbuf_idx
== symbuf_end
)
1758 bufp
= &symbuf
[symbuf_idx
];
1759 if (bfd_h_get_8 (abfd
, bufp
->e_type
) != N_SO
)
1760 error ("First symbol in segment of executable not a source symbol");
1762 max_symnum
= sym_size
/ symbol_size
;
1765 symnum
< max_symnum
;
1768 QUIT
; /* Allow this to be interruptable */
1769 if (symbuf_idx
== symbuf_end
)
1771 bufp
= &symbuf
[symbuf_idx
++];
1772 INTERNALIZE_SYMBOL (nlist
, bufp
, abfd
);
1773 OBJSTAT (objfile
, n_stabs
++);
1775 type
= bfd_h_get_8 (abfd
, bufp
->e_type
);
1781 process_one_symbol (type
, nlist
.n_desc
, nlist
.n_value
,
1782 namestring
, section_offsets
, objfile
);
1784 /* We skip checking for a new .o or -l file; that should never
1785 happen in this routine. */
1786 else if (type
== N_TEXT
)
1788 /* I don't think this code will ever be executed, because
1789 the GCC_COMPILED_FLAG_SYMBOL usually is right before
1790 the N_SO symbol which starts this source file.
1791 However, there is no reason not to accept
1792 the GCC_COMPILED_FLAG_SYMBOL anywhere. */
1794 if (STREQ (namestring
, GCC_COMPILED_FLAG_SYMBOL
))
1795 processing_gcc_compilation
= 1;
1796 else if (STREQ (namestring
, GCC2_COMPILED_FLAG_SYMBOL
))
1797 processing_gcc_compilation
= 2;
1800 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
1801 know whether it will use the old style or v3 mangling. */
1802 if (AUTO_DEMANGLING
)
1804 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
1808 else if (type
& N_EXT
|| type
== (unsigned char) N_TEXT
1809 || type
== (unsigned char) N_NBTEXT
1812 /* Global symbol: see if we came across a dbx defintion for
1813 a corresponding symbol. If so, store the value. Remove
1814 syms from the chain when their values are stored, but
1815 search the whole chain, as there may be several syms from
1816 different files with the same name. */
1817 /* This is probably not true. Since the files will be read
1818 in one at a time, each reference to a global symbol will
1819 be satisfied in each file as it appears. So we skip this
1825 current_objfile
= NULL
;
1827 /* In a Solaris elf file, this variable, which comes from the
1828 value of the N_SO symbol, will still be 0. Luckily, text_offset,
1829 which comes from pst->textlow is correct. */
1830 if (last_source_start_addr
== 0)
1831 last_source_start_addr
= text_offset
;
1833 /* In reordered executables last_source_start_addr may not be the
1834 lower bound for this symtab, instead use text_offset which comes
1835 from pst->textlow which is correct. */
1836 if (last_source_start_addr
> text_offset
)
1837 last_source_start_addr
= text_offset
;
1839 pst
->symtab
= end_symtab (text_offset
+ text_size
, objfile
, SECT_OFF_TEXT (objfile
));
1841 /* Process items which we had to "process_later" due to dependencies
1843 process_now (objfile
);
1849 /* This handles a single symbol from the symbol-file, building symbols
1850 into a GDB symtab. It takes these arguments and an implicit argument.
1852 TYPE is the type field of the ".stab" symbol entry.
1853 DESC is the desc field of the ".stab" entry.
1854 VALU is the value field of the ".stab" entry.
1855 NAME is the symbol name, in our address space.
1856 SECTION_OFFSETS is a set of amounts by which the sections of this object
1857 file were relocated when it was loaded into memory.
1858 Note that these section_offsets are not the
1859 objfile->section_offsets but the pst->section_offsets.
1860 All symbols that refer
1861 to memory locations need to be offset by these amounts.
1862 OBJFILE is the object file from which we are reading symbols.
1863 It is used in end_symtab. */
1866 process_one_symbol (int type
, int desc
, CORE_ADDR valu
, char *name
,
1867 struct section_offsets
*section_offsets
,
1868 struct objfile
*objfile
)
1870 #ifdef SUN_FIXED_LBRAC_BUG
1871 /* If SUN_FIXED_LBRAC_BUG is defined, then it tells us whether we need
1872 to correct the address of N_LBRAC's. If it is not defined, then
1873 we never need to correct the addresses. */
1875 /* This records the last pc address we've seen. We depend on there being
1876 an SLINE or FUN or SO before the first LBRAC, since the variable does
1877 not get reset in between reads of different symbol files. */
1878 static CORE_ADDR last_pc_address
;
1881 register struct context_stack
*new;
1882 /* This remembers the address of the start of a function. It is used
1883 because in Solaris 2, N_LBRAC, N_RBRAC, and N_SLINE entries are
1884 relative to the current function's start address. On systems
1885 other than Solaris 2, this just holds the SECT_OFF_TEXT value, and is
1886 used to relocate these symbol types rather than SECTION_OFFSETS. */
1887 static CORE_ADDR function_start_offset
;
1889 /* If this is nonzero, we've seen a non-gcc N_OPT symbol for this source
1890 file. Used to detect the SunPRO solaris compiler. */
1891 static int n_opt_found
;
1893 /* The stab type used for the definition of the last function.
1894 N_STSYM or N_GSYM for SunOS4 acc; N_FUN for other compilers. */
1895 static int function_stab_type
= 0;
1897 if (!block_address_function_relative
)
1898 /* N_LBRAC, N_RBRAC and N_SLINE entries are not relative to the
1899 function start address, so just use the text offset. */
1900 function_start_offset
= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
1902 /* Something is wrong if we see real data before
1903 seeing a source file name. */
1905 if (last_source_file
== NULL
&& type
!= (unsigned char) N_SO
)
1907 /* Ignore any symbols which appear before an N_SO symbol.
1908 Currently no one puts symbols there, but we should deal
1909 gracefully with the case. A complain()t might be in order,
1910 but this should not be an error (). */
1919 if (*name
== '\000')
1921 /* This N_FUN marks the end of a function. This closes off the
1923 within_function
= 0;
1924 new = pop_context ();
1926 /* Make a block for the local symbols within. */
1927 finish_block (new->name
, &local_symbols
, new->old_blocks
,
1928 new->start_addr
, new->start_addr
+ valu
,
1931 /* May be switching to an assembler file which may not be using
1932 block relative stabs, so reset the offset. */
1933 if (block_address_function_relative
)
1934 function_start_offset
= 0;
1939 /* Relocate for dynamic loading */
1940 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
1941 #ifdef SMASH_TEXT_ADDRESS
1942 SMASH_TEXT_ADDRESS (valu
);
1944 goto define_a_symbol
;
1947 /* This "symbol" just indicates the start of an inner lexical
1948 context within a function. */
1950 /* Ignore extra outermost context from SunPRO cc and acc. */
1951 if (n_opt_found
&& desc
== 1)
1954 if (block_address_function_relative
)
1955 /* Relocate for Sun ELF acc fn-relative syms. */
1956 valu
+= function_start_offset
;
1958 /* On most machines, the block addresses are relative to the
1959 N_SO, the linker did not relocate them (sigh). */
1960 valu
+= last_source_start_addr
;
1962 #ifdef SUN_FIXED_LBRAC_BUG
1963 if (!SUN_FIXED_LBRAC_BUG
&& valu
< last_pc_address
)
1965 /* Patch current LBRAC pc value to match last handy pc value */
1966 complain (&lbrac_complaint
);
1967 valu
= last_pc_address
;
1970 new = push_context (desc
, valu
);
1974 /* This "symbol" just indicates the end of an inner lexical
1975 context that was started with N_LBRAC. */
1977 /* Ignore extra outermost context from SunPRO cc and acc. */
1978 if (n_opt_found
&& desc
== 1)
1981 if (block_address_function_relative
)
1982 /* Relocate for Sun ELF acc fn-relative syms. */
1983 valu
+= function_start_offset
;
1985 /* On most machines, the block addresses are relative to the
1986 N_SO, the linker did not relocate them (sigh). */
1987 valu
+= last_source_start_addr
;
1989 new = pop_context ();
1990 if (desc
!= new->depth
)
1991 complain (&lbrac_mismatch_complaint
, symnum
);
1993 /* Some compilers put the variable decls inside of an
1994 LBRAC/RBRAC block. This macro should be nonzero if this
1995 is true. DESC is N_DESC from the N_RBRAC symbol.
1996 GCC_P is true if we've detected the GCC_COMPILED_SYMBOL
1997 or the GCC2_COMPILED_SYMBOL. */
1998 #if !defined (VARIABLES_INSIDE_BLOCK)
1999 #define VARIABLES_INSIDE_BLOCK(desc, gcc_p) 0
2002 /* Can only use new->locals as local symbols here if we're in
2003 gcc or on a machine that puts them before the lbrack. */
2004 if (!VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2005 local_symbols
= new->locals
;
2007 if (context_stack_depth
2008 > !VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2010 /* This is not the outermost LBRAC...RBRAC pair in the function,
2011 its local symbols preceded it, and are the ones just recovered
2012 from the context stack. Define the block for them (but don't
2013 bother if the block contains no symbols. Should we complain
2014 on blocks without symbols? I can't think of any useful purpose
2016 if (local_symbols
!= NULL
)
2018 /* Muzzle a compiler bug that makes end < start. (which
2019 compilers? Is this ever harmful?). */
2020 if (new->start_addr
> valu
)
2022 complain (&lbrac_rbrac_complaint
);
2023 new->start_addr
= valu
;
2025 /* Make a block for the local symbols within. */
2026 finish_block (0, &local_symbols
, new->old_blocks
,
2027 new->start_addr
, valu
, objfile
);
2032 /* This is the outermost LBRAC...RBRAC pair. There is no
2033 need to do anything; leave the symbols that preceded it
2034 to be attached to the function's own block. We need to
2035 indicate that we just moved outside of the function. */
2036 within_function
= 0;
2039 if (VARIABLES_INSIDE_BLOCK (desc
, processing_gcc_compilation
))
2040 /* Now pop locals of block just finished. */
2041 local_symbols
= new->locals
;
2046 /* This kind of symbol indicates the start of an object file. */
2047 /* Relocate for dynamic loading */
2048 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
2052 /* This type of symbol indicates the start of data
2053 for one source file.
2054 Finish the symbol table of the previous source file
2055 (if any) and start accumulating a new symbol table. */
2056 /* Relocate for dynamic loading */
2057 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
2061 #ifdef SUN_FIXED_LBRAC_BUG
2062 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2065 #ifdef PCC_SOL_BROKEN
2066 /* pcc bug, occasionally puts out SO for SOL. */
2067 if (context_stack_depth
> 0)
2069 start_subfile (name
, NULL
);
2073 if (last_source_file
)
2075 /* Check if previous symbol was also an N_SO (with some
2076 sanity checks). If so, that one was actually the directory
2077 name, and the current one is the real file name.
2079 if (previous_stab_code
== (unsigned char) N_SO
)
2081 patch_subfile_names (current_subfile
, name
);
2082 break; /* Ignore repeated SOs */
2084 end_symtab (valu
, objfile
, SECT_OFF_TEXT (objfile
));
2088 /* Null name means this just marks the end of text for this .o file.
2089 Don't start a new symtab in this case. */
2090 if (*name
== '\000')
2093 if (block_address_function_relative
)
2094 function_start_offset
= 0;
2097 start_symtab (name
, NULL
, valu
);
2098 record_debugformat ("stabs");
2102 /* This type of symbol indicates the start of data for
2103 a sub-source-file, one whose contents were copied or
2104 included in the compilation of the main source file
2105 (whose name was given in the N_SO symbol.) */
2106 /* Relocate for dynamic loading */
2107 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
2108 start_subfile (name
, current_subfile
->dirname
);
2113 add_new_header_file (name
, valu
);
2114 start_subfile (name
, current_subfile
->dirname
);
2118 start_subfile (pop_subfile (), current_subfile
->dirname
);
2122 add_old_header_file (name
, valu
);
2126 /* This type of "symbol" really just records
2127 one line-number -- core-address correspondence.
2128 Enter it in the line list for this symbol table. */
2130 /* Relocate for dynamic loading and for ELF acc fn-relative syms. */
2131 valu
+= function_start_offset
;
2133 #ifdef SUN_FIXED_LBRAC_BUG
2134 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2136 record_line (current_subfile
, desc
, valu
);
2140 common_block_start (name
, objfile
);
2144 common_block_end (objfile
);
2147 /* The following symbol types need to have the appropriate offset added
2148 to their value; then we process symbol definitions in the name. */
2150 case N_STSYM
: /* Static symbol in data seg */
2151 case N_LCSYM
: /* Static symbol in BSS seg */
2152 case N_ROSYM
: /* Static symbol in Read-only data seg */
2153 /* HORRID HACK DEPT. However, it's Sun's furgin' fault.
2154 Solaris2's stabs-in-elf makes *most* symbols relative
2155 but leaves a few absolute (at least for Solaris 2.1 and version
2156 2.0.1 of the SunPRO compiler). N_STSYM and friends sit on the fence.
2157 .stab "foo:S...",N_STSYM is absolute (ld relocates it)
2158 .stab "foo:V...",N_STSYM is relative (section base subtracted).
2159 This leaves us no choice but to search for the 'S' or 'V'...
2160 (or pass the whole section_offsets stuff down ONE MORE function
2161 call level, which we really don't want to do). */
2165 /* .o files and NLMs have non-zero text seg offsets, but don't need
2166 their static syms offset in this fashion. XXX - This is really a
2167 crock that should be fixed in the solib handling code so that I
2168 don't have to work around it here. */
2170 if (!symfile_relocatable
)
2172 p
= strchr (name
, ':');
2173 if (p
!= 0 && p
[1] == 'S')
2175 /* The linker relocated it. We don't want to add an
2176 elfstab_offset_sections-type offset, but we *do* want
2177 to add whatever solib.c passed to symbol_file_add as
2178 addr (this is known to affect SunOS4, and I suspect ELF
2179 too). Since elfstab_offset_sections currently does not
2180 muck with the text offset (there is no Ttext.text
2181 symbol), we can get addr from the text offset. If
2182 elfstab_offset_sections ever starts dealing with the
2183 text offset, and we still need to do this, we need to
2184 invent a SECT_OFF_ADDR_KLUDGE or something. */
2185 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
2186 goto define_a_symbol
;
2189 /* Since it's not the kludge case, re-dispatch to the right handler. */
2199 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
2203 case_N_STSYM
: /* Static symbol in data seg */
2204 case N_DSLINE
: /* Source line number, data seg */
2205 valu
+= ANOFFSET (section_offsets
, SECT_OFF_DATA (objfile
));
2206 goto define_a_symbol
;
2208 case_N_LCSYM
: /* Static symbol in BSS seg */
2209 case N_BSLINE
: /* Source line number, bss seg */
2210 /* N_BROWS: overlaps with N_BSLINE */
2211 valu
+= ANOFFSET (section_offsets
, SECT_OFF_BSS (objfile
));
2212 goto define_a_symbol
;
2214 case_N_ROSYM
: /* Static symbol in Read-only data seg */
2215 valu
+= ANOFFSET (section_offsets
, SECT_OFF_RODATA (objfile
));
2216 goto define_a_symbol
;
2218 case N_ENTRY
: /* Alternate entry point */
2219 /* Relocate for dynamic loading */
2220 valu
+= ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
));
2221 goto define_a_symbol
;
2223 /* The following symbol types we don't know how to process. Handle
2224 them in a "default" way, but complain to people who care. */
2226 case N_CATCH
: /* Exception handler catcher */
2227 case N_EHDECL
: /* Exception handler name */
2228 case N_PC
: /* Global symbol in Pascal */
2229 case N_M2C
: /* Modula-2 compilation unit */
2230 /* N_MOD2: overlaps with N_EHDECL */
2231 case N_SCOPE
: /* Modula-2 scope information */
2232 case N_ECOML
: /* End common (local name) */
2233 case N_NBTEXT
: /* Gould Non-Base-Register symbols??? */
2238 complain (&unknown_symtype_complaint
, local_hex_string (type
));
2241 /* The following symbol types don't need the address field relocated,
2242 since it is either unused, or is absolute. */
2244 case N_GSYM
: /* Global variable */
2245 case N_NSYMS
: /* Number of symbols (ultrix) */
2246 case N_NOMAP
: /* No map? (ultrix) */
2247 case N_RSYM
: /* Register variable */
2248 case N_DEFD
: /* Modula-2 GNU module dependency */
2249 case N_SSYM
: /* Struct or union element */
2250 case N_LSYM
: /* Local symbol in stack */
2251 case N_PSYM
: /* Parameter variable */
2252 case N_LENG
: /* Length of preceding symbol type */
2256 char *colon_pos
= strchr (name
, ':');
2257 if (colon_pos
== NULL
)
2260 deftype
= colon_pos
[1];
2266 function_stab_type
= type
;
2268 #ifdef SOFUN_ADDRESS_MAYBE_MISSING
2269 /* Deal with the SunPRO 3.0 compiler which omits the address
2270 from N_FUN symbols. */
2272 && valu
== ANOFFSET (section_offsets
, SECT_OFF_TEXT (objfile
)))
2274 find_stab_function_addr (name
, last_source_file
, objfile
);
2277 #ifdef SUN_FIXED_LBRAC_BUG
2278 /* The Sun acc compiler, under SunOS4, puts out
2279 functions with N_GSYM or N_STSYM. The problem is
2280 that the address of the symbol is no good (for N_GSYM
2281 it doesn't even attept an address; for N_STSYM it
2282 puts out an address but then it gets relocated
2283 relative to the data segment, not the text segment).
2284 Currently we can't fix this up later as we do for
2285 some types of symbol in scan_file_globals.
2286 Fortunately we do have a way of finding the address -
2287 we know that the value in last_pc_address is either
2288 the one we want (if we're dealing with the first
2289 function in an object file), or somewhere in the
2290 previous function. This means that we can use the
2291 minimal symbol table to get the address. */
2293 /* Starting with release 3.0, the Sun acc compiler,
2294 under SunOS4, puts out functions with N_FUN and a value
2295 of zero. This gets relocated to the start of the text
2296 segment of the module, which is no good either.
2297 Under SunOS4 we can deal with this as N_SLINE and N_SO
2298 entries contain valid absolute addresses.
2299 Release 3.0 acc also puts out N_OPT entries, which makes
2300 it possible to discern acc from cc or gcc. */
2302 if (type
== N_GSYM
|| type
== N_STSYM
2304 && n_opt_found
&& !block_address_function_relative
))
2306 struct minimal_symbol
*m
;
2307 int l
= colon_pos
- name
;
2309 m
= lookup_minimal_symbol_by_pc (last_pc_address
);
2310 if (m
&& STREQN (SYMBOL_NAME (m
), name
, l
)
2311 && SYMBOL_NAME (m
)[l
] == '\0')
2312 /* last_pc_address was in this function */
2313 valu
= SYMBOL_VALUE (m
);
2314 else if (m
&& SYMBOL_NAME (m
+ 1)
2315 && STREQN (SYMBOL_NAME (m
+ 1), name
, l
)
2316 && SYMBOL_NAME (m
+ 1)[l
] == '\0')
2317 /* last_pc_address was in last function */
2318 valu
= SYMBOL_VALUE (m
+ 1);
2320 /* Not found - use last_pc_address (for finish_block) */
2321 valu
= last_pc_address
;
2324 last_pc_address
= valu
; /* Save for SunOS bug circumcision */
2327 if (block_address_function_relative
)
2328 /* For Solaris 2.0 compilers, the block addresses and
2329 N_SLINE's are relative to the start of the
2330 function. On normal systems, and when using gcc on
2331 Solaris 2.0, these addresses are just absolute, or
2332 relative to the N_SO, depending on
2333 BLOCK_ADDRESS_ABSOLUTE. */
2334 function_start_offset
= valu
;
2336 within_function
= 1;
2338 if (context_stack_depth
> 1)
2340 complain (&lbrac_unmatched_complaint
, symnum
);
2344 if (context_stack_depth
> 0)
2346 new = pop_context ();
2347 /* Make a block for the local symbols within. */
2348 finish_block (new->name
, &local_symbols
, new->old_blocks
,
2349 new->start_addr
, valu
, objfile
);
2352 new = push_context (0, valu
);
2353 new->name
= define_symbol (valu
, name
, desc
, type
, objfile
);
2357 define_symbol (valu
, name
, desc
, type
, objfile
);
2363 /* We use N_OPT to carry the gcc2_compiled flag. Sun uses it
2364 for a bunch of other flags, too. Someday we may parse their
2365 flags; for now we ignore theirs and hope they'll ignore ours. */
2366 case N_OPT
: /* Solaris 2: Compiler options */
2369 if (STREQ (name
, GCC2_COMPILED_FLAG_SYMBOL
))
2371 processing_gcc_compilation
= 2;
2372 #if 0 /* Works, but is experimental. -fnf */
2373 /* For now, stay with AUTO_DEMANGLING for g++ output, as we don't
2374 know whether it will use the old style or v3 mangling. */
2375 if (AUTO_DEMANGLING
)
2377 set_demangling_style (GNU_DEMANGLING_STYLE_STRING
);
2386 case N_MAIN
: /* Name of main routine. */
2387 /* FIXME: If one has a symbol file with N_MAIN and then replaces
2388 it with a symbol file with "main" and without N_MAIN. I'm
2389 not sure exactly what rule to follow but probably something
2390 like: N_MAIN takes precedence over "main" no matter what
2391 objfile it is in; If there is more than one N_MAIN, choose
2392 the one in the symfile_objfile; If there is more than one
2393 N_MAIN within a given objfile, complain() and choose
2394 arbitrarily. (kingdon) */
2396 set_main_name (name
);
2399 /* The following symbol types can be ignored. */
2400 case N_OBJ
: /* Solaris 2: Object file dir and name */
2401 /* N_UNDF: Solaris 2: file separator mark */
2402 /* N_UNDF: -- we will never encounter it, since we only process one
2403 file's symbols at once. */
2404 case N_ENDM
: /* Solaris 2: End of module */
2405 case N_ALIAS
: /* SunPro F77: alias name, ignore for now. */
2409 /* '#' is a GNU C extension to allow one symbol to refer to another
2412 Generally this is used so that an alias can refer to its main
2416 /* Initialize symbol reference names and determine if this is
2417 a definition. If symbol reference is being defined, go
2418 ahead and add it. Otherwise, just return sym. */
2423 /* If this stab defines a new reference ID that is not on the
2424 reference list, then put it on the reference list.
2426 We go ahead and advance NAME past the reference, even though
2427 it is not strictly necessary at this time. */
2428 refnum
= symbol_reference_defined (&s
);
2430 if (!ref_search (refnum
))
2431 ref_add (refnum
, 0, name
, valu
);
2436 previous_stab_code
= type
;
2439 /* FIXME: The only difference between this and elfstab_build_psymtabs
2440 is the call to install_minimal_symbols for elf, and the support for
2441 split sections. If the differences are really that small, the code
2442 should be shared. */
2444 /* Scan and build partial symbols for an coff symbol file.
2445 The coff file has already been processed to get its minimal symbols.
2447 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2450 OBJFILE is the object file we are reading symbols from.
2451 ADDR is the address relative to which the symbols are (e.g.
2452 the base address of the text segment).
2453 MAINLINE is true if we are reading the main symbol
2454 table (as opposed to a shared lib or dynamically loaded file).
2455 TEXTADDR is the address of the text section.
2456 TEXTSIZE is the size of the text section.
2457 STABSECTS is the list of .stab sections in OBJFILE.
2458 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2459 .stabstr section exists.
2461 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2462 adjusted for coff details. */
2465 coffstab_build_psymtabs (struct objfile
*objfile
, int mainline
,
2466 CORE_ADDR textaddr
, unsigned int textsize
,
2467 struct stab_section_list
*stabsects
,
2468 file_ptr stabstroffset
, unsigned int stabstrsize
)
2471 bfd
*sym_bfd
= objfile
->obfd
;
2472 char *name
= bfd_get_filename (sym_bfd
);
2473 struct dbx_symfile_info
*info
;
2474 unsigned int stabsize
;
2476 /* There is already a dbx_symfile_info allocated by our caller.
2477 It might even contain some info from the coff symtab to help us. */
2478 info
= objfile
->sym_stab_info
;
2480 DBX_TEXT_ADDR (objfile
) = textaddr
;
2481 DBX_TEXT_SIZE (objfile
) = textsize
;
2483 #define COFF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2484 DBX_SYMBOL_SIZE (objfile
) = COFF_STABS_SYMBOL_SIZE
;
2485 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2487 if (stabstrsize
> bfd_get_size (sym_bfd
))
2488 error ("ridiculous string table size: %d bytes", stabstrsize
);
2489 DBX_STRINGTAB (objfile
) = (char *)
2490 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2491 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2493 /* Now read in the string table in one big gulp. */
2495 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2497 perror_with_name (name
);
2498 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2499 if (val
!= stabstrsize
)
2500 perror_with_name (name
);
2502 stabsread_new_init ();
2503 buildsym_new_init ();
2504 free_header_files ();
2505 init_header_files ();
2507 processing_acc_compilation
= 1;
2509 /* In a coff file, we've already installed the minimal symbols that came
2510 from the coff (non-stab) symbol table, so always act like an
2511 incremental load here. */
2512 if (stabsects
->next
== NULL
)
2514 stabsize
= bfd_section_size (sym_bfd
, stabsects
->section
);
2515 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2516 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2520 struct stab_section_list
*stabsect
;
2522 DBX_SYMCOUNT (objfile
) = 0;
2523 for (stabsect
= stabsects
; stabsect
!= NULL
; stabsect
= stabsect
->next
)
2525 stabsize
= bfd_section_size (sym_bfd
, stabsect
->section
);
2526 DBX_SYMCOUNT (objfile
) += stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2529 DBX_SYMTAB_OFFSET (objfile
) = stabsects
->section
->filepos
;
2531 symbuf_sections
= stabsects
->next
;
2532 symbuf_left
= bfd_section_size (sym_bfd
, stabsects
->section
);
2536 dbx_symfile_read (objfile
, 0);
2539 /* Scan and build partial symbols for an ELF symbol file.
2540 This ELF file has already been processed to get its minimal symbols,
2541 and any DWARF symbols that were in it.
2543 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2546 OBJFILE is the object file we are reading symbols from.
2547 ADDR is the address relative to which the symbols are (e.g.
2548 the base address of the text segment).
2549 MAINLINE is true if we are reading the main symbol
2550 table (as opposed to a shared lib or dynamically loaded file).
2551 STABOFFSET and STABSIZE define the location in OBJFILE where the .stab
2553 STABSTROFFSET and STABSTRSIZE define the location in OBJFILE where the
2554 .stabstr section exists.
2556 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read,
2557 adjusted for elf details. */
2560 elfstab_build_psymtabs (struct objfile
*objfile
, int mainline
,
2561 file_ptr staboffset
, unsigned int stabsize
,
2562 file_ptr stabstroffset
, unsigned int stabstrsize
)
2565 bfd
*sym_bfd
= objfile
->obfd
;
2566 char *name
= bfd_get_filename (sym_bfd
);
2567 struct dbx_symfile_info
*info
;
2569 /* There is already a dbx_symfile_info allocated by our caller.
2570 It might even contain some info from the ELF symtab to help us. */
2571 info
= objfile
->sym_stab_info
;
2573 /* Find the first and last text address. dbx_symfile_read seems to
2575 find_text_range (sym_bfd
, objfile
);
2577 #define ELF_STABS_SYMBOL_SIZE 12 /* XXX FIXME XXX */
2578 DBX_SYMBOL_SIZE (objfile
) = ELF_STABS_SYMBOL_SIZE
;
2579 DBX_SYMCOUNT (objfile
) = stabsize
/ DBX_SYMBOL_SIZE (objfile
);
2580 DBX_STRINGTAB_SIZE (objfile
) = stabstrsize
;
2581 DBX_SYMTAB_OFFSET (objfile
) = staboffset
;
2583 if (stabstrsize
> bfd_get_size (sym_bfd
))
2584 error ("ridiculous string table size: %d bytes", stabstrsize
);
2585 DBX_STRINGTAB (objfile
) = (char *)
2586 obstack_alloc (&objfile
->psymbol_obstack
, stabstrsize
+ 1);
2587 OBJSTAT (objfile
, sz_strtab
+= stabstrsize
+ 1);
2589 /* Now read in the string table in one big gulp. */
2591 val
= bfd_seek (sym_bfd
, stabstroffset
, SEEK_SET
);
2593 perror_with_name (name
);
2594 val
= bfd_read (DBX_STRINGTAB (objfile
), stabstrsize
, 1, sym_bfd
);
2595 if (val
!= stabstrsize
)
2596 perror_with_name (name
);
2598 stabsread_new_init ();
2599 buildsym_new_init ();
2600 free_header_files ();
2601 init_header_files ();
2602 install_minimal_symbols (objfile
);
2604 processing_acc_compilation
= 1;
2606 /* In an elf file, we've already installed the minimal symbols that came
2607 from the elf (non-stab) symbol table, so always act like an
2608 incremental load here. */
2609 dbx_symfile_read (objfile
, 0);
2612 /* Scan and build partial symbols for a file with special sections for stabs
2613 and stabstrings. The file has already been processed to get its minimal
2614 symbols, and any other symbols that might be necessary to resolve GSYMs.
2616 This routine is the equivalent of dbx_symfile_init and dbx_symfile_read
2619 OBJFILE is the object file we are reading symbols from.
2620 ADDR is the address relative to which the symbols are (e.g. the base address
2621 of the text segment).
2622 MAINLINE is true if we are reading the main symbol table (as opposed to a
2623 shared lib or dynamically loaded file).
2624 STAB_NAME is the name of the section that contains the stabs.
2625 STABSTR_NAME is the name of the section that contains the stab strings.
2627 This routine is mostly copied from dbx_symfile_init and dbx_symfile_read. */
2630 stabsect_build_psymtabs (struct objfile
*objfile
, int mainline
, char *stab_name
,
2631 char *stabstr_name
, char *text_name
)
2634 bfd
*sym_bfd
= objfile
->obfd
;
2635 char *name
= bfd_get_filename (sym_bfd
);
2637 asection
*stabstrsect
;
2638 asection
*text_sect
;
2640 stabsect
= bfd_get_section_by_name (sym_bfd
, stab_name
);
2641 stabstrsect
= bfd_get_section_by_name (sym_bfd
, stabstr_name
);
2647 error ("stabsect_build_psymtabs: Found stabs (%s), but not string section (%s)",
2648 stab_name
, stabstr_name
);
2650 objfile
->sym_stab_info
= (struct dbx_symfile_info
*)
2651 xmalloc (sizeof (struct dbx_symfile_info
));
2652 memset (objfile
->sym_stab_info
, 0, sizeof (struct dbx_symfile_info
));
2654 text_sect
= bfd_get_section_by_name (sym_bfd
, text_name
);
2656 error ("Can't find %s section in symbol file", text_name
);
2657 DBX_TEXT_ADDR (objfile
) = bfd_section_vma (sym_bfd
, text_sect
);
2658 DBX_TEXT_SIZE (objfile
) = bfd_section_size (sym_bfd
, text_sect
);
2660 DBX_SYMBOL_SIZE (objfile
) = sizeof (struct external_nlist
);
2661 DBX_SYMCOUNT (objfile
) = bfd_section_size (sym_bfd
, stabsect
)
2662 / DBX_SYMBOL_SIZE (objfile
);
2663 DBX_STRINGTAB_SIZE (objfile
) = bfd_section_size (sym_bfd
, stabstrsect
);
2664 DBX_SYMTAB_OFFSET (objfile
) = stabsect
->filepos
; /* XXX - FIXME: POKING INSIDE BFD DATA STRUCTURES */
2666 if (DBX_STRINGTAB_SIZE (objfile
) > bfd_get_size (sym_bfd
))
2667 error ("ridiculous string table size: %d bytes", DBX_STRINGTAB_SIZE (objfile
));
2668 DBX_STRINGTAB (objfile
) = (char *)
2669 obstack_alloc (&objfile
->psymbol_obstack
, DBX_STRINGTAB_SIZE (objfile
) + 1);
2670 OBJSTAT (objfile
, sz_strtab
+= DBX_STRINGTAB_SIZE (objfile
) + 1);
2672 /* Now read in the string table in one big gulp. */
2674 val
= bfd_get_section_contents (sym_bfd
, /* bfd */
2675 stabstrsect
, /* bfd section */
2676 DBX_STRINGTAB (objfile
), /* input buffer */
2677 0, /* offset into section */
2678 DBX_STRINGTAB_SIZE (objfile
)); /* amount to read */
2681 perror_with_name (name
);
2683 stabsread_new_init ();
2684 buildsym_new_init ();
2685 free_header_files ();
2686 init_header_files ();
2687 install_minimal_symbols (objfile
);
2689 /* Now, do an incremental load */
2691 processing_acc_compilation
= 1;
2692 dbx_symfile_read (objfile
, 0);
2695 static struct sym_fns aout_sym_fns
=
2697 bfd_target_aout_flavour
,
2698 dbx_new_init
, /* sym_new_init: init anything gbl to entire symtab */
2699 dbx_symfile_init
, /* sym_init: read initial info, setup for sym_read() */
2700 dbx_symfile_read
, /* sym_read: read a symbol file into symtab */
2701 dbx_symfile_finish
, /* sym_finish: finished with file, cleanup */
2702 default_symfile_offsets
, /* sym_offsets: parse user's offsets to internal form */
2703 NULL
/* next: pointer to next struct sym_fns */
2707 _initialize_dbxread (void)
2709 add_symtab_fns (&aout_sym_fns
);